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 1107 : MediaAttribute::MediaAttribute(const libjami::MediaMap& mediaMap, bool secure)
26 : {
27 1107 : std::pair<bool, MediaType> pairType = getMediaType(mediaMap);
28 1107 : if (pairType.first)
29 1107 : type_ = pairType.second;
30 :
31 1107 : std::pair<bool, bool> pairBool;
32 :
33 1107 : pairBool = getBoolValue(mediaMap, libjami::Media::MediaAttributeKey::MUTED);
34 1107 : if (pairBool.first)
35 1107 : muted_ = pairBool.second;
36 :
37 1107 : pairBool = getBoolValue(mediaMap, libjami::Media::MediaAttributeKey::ENABLED);
38 1107 : if (pairBool.first)
39 1107 : enabled_ = pairBool.second;
40 :
41 1107 : std::pair<bool, std::string> pairString;
42 1107 : pairString = getStringValue(mediaMap, libjami::Media::MediaAttributeKey::SOURCE);
43 1107 : if (pairBool.first)
44 1107 : sourceUri_ = pairString.second;
45 :
46 1107 : pairString = getStringValue(mediaMap, libjami::Media::MediaAttributeKey::LABEL);
47 1107 : if (pairBool.first)
48 1107 : label_ = pairString.second;
49 :
50 1107 : pairBool = getBoolValue(mediaMap, libjami::Media::MediaAttributeKey::HOLD);
51 1107 : if (pairBool.first)
52 1058 : hold_ = pairBool.second;
53 :
54 1107 : secure_ = secure;
55 1107 : }
56 :
57 : std::vector<MediaAttribute>
58 681 : MediaAttribute::buildMediaAttributesList(const std::vector<libjami::MediaMap>& mediaList, bool secure)
59 : {
60 681 : std::vector<MediaAttribute> mediaAttrList;
61 681 : mediaAttrList.reserve(mediaList.size());
62 :
63 1788 : for (auto const& mediaMap : mediaList) {
64 1107 : mediaAttrList.emplace_back(MediaAttribute(mediaMap, secure));
65 : }
66 :
67 681 : return mediaAttrList;
68 0 : }
69 :
70 : MediaType
71 1111 : MediaAttribute::stringToMediaType(const std::string& mediaType)
72 : {
73 1111 : if (mediaType.compare(libjami::Media::MediaAttributeValue::AUDIO) == 0)
74 619 : return MediaType::MEDIA_AUDIO;
75 492 : if (mediaType.compare(libjami::Media::MediaAttributeValue::VIDEO) == 0)
76 492 : return MediaType::MEDIA_VIDEO;
77 0 : return MediaType::MEDIA_NONE;
78 : }
79 :
80 : std::pair<bool, MediaType>
81 1107 : MediaAttribute::getMediaType(const libjami::MediaMap& map)
82 : {
83 1107 : const auto& iter = map.find(libjami::Media::MediaAttributeKey::MEDIA_TYPE);
84 1107 : if (iter == map.end()) {
85 0 : return {false, MediaType::MEDIA_NONE};
86 : }
87 :
88 1107 : auto type = stringToMediaType(iter->second);
89 1107 : 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 1107 : return {true, type};
95 : }
96 :
97 : std::pair<bool, bool>
98 3321 : MediaAttribute::getBoolValue(const libjami::MediaMap& map, const std::string& key)
99 : {
100 3321 : const auto& iter = map.find(key);
101 3321 : if (iter == map.end()) {
102 49 : return {false, false};
103 : }
104 :
105 3272 : auto const& value = iter->second;
106 3272 : if (value.compare(TRUE_STR) == 0)
107 1143 : return {true, true};
108 2129 : if (value.compare(FALSE_STR) == 0)
109 2129 : 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 2214 : MediaAttribute::getStringValue(const libjami::MediaMap& map, const std::string& key)
117 : {
118 2214 : const auto& iter = map.find(key);
119 2214 : if (iter == map.end()) {
120 0 : return {false, {}};
121 : }
122 :
123 2214 : return {true, iter->second};
124 : }
125 :
126 : char const*
127 5712 : MediaAttribute::boolToString(bool val)
128 : {
129 5712 : return val ? TRUE_STR : FALSE_STR;
130 : }
131 :
132 : char const*
133 2271 : MediaAttribute::mediaTypeToString(MediaType type)
134 : {
135 2271 : if (type == MediaType::MEDIA_AUDIO)
136 1219 : return libjami::Media::MediaAttributeValue::AUDIO;
137 1052 : if (type == MediaType::MEDIA_VIDEO)
138 1000 : 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 110 : MediaAttribute::hasMediaType(const std::vector<MediaAttribute>& mediaList, MediaType type)
146 : {
147 220 : return mediaList.end() != std::find_if(mediaList.begin(), mediaList.end(), [type](const MediaAttribute& media) {
148 138 : return media.type_ == type;
149 220 : });
150 : }
151 :
152 : libjami::MediaMap
153 1904 : MediaAttribute::toMediaMap(const MediaAttribute& mediaAttr)
154 : {
155 1904 : libjami::MediaMap mediaMap;
156 :
157 1904 : mediaMap.emplace(libjami::Media::MediaAttributeKey::MEDIA_TYPE, mediaTypeToString(mediaAttr.type_));
158 1904 : mediaMap.emplace(libjami::Media::MediaAttributeKey::LABEL, mediaAttr.label_);
159 1904 : mediaMap.emplace(libjami::Media::MediaAttributeKey::ENABLED, boolToString(mediaAttr.enabled_));
160 1904 : mediaMap.emplace(libjami::Media::MediaAttributeKey::MUTED, boolToString(mediaAttr.muted_));
161 1904 : mediaMap.emplace(libjami::Media::MediaAttributeKey::SOURCE, mediaAttr.sourceUri_);
162 1904 : mediaMap.emplace(libjami::Media::MediaAttributeKey::HOLD, boolToString(mediaAttr.hold_));
163 :
164 1904 : return mediaMap;
165 0 : }
166 :
167 : std::vector<libjami::MediaMap>
168 1040 : MediaAttribute::mediaAttributesToMediaMaps(const std::vector<MediaAttribute>& mediaAttrList)
169 : {
170 1040 : std::vector<libjami::MediaMap> mediaList;
171 1040 : mediaList.reserve(mediaAttrList.size());
172 2939 : for (auto const& media : mediaAttrList) {
173 1899 : mediaList.emplace_back(toMediaMap(media));
174 : }
175 :
176 1040 : return mediaList;
177 0 : }
178 :
179 : std::string
180 2803 : MediaAttribute::toString(bool full) const
181 : {
182 2803 : std::ostringstream descr;
183 2803 : descr << "type " << (type_ == MediaType::MEDIA_AUDIO ? "[AUDIO]" : "[VIDEO]");
184 2803 : descr << " ";
185 2803 : descr << "enabled " << (enabled_ ? "[YES]" : "[NO]");
186 2803 : descr << " ";
187 2803 : descr << "muted " << (muted_ ? "[YES]" : "[NO]");
188 2803 : descr << " ";
189 2803 : descr << "label [" << label_ << "]";
190 :
191 2803 : if (full) {
192 2309 : descr << " ";
193 2309 : descr << "source [" << sourceUri_ << "]";
194 2309 : descr << " ";
195 2309 : descr << "secure " << (secure_ ? "[YES]" : "[NO]");
196 : }
197 :
198 5606 : return descr.str();
199 2803 : }
200 :
201 : bool
202 4790 : MediaAttribute::hasValidVideo()
203 : {
204 4790 : return type_ == MediaType::MEDIA_VIDEO && enabled_ && !muted_ && !hold_;
205 : }
206 : } // namespace jami
|
