The watershed sits at 4x, and decode throughput is why
Below 4x, video decodes as usual with display durations scaled by the speed, dropping frames to catch up when it falls behind; audio keeps sounding, only on a compressed timeline. That half of the machinery — the speed change happening before anything is handed to the device, and how the clock moves — was covered in the audio rendering and AV sync articles, so I will not repeat it here.
The 4x line is not an arbitrary pick. Decoding is the heaviest stage on this chain, and at full load it manages about 4x real time: between 2x and 4x the decode thread does not even yield its time slice, taking the next packet the moment it can; any higher, decoding every frame can no longer keep up, and the only way out is to not decode non-keyframes. The comment in the code says exactly this: past four times only I frames are decoded, and it can afford to slow down instead. So the two sides of the line are two strategies — one side decodes at full speed and lets the render end control the pace by dropping frames; the other side simply stops decoding and takes the pressure off decode.
Dropping is also kept to one place: the frame-dropping branch on the decode side is commented out in the code, and all actual dropping happens where packets come in. Dropping in both places means two spots each pulling their own way, and the pacing comes out messier, not cleaner.
Exactly 4x is still handled in full; dropping only takes effect past it.
Past 4x: dropping happens where packets come in
The I-frame-only switch being on and the speed being past 4x fold into one truth value, shared by three places: packet intake, render pacing, and the audio decode thread's timeout exemption. The sharing is deliberate — during I-frame mode the audio decode thread has to keep resetting its timeout, because audio packets being dropped and nothing left to decode is the expected state. If that side's criterion were written separately as "speed greater than four", then with the switch off and audio packets flowing normally the exemption would still be in force, and a real decode failure would be swallowed.

Two kinds are dropped at intake: non-keyframe video packets go straight in the bin, and audio packets with them. Configuration frames pass as usual — when the speed drops back under 4x, the new decoder needs them to pick up immediately. Recording is unaffected: recording takes the complete original stream; dropping frames is only a playback policy.
Why drop audio outright instead of muting it? Muted, the audio pipeline keeps consuming at the original rate, the packet queue fills up fast, enqueueing blocks, and the demuxer can no longer feed video packets — the video I-frame pipeline starves, of all things. The other way around, when consumption runs faster than production, the demuxer reads furiously and the progress bar flickers. Dropping at intake means the demuxer is paced only by the video I-frame pipeline's own speed-scaled self-throttling, and the audio side needs no throttling knobs at all. The price is that sync loses its counterpart — past 4x audio is not rendered, AV sync is switched off with it, and comes back when the speed comes back down.
Render pacing and progress in I-frame mode
In I-frame mode, each frame is displayed for exactly its own duration divided by the speed: a source with a keyframe every two seconds, at 8x, shows each frame for 250 ms. Three habits from normal mode all change here: keyframes are far apart to begin with, so a long gap is not judged a timestamp jump; frames are few to begin with, so no frame dropping; and there is no audio clock to chase, so the render paces itself purely by its own scaled durations.
The progress bar changes its criterion too: it takes where rendering has reached, not where reading has. Past 4x, disk or network reads ahead, and the video queue can cache hundreds of keyframes — tens of seconds to minutes of content — so taking the read position as progress makes the bar lie.
The source side has an I-frame mode of its own
Everything above is the playback side's strategy. There is also a class of streams that are pure keyframes to begin with: some sliced and monitoring streams where the server only sends I frames. You hit these without any speed multiplier at all, and the engine detects them automatically on the source side — receiving keyframes with different timestamps in a row enters I-frame mode, and a P or B frame arriving exits it. The other path is anticipation: only sources that truly carry speed semantics (the server can cut the stream by speed) anticipate into the mode under a multiplier; for local and VOD sources whose packet flow does not change with speed, anticipating would only mute for nothing and upset the clock.
Crossing the line is handled like a seek
Switching in either direction, the trap is the moment of the switch itself, and the two directions are symmetric.

Speeding up (from under 4x to past it): the gate only blocks new packets, and the tens of seconds of stale P and B packets already piled up in the queue have to be drained by decoding before I-frame mode truly begins — a drain of seconds to tens of seconds. You click 8x, the picture keeps playing slowly for a while, then suddenly starts jumping. The fix is to treat it as a seek: for a source that can be repositioned, reposition straight to the current render position, flush out the old packets, and every packet after the restart passes the already-opened dropping. Speed changes inside the past-4x regime (8x down to 6x) never had a backlog and do not take this path.
Slowing down (back under 4x) is the other direction: past 4x the audio packets were dropped and the demuxer read ahead, so where audio resumes does not line up with where the video has rendered, and the progress bar jumps back and forth with the audio clock. The fix is the same — reposition to the render position; that half was covered in the AV sync article. Sources that cannot be repositioned (pure live) have neither path, and the error can only converge slowly through buffering and the sync that follows.
One more unobtrusive lag: once the tempo plugin's playback state is calibrated, returning to 1x does not reset it immediately. The divergence between the audio and video decode timelines accumulated at half speed and 2x only converges once the queue drains, and until then the alignment watchdog would misreport that divergence as a fault, so the latch stays closed until the source changes or the player shuts down.
On the user's side this line is easy to recognize: past 4x sound is not rendered at all, so crossing it is the difference between sound and no sound, not a quieter sound; pitch change only happens under 4x, and only on the degraded path where the tempo plugin is missing.
The engine avox is open source on GitHub: github.com/xxxzhou/avox, where both regimes on either side of the 4x line live.