245 lines
6.9 KiB
C++
245 lines
6.9 KiB
C++
/*
|
|
* Copyright (c) 2011 The WebRTC project authors. All Rights Reserved.
|
|
*
|
|
* Use of this source code is governed by a BSD-style license
|
|
* that can be found in the LICENSE file in the root of the source
|
|
* tree. An additional intellectual property rights grant can be found
|
|
* in the file PATENTS. All contributing project authors may
|
|
* be found in the AUTHORS file in the root of the source tree.
|
|
*/
|
|
|
|
#include "webrtc/media/base/streamparams.h"
|
|
|
|
#include <list>
|
|
#include <sstream>
|
|
|
|
namespace cricket {
|
|
namespace {
|
|
// NOTE: There is no check here for duplicate streams, so check before
|
|
// adding.
|
|
void AddStream(std::vector<StreamParams>* streams, const StreamParams& stream) {
|
|
streams->push_back(stream);
|
|
}
|
|
}
|
|
|
|
const char kFecSsrcGroupSemantics[] = "FEC";
|
|
const char kFidSsrcGroupSemantics[] = "FID";
|
|
const char kSimSsrcGroupSemantics[] = "SIM";
|
|
|
|
bool GetStream(const StreamParamsVec& streams,
|
|
const StreamSelector& selector,
|
|
StreamParams* stream_out) {
|
|
const StreamParams* found = GetStream(streams, selector);
|
|
if (found && stream_out)
|
|
*stream_out = *found;
|
|
return found != nullptr;
|
|
}
|
|
|
|
bool MediaStreams::GetAudioStream(
|
|
const StreamSelector& selector, StreamParams* stream) {
|
|
return GetStream(audio_, selector, stream);
|
|
}
|
|
|
|
bool MediaStreams::GetVideoStream(
|
|
const StreamSelector& selector, StreamParams* stream) {
|
|
return GetStream(video_, selector, stream);
|
|
}
|
|
|
|
bool MediaStreams::GetDataStream(
|
|
const StreamSelector& selector, StreamParams* stream) {
|
|
return GetStream(data_, selector, stream);
|
|
}
|
|
|
|
void MediaStreams::CopyFrom(const MediaStreams& streams) {
|
|
audio_ = streams.audio_;
|
|
video_ = streams.video_;
|
|
data_ = streams.data_;
|
|
}
|
|
|
|
void MediaStreams::AddAudioStream(const StreamParams& stream) {
|
|
AddStream(&audio_, stream);
|
|
}
|
|
|
|
void MediaStreams::AddVideoStream(const StreamParams& stream) {
|
|
AddStream(&video_, stream);
|
|
}
|
|
|
|
void MediaStreams::AddDataStream(const StreamParams& stream) {
|
|
AddStream(&data_, stream);
|
|
}
|
|
|
|
bool MediaStreams::RemoveAudioStream(
|
|
const StreamSelector& selector) {
|
|
return RemoveStream(&audio_, selector);
|
|
}
|
|
|
|
bool MediaStreams::RemoveVideoStream(
|
|
const StreamSelector& selector) {
|
|
return RemoveStream(&video_, selector);
|
|
}
|
|
|
|
bool MediaStreams::RemoveDataStream(
|
|
const StreamSelector& selector) {
|
|
return RemoveStream(&data_, selector);
|
|
}
|
|
|
|
static std::string SsrcsToString(const std::vector<uint32_t>& ssrcs) {
|
|
std::ostringstream ost;
|
|
ost << "ssrcs:[";
|
|
for (std::vector<uint32_t>::const_iterator it = ssrcs.begin();
|
|
it != ssrcs.end(); ++it) {
|
|
if (it != ssrcs.begin()) {
|
|
ost << ",";
|
|
}
|
|
ost << *it;
|
|
}
|
|
ost << "]";
|
|
return ost.str();
|
|
}
|
|
|
|
bool SsrcGroup::has_semantics(const std::string& semantics_in) const {
|
|
return (semantics == semantics_in && ssrcs.size() > 0);
|
|
}
|
|
|
|
std::string SsrcGroup::ToString() const {
|
|
std::ostringstream ost;
|
|
ost << "{";
|
|
ost << "semantics:" << semantics << ";";
|
|
ost << SsrcsToString(ssrcs);
|
|
ost << "}";
|
|
return ost.str();
|
|
}
|
|
|
|
std::string StreamParams::ToString() const {
|
|
std::ostringstream ost;
|
|
ost << "{";
|
|
if (!groupid.empty()) {
|
|
ost << "groupid:" << groupid << ";";
|
|
}
|
|
if (!id.empty()) {
|
|
ost << "id:" << id << ";";
|
|
}
|
|
ost << SsrcsToString(ssrcs) << ";";
|
|
ost << "ssrc_groups:";
|
|
for (std::vector<SsrcGroup>::const_iterator it = ssrc_groups.begin();
|
|
it != ssrc_groups.end(); ++it) {
|
|
if (it != ssrc_groups.begin()) {
|
|
ost << ",";
|
|
}
|
|
ost << it->ToString();
|
|
}
|
|
ost << ";";
|
|
if (!type.empty()) {
|
|
ost << "type:" << type << ";";
|
|
}
|
|
if (!display.empty()) {
|
|
ost << "display:" << display << ";";
|
|
}
|
|
if (!cname.empty()) {
|
|
ost << "cname:" << cname << ";";
|
|
}
|
|
if (!sync_label.empty()) {
|
|
ost << "sync_label:" << sync_label;
|
|
}
|
|
ost << "}";
|
|
return ost.str();
|
|
}
|
|
void StreamParams::GetPrimarySsrcs(std::vector<uint32_t>* ssrcs) const {
|
|
const SsrcGroup* sim_group = get_ssrc_group(kSimSsrcGroupSemantics);
|
|
if (sim_group == NULL) {
|
|
ssrcs->push_back(first_ssrc());
|
|
} else {
|
|
for (size_t i = 0; i < sim_group->ssrcs.size(); ++i) {
|
|
ssrcs->push_back(sim_group->ssrcs[i]);
|
|
}
|
|
}
|
|
}
|
|
|
|
void StreamParams::GetFidSsrcs(const std::vector<uint32_t>& primary_ssrcs,
|
|
std::vector<uint32_t>* fid_ssrcs) const {
|
|
for (size_t i = 0; i < primary_ssrcs.size(); ++i) {
|
|
uint32_t fid_ssrc;
|
|
if (GetFidSsrc(primary_ssrcs[i], &fid_ssrc)) {
|
|
fid_ssrcs->push_back(fid_ssrc);
|
|
}
|
|
}
|
|
}
|
|
|
|
bool StreamParams::AddSecondarySsrc(const std::string& semantics,
|
|
uint32_t primary_ssrc,
|
|
uint32_t secondary_ssrc) {
|
|
if (!has_ssrc(primary_ssrc)) {
|
|
return false;
|
|
}
|
|
|
|
ssrcs.push_back(secondary_ssrc);
|
|
std::vector<uint32_t> ssrc_vector;
|
|
ssrc_vector.push_back(primary_ssrc);
|
|
ssrc_vector.push_back(secondary_ssrc);
|
|
SsrcGroup ssrc_group = SsrcGroup(semantics, ssrc_vector);
|
|
ssrc_groups.push_back(ssrc_group);
|
|
return true;
|
|
}
|
|
|
|
bool StreamParams::GetSecondarySsrc(const std::string& semantics,
|
|
uint32_t primary_ssrc,
|
|
uint32_t* secondary_ssrc) const {
|
|
for (std::vector<SsrcGroup>::const_iterator it = ssrc_groups.begin();
|
|
it != ssrc_groups.end(); ++it) {
|
|
if (it->has_semantics(semantics) &&
|
|
it->ssrcs.size() >= 2 &&
|
|
it->ssrcs[0] == primary_ssrc) {
|
|
*secondary_ssrc = it->ssrcs[1];
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool IsOneSsrcStream(const StreamParams& sp) {
|
|
if (sp.ssrcs.size() == 1 && sp.ssrc_groups.empty()) {
|
|
return true;
|
|
}
|
|
if (sp.ssrcs.size() == 2) {
|
|
const SsrcGroup* fid_group = sp.get_ssrc_group(kFidSsrcGroupSemantics);
|
|
if (fid_group != NULL) {
|
|
return (sp.ssrcs == fid_group->ssrcs);
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
static void RemoveFirst(std::list<uint32_t>* ssrcs, uint32_t value) {
|
|
std::list<uint32_t>::iterator it =
|
|
std::find(ssrcs->begin(), ssrcs->end(), value);
|
|
if (it != ssrcs->end()) {
|
|
ssrcs->erase(it);
|
|
}
|
|
}
|
|
|
|
bool IsSimulcastStream(const StreamParams& sp) {
|
|
const SsrcGroup* const sg = sp.get_ssrc_group(kSimSsrcGroupSemantics);
|
|
if (sg == NULL || sg->ssrcs.size() < 2) {
|
|
return false;
|
|
}
|
|
// Start with all StreamParams SSRCs. Remove simulcast SSRCs (from sg) and
|
|
// RTX SSRCs. If we still have SSRCs left, we don't know what they're for.
|
|
// Also we remove first-found SSRCs only. So duplicates should lead to errors.
|
|
std::list<uint32_t> sp_ssrcs(sp.ssrcs.begin(), sp.ssrcs.end());
|
|
for (size_t i = 0; i < sg->ssrcs.size(); ++i) {
|
|
RemoveFirst(&sp_ssrcs, sg->ssrcs[i]);
|
|
}
|
|
for (size_t i = 0; i < sp.ssrc_groups.size(); ++i) {
|
|
const SsrcGroup& group = sp.ssrc_groups[i];
|
|
if (group.semantics.compare(kFidSsrcGroupSemantics) != 0 ||
|
|
group.ssrcs.size() != 2) {
|
|
continue;
|
|
}
|
|
RemoveFirst(&sp_ssrcs, group.ssrcs[1]);
|
|
}
|
|
// If there's SSRCs left that we don't know how to handle, we bail out.
|
|
return sp_ssrcs.size() == 0;
|
|
}
|
|
|
|
} // namespace cricket
|