Line data Source code
1 : /*
2 : * Copyright (C) 2004-2026 Savoir-faire Linux Inc.
3 : *
4 : * This program is free software: you can redistribute it and/or modify
5 : * it under the terms of the GNU General Public License as published by
6 : * the Free Software Foundation, either version 3 of the License, or
7 : * (at your option) any later version.
8 : *
9 : * This program is distributed in the hope that it will be useful,
10 : * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 : * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 : * GNU General Public License for more details.
13 : *
14 : * You should have received a copy of the GNU General Public License
15 : * along with this program. If not, see <https://www.gnu.org/licenses/>.
16 : */
17 :
18 : #include "media/media_attribute.h"
19 : #include "jami/media_const.h"
20 : #include "logger.h"
21 : #include "string_utils.h"
22 :
23 : namespace jami {
24 :
25 1044 : MediaAttribute::MediaAttribute(const libjami::MediaMap& mediaMap, bool secure)
26 : {
27 1044 : std::pair<bool, MediaType> pairType = getMediaType(mediaMap);
28 1044 : if (pairType.first)
29 1044 : type_ = pairType.second;
30 :
31 1044 : std::pair<bool, bool> pairBool;
32 :
33 1044 : pairBool = getBoolValue(mediaMap, libjami::Media::MediaAttributeKey::MUTED);
34 1044 : if (pairBool.first)
35 1044 : muted_ = pairBool.second;
36 :
37 1044 : pairBool = getBoolValue(mediaMap, libjami::Media::MediaAttributeKey::ENABLED);
38 1044 : if (pairBool.first)
39 1044 : enabled_ = pairBool.second;
40 :
41 1044 : std::pair<bool, std::string> pairString;
42 1044 : pairString = getStringValue(mediaMap, libjami::Media::MediaAttributeKey::SOURCE);
43 1044 : if (pairBool.first)
44 1044 : sourceUri_ = pairString.second;
45 :
46 1044 : pairString = getStringValue(mediaMap, libjami::Media::MediaAttributeKey::LABEL);
47 1044 : if (pairBool.first)
48 1044 : label_ = pairString.second;
49 :
50 1044 : pairBool = getBoolValue(mediaMap, libjami::Media::MediaAttributeKey::HOLD);
51 1044 : if (pairBool.first)
52 1016 : hold_ = pairBool.second;
53 :
54 1044 : secure_ = secure;
55 1044 : }
56 :
57 : std::vector<MediaAttribute>
58 641 : MediaAttribute::buildMediaAttributesList(const std::vector<libjami::MediaMap>& mediaList, bool secure)
59 : {
60 641 : std::vector<MediaAttribute> mediaAttrList;
61 641 : mediaAttrList.reserve(mediaList.size());
62 :
63 1685 : for (auto const& mediaMap : mediaList) {
64 1044 : mediaAttrList.emplace_back(MediaAttribute(mediaMap, secure));
65 : }
66 :
67 641 : return mediaAttrList;
68 0 : }
69 :
70 : MediaType
71 1048 : MediaAttribute::stringToMediaType(const std::string& mediaType)
72 : {
73 1048 : if (mediaType.compare(libjami::Media::MediaAttributeValue::AUDIO) == 0)
74 580 : return MediaType::MEDIA_AUDIO;
75 468 : if (mediaType.compare(libjami::Media::MediaAttributeValue::VIDEO) == 0)
76 468 : return MediaType::MEDIA_VIDEO;
77 0 : return MediaType::MEDIA_NONE;
78 : }
79 :
80 : std::pair<bool, MediaType>
81 1044 : MediaAttribute::getMediaType(const libjami::MediaMap& map)
82 : {
83 1044 : const auto& iter = map.find(libjami::Media::MediaAttributeKey::MEDIA_TYPE);
84 1044 : if (iter == map.end()) {
85 0 : return {false, MediaType::MEDIA_NONE};
86 : }
87 :
88 1044 : auto type = stringToMediaType(iter->second);
89 1044 : if (type == MediaType::MEDIA_NONE) {
90 0 : JAMI_ERROR("Invalid value [{}] for a media type key in media map", iter->second);
91 0 : return {false, type};
92 : }
93 :
94 1044 : return {true, type};
95 : }
96 :
97 : std::pair<bool, bool>
98 3132 : MediaAttribute::getBoolValue(const libjami::MediaMap& map, const std::string& key)
99 : {
100 3132 : const auto& iter = map.find(key);
101 3132 : if (iter == map.end()) {
102 28 : return {false, false};
103 : }
104 :
105 3104 : auto const& value = iter->second;
106 3104 : if (value.compare(TRUE_STR) == 0)
107 1075 : return {true, true};
108 2029 : if (value.compare(FALSE_STR) == 0)
109 2029 : return {true, false};
110 :
111 0 : JAMI_ERROR("Invalid value {} for a boolean key", value);
112 0 : return {false, false};
113 : }
114 :
115 : std::pair<bool, std::string>
116 2088 : MediaAttribute::getStringValue(const libjami::MediaMap& map, const std::string& key)
117 : {
118 2088 : const auto& iter = map.find(key);
119 2088 : if (iter == map.end()) {
120 0 : return {false, {}};
121 : }
122 :
123 2088 : return {true, iter->second};
124 : }
125 :
126 : char const*
127 5448 : MediaAttribute::boolToString(bool val)
128 : {
129 5448 : return val ? TRUE_STR : FALSE_STR;
130 : }
131 :
132 : char const*
133 2146 : MediaAttribute::mediaTypeToString(MediaType type)
134 : {
135 2146 : if (type == MediaType::MEDIA_AUDIO)
136 1144 : return libjami::Media::MediaAttributeValue::AUDIO;
137 1002 : if (type == MediaType::MEDIA_VIDEO)
138 950 : return libjami::Media::MediaAttributeValue::VIDEO;
139 52 : if (type == MediaType::MEDIA_NONE)
140 52 : return libjami::Media::MediaAttributeValue::SRC_TYPE_NONE;
141 0 : return "UNKNOWN";
142 : }
143 :
144 : bool
145 109 : MediaAttribute::hasMediaType(const std::vector<MediaAttribute>& mediaList, MediaType type)
146 : {
147 218 : return mediaList.end() != std::find_if(mediaList.begin(), mediaList.end(), [type](const MediaAttribute& media) {
148 137 : return media.type_ == type;
149 218 : });
150 : }
151 :
152 : libjami::MediaMap
153 1816 : MediaAttribute::toMediaMap(const MediaAttribute& mediaAttr)
154 : {
155 1816 : libjami::MediaMap mediaMap;
156 :
157 1816 : mediaMap.emplace(libjami::Media::MediaAttributeKey::MEDIA_TYPE, mediaTypeToString(mediaAttr.type_));
158 1816 : mediaMap.emplace(libjami::Media::MediaAttributeKey::LABEL, mediaAttr.label_);
159 1816 : mediaMap.emplace(libjami::Media::MediaAttributeKey::ENABLED, boolToString(mediaAttr.enabled_));
160 1816 : mediaMap.emplace(libjami::Media::MediaAttributeKey::MUTED, boolToString(mediaAttr.muted_));
161 1816 : mediaMap.emplace(libjami::Media::MediaAttributeKey::SOURCE, mediaAttr.sourceUri_);
162 1816 : mediaMap.emplace(libjami::Media::MediaAttributeKey::HOLD, boolToString(mediaAttr.hold_));
163 :
164 1816 : return mediaMap;
165 0 : }
166 :
167 : std::vector<libjami::MediaMap>
168 985 : MediaAttribute::mediaAttributesToMediaMaps(const std::vector<MediaAttribute>& mediaAttrList)
169 : {
170 985 : std::vector<libjami::MediaMap> mediaList;
171 985 : mediaList.reserve(mediaAttrList.size());
172 2796 : for (auto const& media : mediaAttrList) {
173 1811 : mediaList.emplace_back(toMediaMap(media));
174 : }
175 :
176 985 : return mediaList;
177 0 : }
178 :
179 : std::string
180 2643 : MediaAttribute::toString(bool full) const
181 : {
182 2643 : std::ostringstream descr;
183 2643 : descr << "type " << (type_ == MediaType::MEDIA_AUDIO ? "[AUDIO]" : "[VIDEO]");
184 2643 : descr << " ";
185 2643 : descr << "enabled " << (enabled_ ? "[YES]" : "[NO]");
186 2643 : descr << " ";
187 2643 : descr << "muted " << (muted_ ? "[YES]" : "[NO]");
188 2643 : descr << " ";
189 2643 : descr << "label [" << label_ << "]";
190 :
191 2643 : if (full) {
192 2179 : descr << " ";
193 2179 : descr << "source [" << sourceUri_ << "]";
194 2179 : descr << " ";
195 2179 : descr << "secure " << (secure_ ? "[YES]" : "[NO]");
196 : }
197 :
198 5286 : return descr.str();
199 2643 : }
200 :
201 : bool
202 4460 : MediaAttribute::hasValidVideo()
203 : {
204 4460 : return type_ == MediaType::MEDIA_VIDEO && enabled_ && !muted_ && !hold_;
205 : }
206 : } // namespace jami
|
