webrtc pacer模块(一) 平滑处理的实现

Pacer起到平滑码率的作用，使发送到网络上的码率稳定。如下的这张创建Pacer的流程图，其中PacerSender就是Pacer，其中PacerSender就是Pacer。这篇文章介绍它的核心子类PacingController及Periodic模式下平滑处理的基本流程。平滑处理流程中还有与带宽探测所关联的流程，在本篇文章中并不涉及。

从上图中可以看到，在创建Call对象时，会创建一个RtpTransportControllerSend，它是Call对象中发送数据的大总管，而PacerSender也是属于它管理的对象。

一个Call对象中一个RtpTransportControllerSend，一个RtpTransportControllerSend中一个PacerSender，所以Pacer是作用于Call中所有的stream，这里并不是只处理音视频包，还有fec包，重传包，padding包，Call对象中也发送出去的数据都会经过Pacer。

这篇文章是介绍平滑实现的基本原理和Pacer中的Periodic模式的处理流程。Pacer的流程中还有与带宽探测所关联的流程，在本篇文章中并不涉及。

码率平滑的原理

在视频编码中，虽然编码器会将输出码流的码率控制在所设置的码率范围内。但是在编码器产生关键帧或在画面变化比较大时，码率可能超过设置的码率值。在有fec或重传包时，也可能造成实际发送的码率值超过目标值。这种突发的大码率的数据，可能就会造成网络链路拥塞。

所以引入的pacer就是平滑发送的码率值，在一段时间内，保证发送码率接近设置目标码率值。而避免突发的高码率造成网络链路拥塞。

平滑的基本原理就是**缓存队列+周期发送，将要发送的数据先缓存，在周期性的发送出去，起到平均码率的目的。那么这种周期有两种模式:**

  • **kPeriodic**，周期模式，也是默认模式，以固定间隔时间发送数据。
  • kDynamic，动态模式，根据数据的缓存时长及数据量来计算下一次发送数据的时间点。

组成

pacer的流程都实现在PacingController，包括两个核心类:RoundBoinPacketQueue，IntervalBudget。

  • RoundBobinPacketQueue 缓存队列，对每条流都会缓存，以ssrc做为流的唯一标识，包括：重传包，fec，padding包。
  • IntervalBudget 根据设置的目标码率值及时间间隔计算可发送的数据量。

PacingController类

所属文件为\modules\pacing\pacing_controller.h，如下类图：

两个核心的成员变量:

  1. RoundRobinPakcetQueue packet_queue_ packet的缓存队列。
  2. IntervalBudget media_buget_可发送数据量计算。

两个核心函数:

  1. NextSendTime，获取每次执行的时间(5毫秒，在kPeriodic模式下)。
  2. ProcessPackets，周期处理包的发送，确定要发送的数据量，从缓存队列中取包。
平滑逻辑的处理流程

整个pacer运行的机制就是靠PacingController的NextSendTime和ProcessPackets两个方法，它们被单独的放在一个ModuleThread线程中执行，周期性的被执行，两个方法调用的堆栈如下：

**NextSendTime**

peerconnection_client.exe!webrtc::PacingController::NextSendTime() 行 348 C++

peerconnection_client.exe!webrtc::PacedSender::TimeUntilNextProcess() 行 171 C++

peerconnection_client.exe!webrtc::PacedSender::ModuleProxy::TimeUntilNextProcess() 行 150 C++

