{"id":913,"date":"2023-03-18T23:11:57","date_gmt":"2023-03-18T15:11:57","guid":{"rendered":"https:\/\/www.fanyamin.com\/wordpress\/?p=913"},"modified":"2023-03-19T10:23:52","modified_gmt":"2023-03-19T02:23:52","slug":"webrtc-bandwidth-allocation","status":"publish","type":"post","link":"https:\/\/www.fanyamin.com\/wordpress\/?p=913","title":{"rendered":"WebRTC Bandwidth Allocation"},"content":{"rendered":"

\"file\"<\/p>\n

Title Bandwidth allocation by REMB\n\nModuleRtpRtcpImpl->RTCPReceiver: IncomingPacket\nRTCPReceiver->RTCPReceiver: TriggerCallbacksFromRtcpPacket\nRTCPReceiver->RtpTransportControllerSend:OnReceivedEstimatedBitrate(bitrate)\nRtpTransportControllerSend->GoogCcNetworkController: OnRemoteBitrateReport(receiveTime, bitrate)\nGoogCcNetworkController->SendSideBandwidthEstimation: UpdateReceiverEstimate\nSendSideBandwidthEstimation->SendSideBandwidthEstimation: ApplyTargetLimits\nSendSideBandwidthEstimation->SendSideBandwidthEstimation: UpdateTargetBitrate\n#SendSideBandwidthEstimation->LinkCapacityTracker:OnRateUpdate\nGoogCcNetworkController->Call: OnTargetTransferRate\nCall->BitrateAllocator: OnNetworkEstimateChanged\nBitrateAllocator->BitrateAllocator: AllocateBitrates<\/code><\/pre>\n
Snippets<\/h1>\n
    \n
  • AllocateBitrates \u5e26\u5bbd\u5206\u914d\u65b9\u6cd5<\/li>\n<\/ul>\n
    std::map<BitrateAllocatorObserver*, int> AllocateBitrates(\n    const std::vector<AllocatableTrack>& allocatable_tracks,\n    uint32_t bitrate) {\n  if (allocatable_tracks.empty())\n    return std::map<BitrateAllocatorObserver*, int>();\n\n  if (bitrate == 0)\n    return ZeroRateAllocation(allocatable_tracks);\n\n  uint32_t sum_min_bitrates = 0;\n  uint32_t sum_max_bitrates = 0;\n  for (const auto& observer_config : allocatable_tracks) {\n    sum_min_bitrates += observer_config.config.min_bitrate_bps;\n    sum_max_bitrates += observer_config.config.max_bitrate_bps;\n  }\n\n  \/\/ Not enough for all observers to get an allocation, allocate according to:\n  \/\/ enforced min bitrate -> allocated bitrate previous round -> restart paused\n  \/\/ streams.\n  if (!EnoughBitrateForAllObservers(allocatable_tracks, bitrate,\n                                    sum_min_bitrates))\n    return LowRateAllocation(allocatable_tracks, bitrate);\n\n  \/\/ All observers will get their min bitrate plus a share of the rest. This\n  \/\/ share is allocated to each observer based on its bitrate_priority.\n  if (bitrate <= sum_max_bitrates)\n    return NormalRateAllocation(allocatable_tracks, bitrate, sum_min_bitrates);\n\n  \/\/ All observers will get up to transmission_max_bitrate_multiplier_ x max.\n  return MaxRateAllocation(allocatable_tracks, bitrate, sum_max_bitrates);\n}\n<\/code><\/pre>\n
      \n
    • \n
      UpdateControlState<\/p>\n
      void RtpTransportControllerSend::UpdateControlState() {\nabsl::optional<TargetTransferRate> update = control_handler_->GetUpdate();\nif (!update)\nreturn;\nretransmission_rate_limiter_.SetMaxRate(update->target_rate.bps());\n\/\/ We won't create control_handler_ until we have an observers.\nRTC_DCHECK(observer_ != nullptr);\nobserver_->OnTargetTransferRate(*update);\n}<\/code><\/pre>\n
      EnoughBitrateForAllObservers \u5e26\u5bbd\u8db3\u591f\u548c\u8bdd<\/h3>\n
      bool EnoughBitrateForAllObservers(\nconst std::vector<AllocatableTrack>& allocatable_tracks,\nuint32_t bitrate,\nuint32_t sum_min_bitrates) {\nif (bitrate < sum_min_bitrates)\nreturn false;\n\nuint32_t extra_bitrate_per_observer =\n  (bitrate - sum_min_bitrates) \/\n  static_cast<uint32_t>(allocatable_tracks.size());\nfor (const auto& observer_config : allocatable_tracks) {\nif (observer_config.config.min_bitrate_bps + extra_bitrate_per_observer <\n    observer_config.MinBitrateWithHysteresis()) {\n  return false;\n}\n}\nreturn true;\n}<\/code><\/pre>\n<\/li>\n<\/ul>\n
      LowRateAllocation \u5e26\u5bbd\u4e0d\u591f\u7684\u5206\u6790\u7b56\u7565<\/h3>\n
      \/\/ Allocates bitrate to observers when there isn't enough to allocate the\n\/\/ minimum to all observers.\nstd::map<BitrateAllocatorObserver*, int> LowRateAllocation(\n    const std::vector<AllocatableTrack>& allocatable_tracks,\n    uint32_t bitrate) {\n  std::map<BitrateAllocatorObserver*, int> allocation;\n  \/\/ Start by allocating bitrate to observers enforcing a min bitrate, hence\n  \/\/ remaining_bitrate might turn negative.\n  int64_t remaining_bitrate = bitrate;\n  for (const auto& observer_config : allocatable_tracks) {\n    int32_t allocated_bitrate = 0;\n    if (observer_config.config.enforce_min_bitrate)\n      allocated_bitrate = observer_config.config.min_bitrate_bps;\n\n    allocation[observer_config.observer] = allocated_bitrate;\n    remaining_bitrate -= allocated_bitrate;\n  }\n\n  \/\/ Allocate bitrate to all previously active streams.\n  if (remaining_bitrate > 0) {\n    for (const auto& observer_config : allocatable_tracks) {\n      if (observer_config.config.enforce_min_bitrate ||\n          observer_config.LastAllocatedBitrate() == 0)\n        continue;\n\n      uint32_t required_bitrate = observer_config.MinBitrateWithHysteresis();\n      if (remaining_bitrate >= required_bitrate) {\n        allocation[observer_config.observer] = required_bitrate;\n        remaining_bitrate -= required_bitrate;\n      }\n    }\n  }\n\n  \/\/ Allocate bitrate to previously paused streams.\n  if (remaining_bitrate > 0) {\n    for (const auto& observer_config : allocatable_tracks) {\n      if (observer_config.LastAllocatedBitrate() != 0)\n        continue;\n\n      \/\/ Add a hysteresis to avoid toggling.\n      uint32_t required_bitrate = observer_config.MinBitrateWithHysteresis();\n      if (remaining_bitrate >= required_bitrate) {\n        allocation[observer_config.observer] = required_bitrate;\n        remaining_bitrate -= required_bitrate;\n      }\n    }\n  }\n\n  \/\/ Split a possible remainder evenly on all streams with an allocation.\n  if (remaining_bitrate > 0)\n    DistributeBitrateEvenly(allocatable_tracks, remaining_bitrate, false, 1,\n                            &allocation);\n\n  RTC_DCHECK_EQ(allocation.size(), allocatable_tracks.size());\n  return allocation;\n}\n<\/code><\/pre>\n
      NormalRateAllocation \u6309\u4f18\u5148\u7ea7\u7684\u5e26\u5bbd\u5206\u914d\u7b56\u7565<\/h3>\n
      \/\/ Allocates the bitrate based on the bitrate priority of each observer. This\n\/\/ bitrate priority defines the priority for bitrate to be allocated to that\n\/\/ observer in relation to other observers. For example with two observers, if\n\/\/ observer 1 had a bitrate_priority = 1.0, and observer 2 has a\n\/\/ bitrate_priority = 2.0, the expected behavior is that observer 2 will be\n\/\/ allocated twice the bitrate as observer 1 above the each observer's\n\/\/ min_bitrate_bps values, until one of the observers hits its max_bitrate_bps.\nstd::map<BitrateAllocatorObserver*, int> NormalRateAllocation(\n    const std::vector<AllocatableTrack>& allocatable_tracks,\n    uint32_t bitrate,\n    uint32_t sum_min_bitrates) {\n  std::map<BitrateAllocatorObserver*, int> allocation;\n  std::map<BitrateAllocatorObserver*, int> observers_capacities;\n  for (const auto& observer_config : allocatable_tracks) {\n    allocation[observer_config.observer] =\n        observer_config.config.min_bitrate_bps;\n    observers_capacities[observer_config.observer] =\n        observer_config.config.max_bitrate_bps -\n        observer_config.config.min_bitrate_bps;\n  }\n\n  bitrate -= sum_min_bitrates;\n\n  \/\/ TODO(srte): Implement fair sharing between prioritized streams, currently\n  \/\/ they are treated on a first come first serve basis.\n  for (const auto& observer_config : allocatable_tracks) {\n    int64_t priority_margin = observer_config.config.priority_bitrate_bps -\n                              allocation[observer_config.observer];\n    if (priority_margin > 0 && bitrate > 0) {\n      int64_t extra_bitrate = std::min<int64_t>(priority_margin, bitrate);\n      allocation[observer_config.observer] +=\n          rtc::dchecked_cast<int>(extra_bitrate);\n      observers_capacities[observer_config.observer] -= extra_bitrate;\n      bitrate -= extra_bitrate;\n    }\n  }\n\n  \/\/ From the remaining bitrate, allocate a proportional amount to each observer\n  \/\/ above the min bitrate already allocated.\n  if (bitrate > 0)\n    DistributeBitrateRelatively(allocatable_tracks, bitrate,\n                                observers_capacities, &allocation);\n\n  return allocation;\n}<\/code><\/pre>\n
      MaxRateAllocation \u6700\u5927\u5e26\u5bbd\u5206\u914d\u7b56\u7565<\/h3>\n
      \/\/ Allocates bitrate to observers when there is enough available bandwidth\n\/\/ for all observers to be allocated their max bitrate.\nstd::map<BitrateAllocatorObserver*, int> MaxRateAllocation(\n    const std::vector<AllocatableTrack>& allocatable_tracks,\n    uint32_t bitrate,\n    uint32_t sum_max_bitrates) {\n  std::map<BitrateAllocatorObserver*, int> allocation;\n\n  for (const auto& observer_config : allocatable_tracks) {\n    allocation[observer_config.observer] =\n        observer_config.config.max_bitrate_bps;\n    bitrate -= observer_config.config.max_bitrate_bps;\n  }\n  DistributeBitrateEvenly(allocatable_tracks, bitrate, true,\n                          kTransmissionMaxBitrateMultiplier, &allocation);\n  return allocation;\n}<\/code><\/pre>\n
      ZeroRateAllocation \u96f6\u5e26\u5bbd\u5206\u914d\u7b56\u7565<\/h3>\n
      \/\/ Allocates zero bitrate to all observers.\nstd::map<BitrateAllocatorObserver*, int> ZeroRateAllocation(\n    const std::vector<AllocatableTrack>& allocatable_tracks) {\n  std::map<BitrateAllocatorObserver*, int> allocation;\n  for (const auto& observer_config : allocatable_tracks)\n    allocation[observer_config.observer] = 0;\n  return allocation;\n}<\/code><\/pre>\n
      Log keyword<\/h1>\n