pc/payload_type_picker.cc - src - Git at Google

 /*
  *  Copyright 2024 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 "pc/payload_type_picker.h"

 #include <algorithm>
 #include <utility>
 #include <vector>

 #include "absl/strings/match.h"
 #include "api/rtc_error.h"
 #include "media/base/codec.h"

 namespace webrtc {

 namespace {

 // Due to interoperability issues with old Chrome/WebRTC versions that
 // ignore the [35, 63] range prefer the lower range for new codecs.
 static const int kFirstDynamicPayloadTypeLowerRange = 35;
 static const int kLastDynamicPayloadTypeLowerRange = 63;

 static const int kFirstDynamicPayloadTypeUpperRange = 96;
 static const int kLastDynamicPayloadTypeUpperRange = 127;

 // Note: The only fields we need from a Codec are the type (audio/video),
 // the subtype (vp8/h264/....), the clock rate, the channel count, and the
 // fmtp parameters. The use of cricket::Codec, which contains more fields,
 // is only a temporary measure.

 bool MatchesForSdp(const cricket::Codec& codec_1,
                    const cricket::Codec& codec_2) {
   return absl::EqualsIgnoreCase(codec_1.name, codec_2.name) &&
          codec_1.type == codec_2.type && codec_1.channels == codec_2.channels &&
          codec_1.clockrate == codec_2.clockrate &&
          codec_1.params == codec_2.params;
 }

 struct MapTableEntry {
   webrtc::SdpAudioFormat format;
   int payload_type;
 };

 RTCErrorOr<PayloadType> FindFreePayloadType(std::set<PayloadType> seen_pt) {
   for (auto i = kFirstDynamicPayloadTypeUpperRange;
        i < kLastDynamicPayloadTypeUpperRange; i++) {
     if (seen_pt.count(PayloadType(i)) == 0) {
       return PayloadType(i);
     }
   }
   for (auto i = kFirstDynamicPayloadTypeLowerRange;
        i < kLastDynamicPayloadTypeLowerRange; i++) {
     if (seen_pt.count(PayloadType(i)) == 0) {
       return PayloadType(i);
     }
   }
   return RTCError(RTCErrorType::RESOURCE_EXHAUSTED,
                   "All available dynamic PTs have been assigned");
 }

 }  // namespace

 PayloadTypePicker::PayloadTypePicker() {
   // Default audio codecs. Duplicates media/engine/payload_type_mapper.cc
   const MapTableEntry default_audio_mappings[] = {
       // Static payload type assignments according to RFC 3551.
       {{cricket::kPcmuCodecName, 8000, 1}, 0},
       {{"GSM", 8000, 1}, 3},
       {{"G723", 8000, 1}, 4},
       {{"DVI4", 8000, 1}, 5},
       {{"DVI4", 16000, 1}, 6},
       {{"LPC", 8000, 1}, 7},
       {{cricket::kPcmaCodecName, 8000, 1}, 8},
       {{cricket::kG722CodecName, 8000, 1}, 9},
       {{cricket::kL16CodecName, 44100, 2}, 10},
       {{cricket::kL16CodecName, 44100, 1}, 11},
       {{"QCELP", 8000, 1}, 12},
       {{cricket::kCnCodecName, 8000, 1}, 13},
       // RFC 4566 is a bit ambiguous on the contents of the "encoding
       // parameters" field, which, for audio, encodes the number of
       // channels. It is "optional and may be omitted if the number of
       // channels is one". Does that necessarily imply that an omitted
       // encoding parameter means one channel?  Since RFC 3551 doesn't
       // specify a value for this parameter for MPA, I've included both 0
       // and 1 here, to increase the chances it will be correctly used if
       // someone implements an MPEG audio encoder/decoder.
       {{"MPA", 90000, 0}, 14},
       {{"MPA", 90000, 1}, 14},
       {{"G728", 8000, 1}, 15},
       {{"DVI4", 11025, 1}, 16},
       {{"DVI4", 22050, 1}, 17},
       {{"G729", 8000, 1}, 18},

       // Payload type assignments currently used by WebRTC.
       // Includes data to reduce collisions (and thus reassignments)
       {{cricket::kIlbcCodecName, 8000, 1}, 102},
       {{cricket::kCnCodecName, 16000, 1}, 105},
       {{cricket::kCnCodecName, 32000, 1}, 106},
       {{cricket::kOpusCodecName,
         48000,
         2,
         {{cricket::kCodecParamMinPTime, "10"},
          {cricket::kCodecParamUseInbandFec, cricket::kParamValueTrue}}},
        111},
       // RED for opus is assigned in the lower range, starting at the top.
       // Note that the FMTP refers to the opus payload type.
       {{cricket::kRedCodecName,
         48000,
         2,
         {{cricket::kCodecParamNotInNameValueFormat, "111/111"}}},
        63},
       // TODO(solenberg): Remove the hard coded 16k,32k,48k DTMF once we
       // assign payload types dynamically for send side as well.
       {{cricket::kDtmfCodecName, 48000, 1}, 110},
       {{cricket::kDtmfCodecName, 32000, 1}, 112},
       {{cricket::kDtmfCodecName, 16000, 1}, 113},
       {{cricket::kDtmfCodecName, 8000, 1}, 126}};
   for (auto entry : default_audio_mappings) {
     AddMapping(PayloadType(entry.payload_type),
                cricket::CreateAudioCodec(entry.format));
   }
 }

 RTCErrorOr<PayloadType> PayloadTypePicker::SuggestMapping(
     cricket::Codec codec,
     PayloadTypeRecorder* excluder) {
   // The first matching entry is returned, unless excluder
   // maps it to something different.
   for (auto entry : entries_) {
     if (MatchesForSdp(entry.codec(), codec)) {
       if (excluder) {
         auto result = excluder->LookupCodec(entry.payload_type());
         if (result.ok() && !MatchesForSdp(result.value(), codec)) {
           continue;
         }
       }
       return entry.payload_type();
     }
   }
   RTCErrorOr<PayloadType> found_pt = FindFreePayloadType(seen_payload_types_);
   if (found_pt.ok()) {
     AddMapping(found_pt.value(), codec);
   }
   return found_pt;
 }

 RTCError PayloadTypePicker::AddMapping(PayloadType payload_type,
                                        cricket::Codec codec) {
   // Completely duplicate mappings are ignored.
   // Multiple mappings for the same codec and the same PT are legal;
   for (auto entry : entries_) {
     if (payload_type == entry.payload_type() &&
         MatchesForSdp(codec, entry.codec())) {
       return RTCError::OK();
     }
   }
   entries_.emplace_back(MapEntry(payload_type, codec));
   seen_payload_types_.emplace(payload_type);
   return RTCError::OK();
 }

 RTCError PayloadTypeRecorder::AddMapping(PayloadType payload_type,
                                          cricket::Codec codec) {
   auto existing_codec_it = payload_type_to_codec_.find(payload_type);
   if (existing_codec_it != payload_type_to_codec_.end() &&
       !MatchesForSdp(codec, existing_codec_it->second)) {
     if (absl::EqualsIgnoreCase(codec.name, existing_codec_it->second.name)) {
       // The difference is in clock rate, channels or FMTP parameters.
       RTC_LOG(LS_INFO) << "Warning: Attempt to change a codec's parameters";
       // Some FMTP value changes are harmless, others are harmful.
       // This is done in production today, so we can't return an error.
     } else {
       RTC_LOG(LS_WARNING) << "Warning: You attempted to redefine a codec from "
                           << existing_codec_it->second.ToString() << " to "
                           << " new codec " << codec.ToString();
       // This is a spec violation.
       // TODO: https://issues.webrtc.org/41480892 - return an error.
     }
     // Accept redefinition.
     payload_type_to_codec_.insert_or_assign(payload_type, codec);
     return RTCError::OK();
   }
   payload_type_to_codec_.emplace(payload_type, codec);
   suggester_.AddMapping(payload_type, codec);
   return RTCError::OK();
 }

 std::vector<std::pair<PayloadType, cricket::Codec>>
 PayloadTypeRecorder::GetMappings() {
   return std::vector<std::pair<PayloadType, cricket::Codec>>{};
 }

 RTCErrorOr<PayloadType> PayloadTypeRecorder::LookupPayloadType(
     cricket::Codec codec) {
   // Note that having multiple PTs mapping to the same codec is NOT an error.
   // In this case, we return the first found (not deterministic).
   auto result = std::find_if(
       payload_type_to_codec_.begin(), payload_type_to_codec_.end(),
       [codec](const auto& iter) { return MatchesForSdp(iter.second, codec); });
   if (result == payload_type_to_codec_.end()) {
     return RTCError(RTCErrorType::INVALID_PARAMETER,
                     "No payload type found for codec");
   }
   return result->first;
 }

 RTCErrorOr<cricket::Codec> PayloadTypeRecorder::LookupCodec(
     PayloadType payload_type) {
   auto result = payload_type_to_codec_.find(payload_type);
   if (result == payload_type_to_codec_.end()) {
     return RTCError(RTCErrorType::INVALID_PARAMETER, "No such payload type");
   }
   return result->second;
 }

 void PayloadTypeRecorder::Checkpoint() {
   checkpoint_payload_type_to_codec_ = payload_type_to_codec_;
 }
 void PayloadTypeRecorder::Rollback() {
   payload_type_to_codec_ = checkpoint_payload_type_to_codec_;
 }

 }  // namespace webrtc
	/*
	* Copyright 2024 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 "pc/payload_type_picker.h"

	#include <algorithm>
	#include <utility>
	#include <vector>

	#include "absl/strings/match.h"
	#include "api/rtc_error.h"
	#include "media/base/codec.h"

	namespace webrtc {

	namespace {

	// Due to interoperability issues with old Chrome/WebRTC versions that
	// ignore the [35, 63] range prefer the lower range for new codecs.
	static const int kFirstDynamicPayloadTypeLowerRange = 35;
	static const int kLastDynamicPayloadTypeLowerRange = 63;

	static const int kFirstDynamicPayloadTypeUpperRange = 96;
	static const int kLastDynamicPayloadTypeUpperRange = 127;

	// Note: The only fields we need from a Codec are the type (audio/video),
	// the subtype (vp8/h264/....), the clock rate, the channel count, and the
	// fmtp parameters. The use of cricket::Codec, which contains more fields,
	// is only a temporary measure.

	bool MatchesForSdp(const cricket::Codec& codec_1,
	const cricket::Codec& codec_2) {
	return absl::EqualsIgnoreCase(codec_1.name, codec_2.name) &&
	codec_1.type == codec_2.type && codec_1.channels == codec_2.channels &&
	codec_1.clockrate == codec_2.clockrate &&
	codec_1.params == codec_2.params;
	}

	struct MapTableEntry {
	webrtc::SdpAudioFormat format;
	int payload_type;
	};

	RTCErrorOr<PayloadType> FindFreePayloadType(std::set<PayloadType> seen_pt) {
	for (auto i = kFirstDynamicPayloadTypeUpperRange;
	i < kLastDynamicPayloadTypeUpperRange; i++) {
	if (seen_pt.count(PayloadType(i)) == 0) {
	return PayloadType(i);
	}
	}
	for (auto i = kFirstDynamicPayloadTypeLowerRange;
	i < kLastDynamicPayloadTypeLowerRange; i++) {
	if (seen_pt.count(PayloadType(i)) == 0) {
	return PayloadType(i);
	}
	}
	return RTCError(RTCErrorType::RESOURCE_EXHAUSTED,
	"All available dynamic PTs have been assigned");
	}

	} // namespace

	PayloadTypePicker::PayloadTypePicker() {
	// Default audio codecs. Duplicates media/engine/payload_type_mapper.cc
	const MapTableEntry default_audio_mappings[] = {
	// Static payload type assignments according to RFC 3551.
	{{cricket::kPcmuCodecName, 8000, 1}, 0},
	{{"GSM", 8000, 1}, 3},
	{{"G723", 8000, 1}, 4},
	{{"DVI4", 8000, 1}, 5},
	{{"DVI4", 16000, 1}, 6},
	{{"LPC", 8000, 1}, 7},
	{{cricket::kPcmaCodecName, 8000, 1}, 8},
	{{cricket::kG722CodecName, 8000, 1}, 9},
	{{cricket::kL16CodecName, 44100, 2}, 10},
	{{cricket::kL16CodecName, 44100, 1}, 11},
	{{"QCELP", 8000, 1}, 12},
	{{cricket::kCnCodecName, 8000, 1}, 13},
	// RFC 4566 is a bit ambiguous on the contents of the "encoding
	// parameters" field, which, for audio, encodes the number of
	// channels. It is "optional and may be omitted if the number of
	// channels is one". Does that necessarily imply that an omitted
	// encoding parameter means one channel? Since RFC 3551 doesn't
	// specify a value for this parameter for MPA, I've included both 0
	// and 1 here, to increase the chances it will be correctly used if
	// someone implements an MPEG audio encoder/decoder.
	{{"MPA", 90000, 0}, 14},
	{{"MPA", 90000, 1}, 14},
	{{"G728", 8000, 1}, 15},
	{{"DVI4", 11025, 1}, 16},
	{{"DVI4", 22050, 1}, 17},
	{{"G729", 8000, 1}, 18},

	// Payload type assignments currently used by WebRTC.
	// Includes data to reduce collisions (and thus reassignments)
	{{cricket::kIlbcCodecName, 8000, 1}, 102},
	{{cricket::kCnCodecName, 16000, 1}, 105},
	{{cricket::kCnCodecName, 32000, 1}, 106},
	{{cricket::kOpusCodecName,
	48000,
	2,
	{{cricket::kCodecParamMinPTime, "10"},
	{cricket::kCodecParamUseInbandFec, cricket::kParamValueTrue}}},
	111},
	// RED for opus is assigned in the lower range, starting at the top.
	// Note that the FMTP refers to the opus payload type.
	{{cricket::kRedCodecName,
	48000,
	2,
	{{cricket::kCodecParamNotInNameValueFormat, "111/111"}}},
	63},
	// TODO(solenberg): Remove the hard coded 16k,32k,48k DTMF once we
	// assign payload types dynamically for send side as well.
	{{cricket::kDtmfCodecName, 48000, 1}, 110},
	{{cricket::kDtmfCodecName, 32000, 1}, 112},
	{{cricket::kDtmfCodecName, 16000, 1}, 113},
	{{cricket::kDtmfCodecName, 8000, 1}, 126}};
	for (auto entry : default_audio_mappings) {
	AddMapping(PayloadType(entry.payload_type),
	cricket::CreateAudioCodec(entry.format));
	}
	}

	RTCErrorOr<PayloadType> PayloadTypePicker::SuggestMapping(
	cricket::Codec codec,
	PayloadTypeRecorder* excluder) {
	// The first matching entry is returned, unless excluder
	// maps it to something different.
	for (auto entry : entries_) {
	if (MatchesForSdp(entry.codec(), codec)) {
	if (excluder) {
	auto result = excluder->LookupCodec(entry.payload_type());
	if (result.ok() && !MatchesForSdp(result.value(), codec)) {
	continue;
	}
	}
	return entry.payload_type();
	}
	}
	RTCErrorOr<PayloadType> found_pt = FindFreePayloadType(seen_payload_types_);
	if (found_pt.ok()) {
	AddMapping(found_pt.value(), codec);
	}
	return found_pt;
	}

	RTCError PayloadTypePicker::AddMapping(PayloadType payload_type,
	cricket::Codec codec) {
	// Completely duplicate mappings are ignored.
	// Multiple mappings for the same codec and the same PT are legal;
	for (auto entry : entries_) {
	if (payload_type == entry.payload_type() &&
	MatchesForSdp(codec, entry.codec())) {
	return RTCError::OK();
	}
	}
	entries_.emplace_back(MapEntry(payload_type, codec));
	seen_payload_types_.emplace(payload_type);
	return RTCError::OK();
	}

	RTCError PayloadTypeRecorder::AddMapping(PayloadType payload_type,
	cricket::Codec codec) {
	auto existing_codec_it = payload_type_to_codec_.find(payload_type);
	if (existing_codec_it != payload_type_to_codec_.end() &&
	!MatchesForSdp(codec, existing_codec_it->second)) {
	if (absl::EqualsIgnoreCase(codec.name, existing_codec_it->second.name)) {
	// The difference is in clock rate, channels or FMTP parameters.
	RTC_LOG(LS_INFO) << "Warning: Attempt to change a codec's parameters";
	// Some FMTP value changes are harmless, others are harmful.
	// This is done in production today, so we can't return an error.
	} else {
	RTC_LOG(LS_WARNING) << "Warning: You attempted to redefine a codec from "
	<< existing_codec_it->second.ToString() << " to "
	<< " new codec " << codec.ToString();
	// This is a spec violation.
	// TODO: https://issues.webrtc.org/41480892 - return an error.
	}
	// Accept redefinition.
	payload_type_to_codec_.insert_or_assign(payload_type, codec);
	return RTCError::OK();
	}
	payload_type_to_codec_.emplace(payload_type, codec);
	suggester_.AddMapping(payload_type, codec);
	return RTCError::OK();
	}

	std::vector<std::pair<PayloadType, cricket::Codec>>
	PayloadTypeRecorder::GetMappings() {
	return std::vector<std::pair<PayloadType, cricket::Codec>>{};
	}

	RTCErrorOr<PayloadType> PayloadTypeRecorder::LookupPayloadType(
	cricket::Codec codec) {
	// Note that having multiple PTs mapping to the same codec is NOT an error.
	// In this case, we return the first found (not deterministic).
	auto result = std::find_if(
	payload_type_to_codec_.begin(), payload_type_to_codec_.end(),
	[codec](const auto& iter) { return MatchesForSdp(iter.second, codec); });
	if (result == payload_type_to_codec_.end()) {
	return RTCError(RTCErrorType::INVALID_PARAMETER,
	"No payload type found for codec");
	}
	return result->first;
	}

	RTCErrorOr<cricket::Codec> PayloadTypeRecorder::LookupCodec(
	PayloadType payload_type) {
	auto result = payload_type_to_codec_.find(payload_type);
	if (result == payload_type_to_codec_.end()) {
	return RTCError(RTCErrorType::INVALID_PARAMETER, "No such payload type");
	}
	return result->second;
	}

	void PayloadTypeRecorder::Checkpoint() {
	checkpoint_payload_type_to_codec_ = payload_type_to_codec_;
	}
	void PayloadTypeRecorder::Rollback() {
	payload_type_to_codec_ = checkpoint_payload_type_to_codec_;
	}

	} // namespace webrtc