1 /* 2 * libjingle 3 * Copyright 2011 Google Inc. 4 * 5 * Redistribution and use in source and binary forms, with or without 6 * modification, are permitted provided that the following conditions are met: 7 * 8 * 1. Redistributions of source code must retain the above copyright notice, 9 * this list of conditions and the following disclaimer. 10 * 2. Redistributions in binary form must reproduce the above copyright notice, 11 * this list of conditions and the following disclaimer in the documentation 12 * and/or other materials provided with the distribution. 13 * 3. The name of the author may not be used to endorse or promote products 14 * derived from this software without specific prior written permission. 15 * 16 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED 17 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF 18 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO 19 * EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 20 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, 21 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; 22 * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, 23 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR 24 * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF 25 * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 26 */ 27 28 #include "talk/media/base/streamparams.h" 29 30 #include <list> 31 #include <sstream> 32 33 namespace cricket { 34 35 const char kFecSsrcGroupSemantics[] = "FEC"; 36 const char kFidSsrcGroupSemantics[] = "FID"; 37 const char kSimSsrcGroupSemantics[] = "SIM"; 38 39 static std::string SsrcsToString(const std::vector<uint32>& ssrcs) { 40 std::ostringstream ost; 41 ost << "ssrcs:["; 42 for (std::vector<uint32>::const_iterator it = ssrcs.begin(); 43 it != ssrcs.end(); ++it) { 44 if (it != ssrcs.begin()) { 45 ost << ","; 46 } 47 ost << *it; 48 } 49 ost << "]"; 50 return ost.str(); 51 } 52 53 bool SsrcGroup::has_semantics(const std::string& semantics_in) const { 54 return (semantics == semantics_in && ssrcs.size() > 0); 55 } 56 57 std::string SsrcGroup::ToString() const { 58 std::ostringstream ost; 59 ost << "{"; 60 ost << "semantics:" << semantics << ";"; 61 ost << SsrcsToString(ssrcs); 62 ost << "}"; 63 return ost.str(); 64 } 65 66 std::string StreamParams::ToString() const { 67 std::ostringstream ost; 68 ost << "{"; 69 if (!groupid.empty()) { 70 ost << "groupid:" << groupid << ";"; 71 } 72 if (!id.empty()) { 73 ost << "id:" << id << ";"; 74 } 75 ost << SsrcsToString(ssrcs) << ";"; 76 ost << "ssrc_groups:"; 77 for (std::vector<SsrcGroup>::const_iterator it = ssrc_groups.begin(); 78 it != ssrc_groups.end(); ++it) { 79 if (it != ssrc_groups.begin()) { 80 ost << ","; 81 } 82 ost << it->ToString(); 83 } 84 ost << ";"; 85 if (!type.empty()) { 86 ost << "type:" << type << ";"; 87 } 88 if (!display.empty()) { 89 ost << "display:" << display << ";"; 90 } 91 if (!cname.empty()) { 92 ost << "cname:" << cname << ";"; 93 } 94 if (!sync_label.empty()) { 95 ost << "sync_label:" << sync_label; 96 } 97 ost << "}"; 98 return ost.str(); 99 } 100 101 bool StreamParams::AddSecondarySsrc(const std::string& semantics, 102 uint32 primary_ssrc, 103 uint32 secondary_ssrc) { 104 if (!has_ssrc(primary_ssrc)) { 105 return false; 106 } 107 108 ssrcs.push_back(secondary_ssrc); 109 std::vector<uint32> ssrc_vector; 110 ssrc_vector.push_back(primary_ssrc); 111 ssrc_vector.push_back(secondary_ssrc); 112 SsrcGroup ssrc_group = SsrcGroup(semantics, ssrc_vector); 113 ssrc_groups.push_back(ssrc_group); 114 return true; 115 } 116 117 bool StreamParams::GetSecondarySsrc(const std::string& semantics, 118 uint32 primary_ssrc, 119 uint32* secondary_ssrc) const { 120 for (std::vector<SsrcGroup>::const_iterator it = ssrc_groups.begin(); 121 it != ssrc_groups.end(); ++it) { 122 if (it->has_semantics(semantics) && 123 it->ssrcs.size() >= 2 && 124 it->ssrcs[0] == primary_ssrc) { 125 *secondary_ssrc = it->ssrcs[1]; 126 return true; 127 } 128 } 129 return false; 130 } 131 132 bool GetStream(const StreamParamsVec& streams, 133 const StreamSelector& selector, 134 StreamParams* stream_out) { 135 for (StreamParamsVec::const_iterator stream = streams.begin(); 136 stream != streams.end(); ++stream) { 137 if (selector.Matches(*stream)) { 138 if (stream_out != NULL) { 139 *stream_out = *stream; 140 } 141 return true; 142 } 143 } 144 return false; 145 } 146 147 bool GetStreamBySsrc(const StreamParamsVec& streams, uint32 ssrc, 148 StreamParams* stream_out) { 149 return GetStream(streams, StreamSelector(ssrc), stream_out); 150 } 151 152 bool GetStreamByIds(const StreamParamsVec& streams, 153 const std::string& groupid, 154 const std::string& id, 155 StreamParams* stream_out) { 156 return GetStream(streams, StreamSelector(groupid, id), stream_out); 157 } 158 159 bool RemoveStream(StreamParamsVec* streams, 160 const StreamSelector& selector) { 161 bool ret = false; 162 for (StreamParamsVec::iterator stream = streams->begin(); 163 stream != streams->end(); ) { 164 if (selector.Matches(*stream)) { 165 stream = streams->erase(stream); 166 ret = true; 167 } else { 168 ++stream; 169 } 170 } 171 return ret; 172 } 173 174 bool RemoveStreamBySsrc(StreamParamsVec* streams, uint32 ssrc) { 175 return RemoveStream(streams, StreamSelector(ssrc)); 176 } 177 178 bool RemoveStreamByIds(StreamParamsVec* streams, 179 const std::string& groupid, 180 const std::string& id) { 181 return RemoveStream(streams, StreamSelector(groupid, id)); 182 } 183 184 bool IsOneSsrcStream(const StreamParams& sp) { 185 if (sp.ssrcs.size() == 1 && sp.ssrc_groups.empty()) { 186 return true; 187 } 188 if (sp.ssrcs.size() == 2) { 189 const SsrcGroup* fid_group = sp.get_ssrc_group(kFidSsrcGroupSemantics); 190 if (fid_group != NULL) { 191 return (sp.ssrcs == fid_group->ssrcs); 192 } 193 } 194 return false; 195 } 196 197 static void RemoveFirst(std::list<uint32>* ssrcs, uint32 value) { 198 std::list<uint32>::iterator it = 199 std::find(ssrcs->begin(), ssrcs->end(), value); 200 if (it != ssrcs->end()) { 201 ssrcs->erase(it); 202 } 203 } 204 205 bool IsSimulcastStream(const StreamParams& sp) { 206 const SsrcGroup* const sg = sp.get_ssrc_group(kSimSsrcGroupSemantics); 207 if (sg == NULL || sg->ssrcs.size() < 2) { 208 return false; 209 } 210 // Start with all StreamParams SSRCs. Remove simulcast SSRCs (from sg) and 211 // RTX SSRCs. If we still have SSRCs left, we don't know what they're for. 212 // Also we remove first-found SSRCs only. So duplicates should lead to errors. 213 std::list<uint32> sp_ssrcs(sp.ssrcs.begin(), sp.ssrcs.end()); 214 for (size_t i = 0; i < sg->ssrcs.size(); ++i) { 215 RemoveFirst(&sp_ssrcs, sg->ssrcs[i]); 216 } 217 for (size_t i = 0; i < sp.ssrc_groups.size(); ++i) { 218 const SsrcGroup& group = sp.ssrc_groups[i]; 219 if (group.semantics.compare(kFidSsrcGroupSemantics) != 0 || 220 group.ssrcs.size() != 2) { 221 continue; 222 } 223 RemoveFirst(&sp_ssrcs, group.ssrcs[1]); 224 } 225 // If there's SSRCs left that we don't know how to handle, we bail out. 226 return sp_ssrcs.size() == 0; 227 } 228 229 } // namespace cricket 230
