编解码器类关系图

image.png
Add10MsData 用于向编码器输入数据
PlayoutData10Ms 用于从解码器获取数据
IncomingPacket用于从网络获取音频包，数据是没有rtp头的

创建音频编码器的步骤

image.png

创建音频编码器的函数调用过程

image.png
右边的第一步走完后，才会执行第二步。
最后调用SetEncoder将构造好的AudioEncoderOpusImpl赋值给创建好的AudioCodingModuleImpl。

音频编码器的选择

image.png

代码分析

ChannelSend::ChannelSend

H:\webrtc-20210315\webrtc-20210315\webrtc\webrtc-checkout\src\audio\channel_send.cc

  1. ChannelSend::ChannelSend(
  2.     Clock* clock,
  3.     TaskQueueFactory* task_queue_factory,
  4.     ProcessThread* module_process_thread,
  5.     Transport* rtp_transport,
  6.     RtcpRttStats* rtcp_rtt_stats,
  7.     RtcEventLog* rtc_event_log,
  8.     FrameEncryptorInterface* frame_encryptor,
  9.     const webrtc::CryptoOptions& crypto_options,
  10.     bool extmap_allow_mixed,
  11.     int rtcp_report_interval_ms,
  12.     uint32_t ssrc,
  13.     rtc::scoped_refptr<FrameTransformerInterface> frame_transformer,
  14.     TransportFeedbackObserver* feedback_observer)
  15.     : event_log_(rtc_event_log),
  16.       _timeStamp(0),  // This is just an offset, RTP module will add it's own
  17.                       // random offset
  18.       _moduleProcessThreadPtr(module_process_thread),
  19.       input_mute_(false),
  20.       previous_frame_muted_(false),
  21.       _includeAudioLevelIndication(false),
  22.       rtcp_observer_(new VoERtcpObserver(this)),
  23.       feedback_observer_(feedback_observer),
  24.       rtp_packet_pacer_proxy_(new RtpPacketSenderProxy()),
  25.       retransmission_rate_limiter_(
  26.           new RateLimiter(clock, kMaxRetransmissionWindowMs)),
  27.       frame_encryptor_(frame_encryptor),
  28.       crypto_options_(crypto_options),
  29.       encoder_queue_(task_queue_factory->CreateTaskQueue(
  30.           "AudioEncoder",
  31.           TaskQueueFactory::Priority::NORMAL)),
  32.       fixing_timestamp_stall_(
  33.           !field_trial::IsDisabled("WebRTC-Audio-FixTimestampStall")) {
  34.   RTC_DCHECK(module_process_thread);
  35.   module_process_thread_checker_.Detach();
  37.   // 创建音频编码器
  38.   audio_coding_.reset(AudioCodingModule::Create(AudioCodingModule::Config()));
  40.   RtpRtcpInterface::Configuration configuration;
  41.   configuration.bandwidth_callback = rtcp_observer_.get();
  42.   configuration.transport_feedback_callback = feedback_observer_;
  43.   configuration.clock = (clock ? clock : Clock::GetRealTimeClock());
  44.   configuration.audio = true;
  45.   configuration.outgoing_transport = rtp_transport;
  47.   configuration.paced_sender = rtp_packet_pacer_proxy_.get();
  49.   configuration.event_log = event_log_;
  50.   configuration.rtt_stats = rtcp_rtt_stats;
  51.   configuration.retransmission_rate_limiter =
  52.       retransmission_rate_limiter_.get();
  53.   configuration.extmap_allow_mixed = extmap_allow_mixed;
  54.   configuration.rtcp_report_interval_ms = rtcp_report_interval_ms;
  56.   configuration.local_media_ssrc = ssrc;
  58.     // 创建ModuleRtpRtcpImpl2
  59.   rtp_rtcp_ = ModuleRtpRtcpImpl2::Create(configuration);
  60.   rtp_rtcp_->SetSendingMediaStatus(false);
  62.   rtp_sender_audio_ = std::make_unique<RTPSenderAudio>(configuration.clock,
  63.                                                        rtp_rtcp_->RtpSender());
  65.   _moduleProcessThreadPtr->RegisterModule(rtp_rtcp_.get(), RTC_FROM_HERE);
  67.   // Ensure that RTCP is enabled by default for the created channel.
  68.   rtp_rtcp_->SetRTCPStatus(RtcpMode::kCompound);
  70.   int error = audio_coding_->RegisterTransportCallback(this);
  71.   RTC_DCHECK_EQ(0, error);
  72.   if (frame_transformer)
  73.     InitFrameTransformerDelegate(std::move(frame_transformer));
  74. }