peerconnection_client.exe!webrtc::`anonymous namespace’::GetNextCallbackTime(webrtc::Module * module, __int64 time_now) 行 30 C++

peerconnection_client.exe!webrtc::ProcessThreadImpl::Process() 行 231 C++

peerconnection_client.exe!webrtc::ProcessThreadImpl::Run(void * obj) 行 198 C++

peerconnection_client.exe!rtc::PlatformThread::Run() 行 130 C++

peerconnection_client.exe!rtc::PlatformThread::StartThread(void * param) 行 62 C++

**ProcessPackets**

peerconnection_client.exe!webrtc::PacingController::ProcessPackets() 行 408 C++

peerconnection_client.exe!webrtc::PacedSender::Process() 行 183 C++

peerconnection_client.exe!webrtc::PacedSender::ModuleProxy::Process() 行 152 C++

peerconnection_client.exe!webrtc::ProcessThreadImpl::Process() 行 226 C++

peerconnection_client.exe!webrtc::ProcessThreadImpl::Run(void * obj) 行 198 C++

peerconnection_client.exe!rtc::PlatformThread::Run() 行 130 C++

peerconnection_client.exe!rtc::PlatformThread::StartThread(void * param) 行 62 C++

核心骨架就是下面三个步骤：

  1. 设置目标码率，通过SetPacingRates(...)方法。
  2. 计算每个时间片可以发送的数据，在UpdateBudgetWithElapsedTime(TimeDelta delta)方法中。
  3. 用已发送的数据量来计算还剩多少数据量可以发送，在UpdateBudgetWithSentData(DataSize size)方法中。

详细流程：

(1). 如果媒体数据包处理模式是 kDynamic，则检查期望的发送时间和 前一次数据包处理时间 的对比，当前者大于后者时，则根据两者的差值更新预计仍在传输中的数据量，以及 前一次数据包处理时间；(Periodic模式是5ms执行一次)

(2). 从媒体数据包优先级队列中取一个数据包出来；

(3). 第 (2) 步中取出的数据包为空，但已经发送的媒体数据的量还没有达到码率探测器 webrtc::BitrateProber 建议发送的最小探测数据量，则创建一些填充数据包放入媒体数据包优先级队列，并继续下一轮处理；

(4). 发送取出的媒体数据包；

(5). 获取 FEC 数据包，并放入媒体数据包优先级队列；

(6). 根据发送的数据包的数据量，更新预计仍在传输中的数据量等信息；

(7). 如果是在码率探测期间，且发送的数据量超出码率探测器 webrtc::BitrateProber 建议发送的最小探测数据量，则结束发送过程；

(8). 如果媒体数据包处理模式是 kDynamic，则更新目标发送时间。

RoundBobinPacketQueue

RoundBobinPacketQueue是一个缓存队列， 用于缓存数据包(音视频包，fec，padding，重传包)，它有两个特征：

  1. 根据优先级存储包(每种类型包都有优先级)。
  2. 记录缓存时长(记录每个包的入队时间，用于计算缓存的总时长，避免引入过多的延迟)。
类图

上图种的Stream类代表了一路流，QueuePacket类代表了数据包。

RoundBobinPacketQueue三个核心的数据结构：

  • std::map<uint32_t, Stream> streams_

key为ssrc。

  • std::multimap<StreamPrioKey, uint32_t> **stream_priorities_**

**Stream**的优先级信息表，以**priority**和**DataSize**为比较的key，value是ssrc。通过优先级找Stream，方便优先级变化的实现。越靠前，优先级越高。

Stream类中的std::multimap<StreamPrioKey, uint32_t>::iterator priority_it;它指向 RoundBobinPacketQueue中的stream_priorities_中的某项，可以快速定位到自己的优先级。

  • std::multiset<Timestamp> enqueue_times_

The enqueue time of every packet currently in the queue. Used to figure out the age of the oldest packet in the queue.

记录每一个包的入队时间

QueuedPacket对象中的std::multiset<Timestamp>::iterator enqueue_time_it_;指向enqueue_times_中的项，可以快速定位到自己的入队时间。

Stream,QueuePacket,RoundBobinPacketQueue关系图

如下是Stream对象，QueuePacket对象与RoundBobinPacketQueue对象的关系图。

上图是以Stream为中心，描绘Stream,QueuePacket,RoundBobinPacketQueue的关系。

  • 每个Stream都被记录在RoundRobinPacketQueue的streams_中，以ssrc为key。
  • 每个Stream的优先级都被记录在RoundRobinPacketQueue的stream_priorites_中，以优先级为key，ssrc为value。
  • 数据包都被封装成QueuePacket缓存在Stream对象的packet_queue中，它也是一个优先级队列，所以每个数据包都是有优先级的。
  • RoundRobinPacketQueue的enqueue_times_记录着每个rtp packet的入队时间。
  • stream中std::multimap<StreamPrioKey,uint32_t>::iterator priority_it迭代器指向该stream在stream_priorites_中的位置，便于快速检索。
  • QueuedPacket中的std::multiset<Timestamp>::iterator enqueue_time_it迭代器指向该packet在enqueue_times_中的位置，便于快速检索。

缓存队列中记录的信息有：

  1. 记录总的缓存包个数。
  2. 记录总的数据量。
  3. 记录包的优先级。
  4. 记录包的入队时间(计算包的缓存总时长，平均缓存时间，最大缓存时间)。
插入队列(push方法)的逻辑
  1. 从streams_中找pakcet所属的Ssrc的stream，如果没有，则在streams_中插入一项。
  2. 查看stream的priority_it是否等于stream_priorities_的end()：如果相等，则在stream_priorities插入新的项; 否则，如果新包的优先级高，则更新其ssrc对应队列的优先级。
  3. 更新队列总时长。
  4. 入队时间减去暂停时间(一般不会有暂停)。
  5. 队列总包数+1。
  6. 队列总字节大小+包的负载大小+Padding大小(Packet的大小)。
  7. 插入到steam对象的packet_queue中。

push流程的注意点:

  • stream的size指的是stream发送的size，在Pop中，会加上弹出的PacketSize。
  • 一条stream的packet的priority值都是一样的。
  • 在入队一个stream的新的packet时，并不确定优先级，触发优先级队列中没有记录或packet的优先级发生变化。
取数据(Pop方法)的逻辑
  1. 获得优先级最高的stream。
  2. 从stream的packet_queue中取出第一个Packet。
  3. 将stream在stream_priorites_中的项删除掉。
  4. 计算Packet入队后到现在的时间(不包括暂停时间)。
  5. 将这段时间从队列的总时间中减去。
  6. 从equeue_times_中将Packet的项删除。
  7. 总包数减一。
  8. 总字节数减去包的字节数。
  9. 将包从stream中的queue中弹出。
  10. 如果stream中的队列为空，则令stream的priority_it指向stream_priorities的end()。
  11. 否则，从stream队列头部取Packet，将该Packet的priority插入到stream_priorities_中。
缓存时间的计算

计算缓存时间的目的是控制延迟，包括如下几个方法:

  • 获取缓存时间最长的包
Timestamp RoundRobinPacketQueue::OldestEnqueueTime() const {if (single_packet_queue_.has_value()) {return single_packet_queue_->EnqueueTime();}if (Empty())return Timestamp::MinusInfinity();RTC_CHECK(!enqueue_times_.empty());return *enqueue_times_.begin();
}

这个方法是用于统计，最终会被call对象的GetStats()方法调用。

  • 计算总延时，UpdateQueueTime每次被调用，总时长都会被计算，累加。
void RoundRobinPacketQueue::UpdateQueueTime(Timestamp now) {RTC_CHECK_GE(now, time_last_updated_);if (now == time_last_updated_)return;TimeDelta delta = now - time_last_updated_;if (paused_) {pause_time_sum_ += delta;} else {//有n个包，每调一次UpdateQueueTime就有一个delta值，总数为size of packet乘以deltaqueue_time_sum_ += TimeDelta::Micros(delta.us() * size_packets_);}time_last_updated_ = now;
}
  • 计算平均缓存时间

平均缓存时间=queue的总时间数/包数，用于判断延时(缓存时间)是否过大。

TimeDelta RoundRobinPacketQueue::AverageQueueTime() const {if (Empty())return TimeDelta::Zero();return queue_time_sum_ / size_packets_;
}
控制延时

在PacingController::ProcessPackets()方法中，会计算包的缓存时间，如下if分支

if (drain_large_queues_) {//限制延时TimeDelta avg_time_left =std::max(TimeDelta::Millis(1),queue_time_limit - packet_queue_.AverageQueueTime());DataRate min_rate_needed = queue_size_data / avg_time_left;if (min_rate_needed > target_rate) {target_rate = min_rate_needed;RTC_LOG(LS_VERBOSE) << "bwe:large_pacing_queue pacing_rate_kbps="<< target_rate.kbps();}
}

首先会计算缓存队列的的平均缓存时间，通过设置的缓存时间限制值减去它得出应该要在多长时间发送这些数据。

再计算发送速率，最后设置目标码率值。这个目标码率值会被设置到media_buget中去(kPeriodic模式下)。

快速处理

缓存队列缓存数据，肯定会引入延迟，在RonundBobinPacketQeueu有一个absl::optional<QueuedPacket> single_packet_queue_成员变量，它的作用就是快速处理数据包。

只有音频流时的处理

音频对延迟很敏感，需要尽量少引入延迟。在RoundRobinPacketQueue::Push中，有一个分支，如下：

if (size_packets_ == 0) {single_packet_queue_.emplace(QueuedPacket(priority, enqueue_time, enqueue_order,enqueue_times_.end(), std::move(packet)));UpdateQueueTime(enqueue_time);single_packet_queue_->SubtractPauseTime(pause_time_sum_);size_packets_ = 1;size_ += PacketSize(*single_packet_queue_);}

在 size_packets_ == 0，会放到single_packet_queue_。而每取一个数据包，size_packets设置0。对音频包，一次采集周期内，20ms，只会产生一个包，而pacer的执行周期是5ms，音频包始终会走入if (size_packets_ == 0)为0的分支。

在取数据包时，在std::unique_ptr<RtpPacketToSend> PacingController::GetPendingPacket方法中，会有一个判断语句，判断音频是否走pacer。

bool unpaced_audio_packet =!pace_audio_ && packet_queue_.LeadingAudioPacketEnqueueTime().has_value();

LeadingAudioPacketEnqueueTime()是判断single_packet_queue_或streams_是否有缓存音频包(下一个包是否是音频包)。

absl::optional<Timestamp> RoundRobinPacketQueue::LeadingAudioPacketEnqueueTime()const {if (single_packet_queue_.has_value()) {if (single_packet_queue_->Type() == RtpPacketMediaType::kAudio) {return single_packet_queue_->EnqueueTime();}return absl::nullopt;}if (stream_priorities_.empty()) {return absl::nullopt;}uint32_t ssrc = stream_priorities_.begin()->second;const auto& top_packet = streams_.find(ssrc)->second.packet_queue.top();if (top_packet.Type() == RtpPacketMediaType::kAudio) {return top_packet.EnqueueTime();}return absl::nullopt;
}

如果这个unpaced_audio_packet变量的值为true，这不会走media_buget_的机制，直接取出数据。

std::unique_ptr<RtpPacketToSend> PacingController::GetPendingPacket(const PacedPacketInfo& pacing_info,Timestamp target_send_time,Timestamp now) {if (packet_queue_.Empty()) {return nullptr;}// First, check if there is any reason _not_ to send the next queued packet.// Unpaced audio packets and probes are exempted from send checks.bool unpaced_audio_packet =!pace_audio_ && packet_queue_.LeadingAudioPacketEnqueueTime().has_value();bool is_probe = pacing_info.probe_cluster_id != PacedPacketInfo::kNotAProbe;//不pace audioif (!unpaced_audio_packet && !is_probe) {if (Congested()) {// Don't send anything if congested.return nullptr;}if (mode_ == ProcessMode::kPeriodic) {if (media_budget_.bytes_remaining() <= 0) {// Not enough budget.RTC_LOG(LS_INFO) << "===> media budget not enough";return nullptr;}} else {// Dynamic processing mode.if (now <= target_send_time) {// We allow sending slightly early if we think that we would actually// had been able to, had we been right on time - i.e. the current debt// is not more than would be reduced to zero at the target sent time.TimeDelta flush_time = media_debt_ / media_rate_;if (now + flush_time > target_send_time) {return nullptr;}}}}//直接取出数据return packet_queue_.Pop();
}

在std::unique_ptr<RtpPacketToSend> RoundRobinPacketQueue::Pop()方法中，走下面这个分支。

if (single_packet_queue_.has_value()) {//音频包走这个分支RTC_DCHECK(stream_priorities_.empty());std::unique_ptr<RtpPacketToSend> rtp_packet(single_packet_queue_->RtpPacket());single_packet_queue_.reset();queue_time_sum_ = TimeDelta::Zero();size_packets_ = 0;size_ = DataSize::Zero();return rtp_packet;}

在只有音频的情况下，音频包只会入single_packet_queue_，并且不会走media_buget_的机制，每次时间片内都会马上取出来发送出去，起到降低延迟的作用。

音视频流的处理

PacingController::ProcessPackets是每5ms跑一次(kPeriodic模式)。视频数据，一次会产生一批rtp包，在间隔周期内，会有多个包进入队列。在size_packets_为0时，包会进入single_packet_queue_，不为0时进入包缓存队列。在这个时候media_budget_就起作用了。

音视频流都存在的情况下，音频包也不止会进入single_pakcet_queue_了，这时音频的加速就体现在std::unique_ptr<RtpPacketToSend> PacingController::GetPendingPacket上了，判断为音频包时，则不走media_buget_机制，直接取出数据。

对非音频包，则下面这个分支会起作用，限制包的发送。

if (mode_ == ProcessMode::kPeriodic) {if (media_budget_.bytes_remaining() <= 0) {// Not enough budget.RTC_LOG(LS_INFO) << "===> media budget not enough";return nullptr;}
}

IntervalBudget

原理

IntervalBudget作用是根据当前PacedSender->Process的调用时间间隔和当前目标码率target bitrate来计算出本次Process理应发送的字节数。

比如当前码率是100 000bps，本次Process调用与上次调用间隔是20ms，则本次理应发送的字节数是100 bits per ms * 20 ms = 2000bits=250 bytes。

250bytes为本次发送理应发送的字节数，但实际上视频RTP包差不多是一个MTU大小。我们不可能真的发送250bytes的数据，因此可能会导致理应发送的数据量多或少的问题，如何解决这个问题呢？

IntervalBudget中引入一个bytes_remaining_的变量来记录上次发送后，与理应发送数据量相比，多或少发了多少。其值为负表示上轮我们实际发送的比理应发送的数据量多了，我们本轮应该停止发送。其值为正表示我们上轮实际发送比理应发送的要少，还有富余。

工作原理

void set_target_rate_kbps(int target_rate_kbps);设置总的可用量max_bytes_in_budget_。

void IntervalBudget::set_target_rate_kbps(int target_rate_kbps) {target_rate_kbps_ = target_rate_kbps;max_bytes_in_budget_ = (kWindowMs * target_rate_kbps_) / 8;bytes_remaining_ = std::min(std::max(-max_bytes_in_budget_, bytes_remaining_),max_bytes_in_budget_);
}

target_rate_kbps目标码率，max_bytes_in_budget_为半秒钟可发送的码率。

void IncreaseBudget(int64_t delta_time_ms);根据毫秒数增加预算(增加的量计入bytes_remaining)，在kPeriodic模式下，这个delta_time_ms的值为5ms。

void IntervalBudget::IncreaseBudget(int64_t delta_time_ms) {int64_t bytes = target_rate_kbps_ * delta_time_ms / 8;if (bytes_remaining_ < 0 || can_build_up_underuse_) {// We overused last interval, compensate this interval.bytes_remaining_ = std::min(bytes_remaining_ + bytes, max_bytes_in_budget_);} else {// If we underused last interval we can't use it this interval.bytes_remaining_ = std::min(bytes, max_bytes_in_budget_);}
}

void UseBudget(size_t bytes);使用预算(bytes_remaining_减去bytes)。

void IntervalBudget::UseBudget(size_t bytes) {bytes_remaining_ = std::max(bytes_remaining_ - static_cast<int>(bytes),-max_bytes_in_budget_);
}

UseBudget(size_t bytes)更新用掉的数据量(就是已发送的数据量)，如下调用堆栈

如果bytes_remaining_小于0，那么当然不能在发数据了。

**padding_budget_**的原理也一样，它是用于计算padding的数据量。

码率平滑的实现原理

发包的流程PacingController::ProcessPackets放在一个线程中，会被定时触发。被触发后，会计算当前时间和上次被调用时间的时间差，然后将时间差参数传入media_buget(**IntervalBudget**对象)，media_buget_算出当前时间片可以发送多少数据，然后从缓存队列(**RoundBobinPacketQueue**对象)中取出数据进行发送。

**media_buget_**计算时间片发送多少字节的公式如下：

**delta time：**上次检查时间点和这次检查时间点的时间差。

target bitrate: pacer的参考码率，是由probe模块根据网络探测带宽评估出来。

remain_bytes: 每次触发包时会减去发送报文的长度size，如果remain_bytes>0，继续从缓存队列中取下一个报文进行发送，直到remain_bytes<=0或者缓存队列没有更多的报文。

如果缓存队列没有更多待发的报文，但是**media_buget_**(**IntervalBudget**对象)计算出还可以发送更多的数据，这个时候pacer会进行padding报文补充。

四个用于控制发送码率的方法：

**bool PacingController::Congested()**

**void PacingController::OnPacketSent**** 底层socket发送的数据量的回调。**

**void PacingController::UpdateBudgetWithSentData(DataSize size)**

**void PacingController::UpdateOutstandingData(DataSize outstanding_data)**

码率分配

数据包的优先级

前面就提到了缓存队列是一个优先级队列，对数据包会设置一个优先级，在每次插入数据时(PacingController::EnqueuePacket(...)方法)，都会调用GetPriorityForType(RtpPacketMediaType type)，如下优先级：

int GetPriorityForType(RtpPacketMediaType type) {// Lower number takes priority over higher.switch (type) {case RtpPacketMediaType::kAudio:// Audio is always prioritized over other packet types.return kFirstPriority + 1;case RtpPacketMediaType::kRetransmission:// Send retransmissions before new media.return kFirstPriority + 2;case RtpPacketMediaType::kVideo:case RtpPacketMediaType::kForwardErrorCorrection:// Video has "normal" priority, in the old speak.// Send redundancy concurrently to video. If it is delayed it might have a// lower chance of being useful.return kFirstPriority + 3;case RtpPacketMediaType::kPadding:// Packets that are in themselves likely useless, only sent to keep the// BWE high.return kFirstPriority + 4;}RTC_CHECK_NOTREACHED();
}

在QueuedPacket中的operator<(const RoundRobinPacketQueue::QueuedPacket& other)会根据优先级确定QueuedPacket在队列中顺序。priority值越小，代表优先级越高，如下，在QueuedPacket中定义的bool operator<(const QueuedPacket& other) const

bool RoundRobinPacketQueue::QueuedPacket::operator<(const RoundRobinPacketQueue::QueuedPacket& other) const {if (priority_ != other.priority_)return priority_ > other.priority_;if (is_retransmission_ != other.is_retransmission_)return other.is_retransmission_;return enqueue_order_ > other.enqueue_order_;
}

● 优先值小的，排在前面。
● 优先级相同，非重传包在前面。
● 优先级和重传标志均相同，以入队先后顺序排列(enqueue_order_就是一个递增的值)。

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.mzph.cn/diannao/77611.shtml

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

【android bluetooth 协议分析 01】【HCI 层介绍 1】【hci_packets.pdl 介绍】

【android bluetooth 协议分析 01】【HCI 层介绍 1】【hci_packets.pdl 介绍】

在 AOSP 的蓝牙协议栈 (Gabeldorsche) 中&#xff0c;hci_packets.pdl 是一个 协议描述语言文件&#xff0c;用于定义 HCI (Host Controller Interface) 层的数据包结构和通信协议。以下是详细解析&#xff1a; 1. 文件作用 system/gd/hci/hci_packets.pdl 协议自动化生成&…
阅读更多...
操作系统 4.2-键盘

操作系统 4.2-键盘

键盘中断初始化和处理 提取的代码如下&#xff1a; // con_init 函数&#xff0c;初始化控制台&#xff08;包括键盘&#xff09;的中断 void con_init(void) {set_trap_gate(0x21, &keyboard_interrupt); } ​ // 键盘中断处理函数 .globl _keyboard_interrupt _keyboard…
阅读更多...
深入理解Softmax函数及其在PyTorch中的实现

深入理解Softmax函数及其在PyTorch中的实现

Softmax函数简介 Softmax函数在机器学习和深度学习中&#xff0c;被广泛用于多分类问题的输出层。它将一个实数向量转换为概率分布&#xff0c;使得每个元素介于0和1之间&#xff0c;且所有元素之和为1。 Softmax函数的定义 给定一个长度为 K K K的输入向量 z [ z 1 , z 2 …
阅读更多...
Vue 3 响应式更新问题解析

Vue 3 响应式更新问题解析

在 Vue 3 中&#xff0c;即使使用 reactive 或 ref 创建的响应式数据&#xff0c;当数据量很大时也可能出现更新不及时的情况。以下是原因和解决方案&#xff1a; 核心原因 ​​响应式系统优化机制​​&#xff1a; Vue 3 使用 Proxy 实现响应式&#xff0c;比 Vue 2 更高效但为…
阅读更多...
异形遮罩之QML中的 `OpacityMask` 实战

异形遮罩之QML中的 `OpacityMask` 实战

文章目录 &#x1f327;️ 传统实现的问题&#x1f449; 效果图 &#x1f308; 使用 OpacityMask 的理想方案&#x1f449;代码如下&#x1f3af; 最终效果&#xff1a; ✨ 延伸应用&#x1f9e0; 总结 在 UI 设计中&#xff0c;经常希望实现一些“异形区域”拥有统一透明度或颜…
阅读更多...
数据可视化 —— 堆形图应用（大全）

数据可视化 —— 堆形图应用（大全）

一、案例一&#xff1a;温度堆积图 # 导入 matplotlib 库中的 pyplot 模块&#xff0c;这个模块提供了类似于 MATLAB 的绘图接口&#xff0c; # 方便我们创建各种类型的可视化图表&#xff0c;比如折线图、柱状图、散点图等 import matplotlib.pyplot as plt # 导入 numpy 库&…
阅读更多...
python工程中的包管理（requirements.txt）

python工程中的包管理（requirements.txt）

pip install -r requirements.txtpython工程通过requirements.txt来管理依赖库版本&#xff0c;上述命令&#xff0c;可以一把安装依赖库&#xff0c;类似java中maven的pom.xml文件。 参考 [](
阅读更多...
操作系统 3.4-段页结合的实际内存管理

操作系统 3.4-段页结合的实际内存管理

段与页结合的初步思路 虚拟内存的引入&#xff1a; 为了结合段和页的优势&#xff0c;操作系统引入了虚拟内存的概念。虚拟内存是一段地址空间&#xff0c;它映射到物理内存上&#xff0c;但对用户程序是透明的。 段到虚拟内存的映射&#xff1a; 用户程序中的段首先映射到虚…
阅读更多...
【Amazon EC2】为何基于浏览器的EC2 Instance Connect 客户端连接不上EC2实例

【Amazon EC2】为何基于浏览器的EC2 Instance Connect 客户端连接不上EC2实例

文章目录 前言&#x1f4d6;一、报错先知❌二、问题复现&#x1f62f;三、解决办法&#x1f3b2;四、验证结果&#x1f44d;五、参考链接&#x1f517; 前言&#x1f4d6; 这篇文章将讲述我在 Amazon EC2 上使用 RHEL9 AMI 时无法连接到 EC2 实例时所遇到的麻烦&#x1f616; …
阅读更多...
Python学习笔记（二）（字符串）

Python学习笔记（二）（字符串）

文章目录 编写简单的程序一、标识符 (Identifiers)及关键字命名规则&#xff1a;命名惯例&#xff1a;关键字 二、变量与赋值 (Variables & Assignment)变量定义&#xff1a;多重赋值&#xff1a;变量交换&#xff1a;&#xff08;很方便哟&#xff09; 三、输入与输出 (In…
阅读更多...
Hydra Columnar：一个开源的PostgreSQL列式存储引擎

Hydra Columnar：一个开源的PostgreSQL列式存储引擎

Hydra Columnar 是一个 PostgreSQL 列式存储插件&#xff0c;专为分析型&#xff08;OLAP&#xff09;工作负载设计&#xff0c;旨在提升大规模分析查询和批量更新的效率。 Hydra Columnar 以扩展插件的方式提供&#xff0c;主要特点包括&#xff1a; 采用列式存储&#xff0c…
阅读更多...
es的告警信息

es的告警信息

Elasticsearch&#xff08;ES&#xff09;是一个开源的分布式搜索和分析引擎&#xff0c;在运行过程中可能会产生多种告警信息&#xff0c;以提示用户系统中存在的潜在问题或异常情况。以下是一些常见的 ES 告警信息及其含义和处理方法&#xff1a; 集群健康状态告警 信息示例…
阅读更多...
健康与好身体笔记

健康与好身体笔记

文章目录 保证睡眠饭后百步走&#xff0c;活到九十九补充钙质一副好肠胃肚子咕咕叫 健康和工作的取舍 以前对健康没概念&#xff0c;但是随着年龄增长&#xff0c;健康问题凸显出来。 持续维护该文档&#xff0c;健康是个永恒的话题。 保证睡眠 一是心态要好&#xff0c;沾枕…
阅读更多...
vue实现在线进制转换

vue实现在线进制转换

vue实现在线进制转换 主要功能包括&#xff1a; 1.支持2-36进制之间的转换。 2.支持整数和浮点数的转换。 3.输入验证&#xff08;虽然可能存在不严格的情况&#xff09;。 4.错误提示。 5.结果展示&#xff0c;包括大写字母。 6.用户友好的界面&#xff0c;包括下拉菜单、输…
阅读更多...
智体知识库：poplang编程语言是什么？

智体知识库：poplang编程语言是什么？

问&#xff1a;poplang语言是什么 Poplang 语言简介 Poplang&#xff08;OPCode-Oriented Programming Language&#xff09;是一种面向操作码&#xff08;Opcode&#xff09;的轻量级编程语言&#xff0c;主要用于智体&#xff08;Agent&#xff09;系统中的自动化任务处理、…
阅读更多...
二分查找5：852. 山脉数组的峰顶索引

二分查找5：852. 山脉数组的峰顶索引

链接&#xff1a;852. 山脉数组的峰顶索引 - 力扣&#xff08;LeetCode&#xff09; 题解&#xff1a; 事实证明&#xff0c;二分查找不局限于有序数组&#xff0c;非有序的数组也同样适用 二分查找主要思想在于二段性&#xff0c;即将数组分为两段。本体就可以将数组分为ar…
阅读更多...
下列软件包有未满足的依赖关系: python3-catkin-pkg : 冲突: catkin 但是 0.8.10-

下列软件包有未满足的依赖关系: python3-catkin-pkg : 冲突: catkin 但是 0.8.10-

下列软件包有未满足的依赖关系: python3-catkin-pkg : 冲突: catkin 但是 0.8.10- 解决&#xff1a; 1. 确认当前的包状态 首先&#xff0c;运行以下命令来查看当前安装的catkin和python3-catkin-pkg版本&#xff0c;以及它们之间的依赖关系&#xff1a; dpkg -l | grep ca…
阅读更多...
深度学习：AI 大模型时代的智能引擎

深度学习：AI 大模型时代的智能引擎

当 Deepspeek 以逼真到难辨真假的语音合成和视频生成技术横空出世&#xff0c;瞬间引发了全球对 AI 伦理与技术边界的激烈讨论。从伪造名人演讲、制造虚假新闻&#xff0c;到影视行业的特效革新&#xff0c;这项技术以惊人的速度渗透进大众视野。但在 Deepspeek 强大功能的背后…
阅读更多...
医学分割新标杆！双路径PGM-UNet：CNN+Mamba实现病灶毫厘级捕捉

医学分割新标杆！双路径PGM-UNet：CNN+Mamba实现病灶毫厘级捕捉

一、引言&#xff1a;医学图像分割的挑战与机遇 医学图像分割是辅助疾病诊断和治疗规划的关键技术&#xff0c;但传统方法常受限于复杂病理特征和微小结构。现有深度学习模型&#xff08;如CNN和Transformer&#xff09;虽各有优势&#xff0c;但CNN难以建模长距离依赖&…
阅读更多...
CV - 目标检测

CV - 目标检测

物体检测 目标检测和图片分类的区别&#xff1a; 图像分类&#xff08;Image Classification&#xff09; 目的&#xff1a;图像分类的目的是识别出图像中主要物体的类别。它试图回答“图像是什么&#xff1f;”的问题。 输出&#xff1a;通常输出是一个标签或一组概率值&am…
阅读更多...
最新文章

Copyright @ 2022~2023