Video freezes after removing the `set_current_bitrate` method

[Razzwan]

I'm a bit behind with the project updates. In particular, when trying to merge changes related to removing the set_current_bitrate method, the videos in a room with 10 participants start to freeze. This doesn't happen when there are only 3-4 participants in the room. It's likely due to changes in how Rids should be modified.

Should I make some changes in this code?:

  Event::EgressBitrateEstimate(bitrate_kind) => match bitrate_kind {
      BweKind::Remb(_mid, _bitrate) => Propagated::Noop,
      // should handle_bitrate be significantly modifyed after changes?
      BweKind::Twcc(bitrate) => self.handle_bitrate(bitrate, sfu_tx),
      // What shout be done here?
      _ => Propagated::Noop,
  },

Other place, I don't understand:

let mut rtc = Rtc::builder()
    .set_rtp_mode(false)
    .clear_codecs()
    .enable_h264(true)
    .enable_opus(true)
    .enable_vp8(true)
    .enable_bwe(Some(self.rids_info.low_exac(clients_amount)))
    .set_stats_interval(None)
    .build(Instant::now() /* can it be something except Instant::now()? If yes, then in which cases? */);

Perhaps, some other places must be changed to make it work. If so, please share the docs, which describe this changes?

[algesten]

Hi @Razzwan!

// should handle_bitrate be significantly modifyed after changes?

No. It should be a better estimate than before.

.enable_bwe(Some(self.rids_info.low_exac(clients_amount)))

You don't need to communicate your current bitrate anymore, only the desired one.

/* can it be something except Instant::now()? If yes, then in which cases? */)

You probably always want Instant::now() unless you're writing some kind of test that manipulates time.

[Razzwan]

Hi @algesten!

No. It should be a better estimate than before.

It seems that along with the improvement in the estimation, there is also a significant slowdown in the execution of the code, as in my case, this leads to a slowdown in the playback of the video, even to a complete halt.

You don't need to communicate your current bitrate anymore, only the desired one.

I see, but if I remove .enable_bwe(Some(self.rids_info.low_exac(clients_amount))) then BWE will be disabled at all. Should I set it up differently?

Perhaps some changes need to be made to the code for distributing videos to all clients? Right now my code looks like this:

        loop {
            room.peers.retain(|c| c.rtc.is_alive());
            room.reviewers.retain(|r| r.rtc.is_alive());

            let mut deadline = Instant::now() + Duration::from_millis(50);

            let peers_len = room.peers.len();
            for i in 0..peers_len {
                let idx = (cl_start_idx + i) % peers_len;
                match poll_cl_until_timeout(
                    room.peers.get_mut_by_idx(idx),
                    &mut to_propagate,
                    &socket,
                    &room.tx,
                    deadline,
                ) {
                    PollRes::Break => break,
                    PollRes::Timeout(t) => deadline = t,
                }
            }
            if peers_len > 0 {
                cl_start_idx = (cl_start_idx + 1) % peers_len;
            }

            if deadline > Instant::now() {
                let reviewers_len = room.reviewers.len();
                for i in 0..reviewers_len {
                    let idx = (rv_start_idx + i) % reviewers_len;
                    match poll_rv_until_timeout(
                        room.reviewers.get_mut_by_idx(idx),
                        &mut to_propagate,
                        &socket,
                        &room.tx,
                        deadline,
                    ) {
                        PollRes::Break => break,
                        PollRes::Timeout(t) => deadline = t,
                    }
                }
                if reviewers_len > 0 {
                    rv_start_idx = (rv_start_idx + 1) % reviewers_len;
                }
            }

            if deadline > Instant::now() {
                let mut iter = 0usize;

                while let Some(p) = to_propagate.pop_front() {
                    propagate(&p, &mut room);
                    iter += 1;
                    if iter % ONCE_PER_ITER == 0 && Instant::now() >= deadline {
                        break;
                    }
                }
                if iter > 0 {
                    continue;
                }
            } else {
                if let Some(p) = to_propagate.pop_front() {
                    propagate(&p, &mut room);
                    continue;
                }
            }

            let remaining = deadline
                .saturating_duration_since(Instant::now())
                .max(Duration::from_millis(4));

            socket
                .set_read_timeout(Some(remaining))
                .expect("setting socket read timeout");

            if let Some(input) = read_socket_input(&socket, socket_addr, &mut buf) {
                if let Some(cl) = room.peers.iter_mut().find(|e| e.accepts(&input)) {
                    cl.handle_input(input);
                } else {
                    if let Some(rv) = room.reviewers.iter_mut().find(|e| e.accepts(&input)) {
                        rv.handle_input(input);
                    } else {
                        if let Some(room_voice) = &mut room.voice {
                            if room_voice.accepts(&input) {
                                room_voice.handle_input(input);
                            }
                        }
                    }
                }
            }

            // Drive time forward in all peers.
            let now = Instant::now();
            for cl in room.peers.iter_mut() {
                cl.handle_input(Input::Timeout(now));
            }
            // Drive time forward in all reviewers.
            for rv in room.reviewers.iter_mut() {
                rv.handle_input(Input::Timeout(now));
            }

            // Perhaps there's an error in these last parts of the code that are trying to execute empty loop passes to initiate forward movement?
        }

In short, I haven't been able to update to a version without the set_current_bittrate method yet.