WebRtcVoiceMediaChannel::SetSendCodecs

  1. // Utility function called from SetSendParameters() to extract current send
  2. // codec settings from the given list of codecs (originally from SDP). Both send
  3. // and receive streams may be reconfigured based on the new settings.
  4. bool WebRtcVoiceMediaChannel::SetSendCodecs(
  5.     const std::vector<AudioCodec>& codecs) {
  6.   RTC_DCHECK_RUN_ON(worker_thread_);
  7.   dtmf_payload_type_ = absl::nullopt;
  8.   dtmf_payload_freq_ = -1;
  10.   // Validate supplied codecs list.
  11.   for (const AudioCodec& codec : codecs) {
  12.     // TODO(solenberg): Validate more aspects of input - that payload types
  13.     //                  don't overlap, remove redundant/unsupported codecs etc -
  14.     //                  the same way it is done for RtpHeaderExtensions.
  15.     if (codec.id < kMinPayloadType || codec.id > kMaxPayloadType) {
  16.       RTC_LOG(LS_WARNING) << "Codec payload type out of range: "
  17.                           << ToString(codec);
  18.       return false;
  19.     }
  20.   }
  22.   // Find PT of telephone-event codec with lowest clockrate, as a fallback, in
  23.   // case we don't have a DTMF codec with a rate matching the send codec's, or
  24.   // if this function returns early.
  25.   std::vector<AudioCodec> dtmf_codecs;
  26.   for (const AudioCodec& codec : codecs) {
  27.     if (IsCodec(codec, kDtmfCodecName)) {
  28.       dtmf_codecs.push_back(codec);
  29.       if (!dtmf_payload_type_ || codec.clockrate < dtmf_payload_freq_) {
  30.         dtmf_payload_type_ = codec.id;
  31.         dtmf_payload_freq_ = codec.clockrate;
  32.       }
  33.     }
  34.   }
  36.   // Scan through the list to figure out the codec to use for sending.
  37.   absl::optional<webrtc::AudioSendStream::Config::SendCodecSpec>
  38.       send_codec_spec;
  39.   webrtc::BitrateConstraints bitrate_config;
  40.   absl::optional<webrtc::AudioCodecInfo> voice_codec_info;
  41.   size_t send_codec_position = 0;
  42.   for (const AudioCodec& voice_codec : codecs) {
  43.     if (!(IsCodec(voice_codec, kCnCodecName) ||
  44.           IsCodec(voice_codec, kDtmfCodecName) ||
  45.           IsCodec(voice_codec, kRedCodecName))) {
  46.       webrtc::SdpAudioFormat format(voice_codec.name, voice_codec.clockrate,
  47.                                     voice_codec.channels, voice_codec.params);
  49.       voice_codec_info = engine()->encoder_factory_->QueryAudioEncoder(format);
  50.       if (!voice_codec_info) {
  51.         RTC_LOG(LS_WARNING) << "Unknown codec " << ToString(voice_codec);
  52.         continue;
  53.       }
  55.       send_codec_spec = webrtc::AudioSendStream::Config::SendCodecSpec(
  56.           voice_codec.id, format);
  57.       if (voice_codec.bitrate > 0) {
  58.         send_codec_spec->target_bitrate_bps = voice_codec.bitrate;
  59.       }
  60.       send_codec_spec->transport_cc_enabled = HasTransportCc(voice_codec);
  61.       send_codec_spec->nack_enabled = HasNack(voice_codec);
  62.       bitrate_config = GetBitrateConfigForCodec(voice_codec);
  63.       break;
  64.     }
  65.     send_codec_position++;
  66.   }
  68.   if (!send_codec_spec) {
  69.     return false;
  70.   }
  72.   RTC_DCHECK(voice_codec_info);
  73.   if (voice_codec_info->allow_comfort_noise) {
  74.     // Loop through the codecs list again to find the CN codec.
  75.     // TODO(solenberg): Break out into a separate function?
  76.     for (const AudioCodec& cn_codec : codecs) {
  77.       if (IsCodec(cn_codec, kCnCodecName) &&
  78.           cn_codec.clockrate == send_codec_spec->format.clockrate_hz &&
  79.           cn_codec.channels == voice_codec_info->num_channels) {
  80.         if (cn_codec.channels != 1) {
  81.           RTC_LOG(LS_WARNING)
  82.               << "CN #channels " << cn_codec.channels << " not supported.";
  83.         } else if (cn_codec.clockrate != 8000 && cn_codec.clockrate != 16000 &&
  84.                    cn_codec.clockrate != 32000) {
  85.           RTC_LOG(LS_WARNING)
  86.               << "CN frequency " << cn_codec.clockrate << " not supported.";
  87.         } else {
  88.           send_codec_spec->cng_payload_type = cn_codec.id;
  89.         }
  90.         break;
  91.       }
  92.     }
  94.     // Find the telephone-event PT exactly matching the preferred send codec.
  95.     for (const AudioCodec& dtmf_codec : dtmf_codecs) {
  96.       if (dtmf_codec.clockrate == send_codec_spec->format.clockrate_hz) {
  97.         dtmf_payload_type_ = dtmf_codec.id;
  98.         dtmf_payload_freq_ = dtmf_codec.clockrate;
  99.         break;
  100.       }
  101.     }
  102.   }
  104.   if (audio_red_for_opus_trial_enabled_) {
  105.     // Loop through the codecs to find the RED codec that matches opus
  106.     // with respect to clockrate and number of channels.
  107.     size_t red_codec_position = 0;
  108.     for (const AudioCodec& red_codec : codecs) {
  109.       if (red_codec_position < send_codec_position &&
  110.           IsCodec(red_codec, kRedCodecName) &&
  111.           red_codec.clockrate == send_codec_spec->format.clockrate_hz &&
  112.           red_codec.channels == send_codec_spec->format.num_channels) {
  113.         send_codec_spec->red_payload_type = red_codec.id;
  114.         break;
  115.       }
  116.       red_codec_position++;
  117.     }
  118.   }
  120.   if (send_codec_spec_ != send_codec_spec) {
  121.     send_codec_spec_ = std::move(send_codec_spec);
  122.     // Apply new settings to all streams.
  123.     for (const auto& kv : send_streams_) {
  124.       kv.second->SetSendCodecSpec(*send_codec_spec_);
  125.     }
  126.   } else {
  127.     // If the codec isn't changing, set the start bitrate to -1 which means
  128.     // "unchanged" so that BWE isn't affected.
  129.     bitrate_config.start_bitrate_bps = -1;
  130.   }
  131.   call_->GetTransportControllerSend()->SetSdpBitrateParameters(bitrate_config);
  133.   // Check if the transport cc feedback or NACK status has changed on the
  134.   // preferred send codec, and in that case reconfigure all receive streams.
  135.   if (recv_transport_cc_enabled_ != send_codec_spec_->transport_cc_enabled ||
  136.       recv_nack_enabled_ != send_codec_spec_->nack_enabled) {
  137.     RTC_LOG(LS_INFO) << "Recreate all the receive streams because the send "
  138.                         "codec has changed.";
  139.     recv_transport_cc_enabled_ = send_codec_spec_->transport_cc_enabled;
  140.     recv_nack_enabled_ = send_codec_spec_->nack_enabled;
  141.     for (auto& kv : recv_streams_) {
  142.       kv.second->SetUseTransportCcAndRecreateStream(recv_transport_cc_enabled_,
  143.                                                     recv_nack_enabled_);
  144.     }
  145.   }
  147.   send_codecs_ = codecs;
  148.   return true;
  149. }

image.png

总结

image.png