Home / Blog / Common Issues / Common Video Calls Bugs and How to Catch Them

Common Video Calls Bugs and How to Catch Them

Common Video Calls Bugs and How to Catch Them

January 20, 2026 · 18 min read · Common Issues

Common Video Calls Bugs and How to Catch Them

Video conferencing has become a core feature sets of the customer support portals to internal team tools. When a video call feature misbehaves, users notice immediately—dropped audio, frozen video, or a broken screen‑share flow can erode trust and push people to alternatives. This guide walks through the most frequent defects that surface in real‑world video‑call implementations, explains why they occur, shows how to reproduce them reliably, and gives concrete steps to fix and prevent each class of issue.

---

Common Video Calls Bugs and How to Catch Them: Audio Glitches

Audio problems are the most visible class of failure because users can hear them instantly. Typical symptoms include echo, one‑way audio, clipping, or sudden drops to silence. These glitches often stem from mismatched sample rates, incorrect handling of the WebRTC getUserMedia constraints, or race conditions when switching between microphone and speaker devices.

Why audio glitches happen

When a browser or native SDK initializes an audio track, it negotiates a sample rate (commonly 48 kHz for WebRTC). If the capture device reports a different rate—say 44.1 kHz from a USB headset—and the application forces a resample without proper buffering, the audio pipeline can underrun or overrun, producing clicks or silence. Another frequent cause is the failure to release the previous audio stream before requesting a new one, leaving the audio module in a locked state on some Android OEM skins.

Reproducing the bug

  1. Connect two clients: one using a USB headset that defaults to 44.1 kHz, the other using the built‑in microphone (48 kHz).
  2. In the call, invoke getUserMedia({ audio: { sampleRate: 48000 } }) on the headset client without checking the actual mediaStreamTrack.getSettings().sampleRate.
  3. Observe the remote participant hearing periodic clicks every second or a brief mute after the first few seconds.

A scripted test that always uses the default microphone will miss this because it never encounters the mismatched device.

Detection strategies

Fix and prevention

Code snippet – safe audio track swap (JavaScript)


let audioTrack = null;

async function switchAudioDevice(deviceId) {
  if (audioTrack) {
    audioTrack.stop();
    await new Promise(res => audioTrack.addEventListener('ended', res));
  }
  const stream = await navigator.mediaDevices.getUserMedia({
    audio: { deviceId: { exact: deviceId } }
  });
  audioTrack = stream.getAudioTracks()[0];
  myPeerConnection.addTrack(audioTrack, stream);
}

---

Common Video Calls Bugs and How to Catch Them: Video Freeze

A frozen video frame while audio continues is a classic sign that the video pipeline stalled while the audio path stayed healthy. Users see a static image that may linger for seconds or minutes, often accompanied by a “reconnecting” badge that never clears.

Root causes

Video freeze usually originates from one of three places:

  1. Encoder overload – The CPU cannot keep up with the requested resolution/frame‑rate, causing the encoder to drop frames and eventually stall.
  2. Packet loss burst – A sudden loss of UDP packets (common on congested Wi‑Fi) leads to missing key frames; the decoder waits for the next I‑frame and shows the last decoded picture.
  3. Graphics texture leak – In native apps, each decoded frame is uploaded to a GPU texture; if the texture is not released, the GPU runs out of memory and stops accepting new frames.

Reproducing the freeze

Detection strategies

Fix and prevention

Command – simulate packet loss for WebRTC (Linux)


# Replace eth0 with the interface carrying UDP traffic
sudo tc qdisc add dev eth0 root netem loss 10% delay 20ms
# After test, restore normal state
sudo tc qdisc del dev eth0 root

---

Common Video Calls Bugs and How to Catch Them: Screen Share Failures

Screen sharing introduces a second video source that often uses a different capture pipeline (desktop capture API, media projection, or broadcast intent). Failures appear as a black rectangle, a frozen shared view, or the caller seeing their own camera instead of the shared screen.

Why screen share breaks

Reproducing the failure

  1. Permission mishandling: On a macOS test machine, disable “Screen Recording” for the test app in System Preferences → Privacy & Security. Initiate a share; the remote participant sees a black tile.
  2. Secure surface: On an Android device with Samsung Secure Folder enabled, start a media projection without requesting android.permission.CAPTURE_SECURE_VIDEO_OUTPUT. The shared view appears black.
  3. Frame‑rate stress: Set the capture frame rate to 60 fps via navigator.mediaDevices.getDisplayMedia({ video: { frameRate: { ideal: 60 } } }) while limiting the encoder to 15 fps. After ~30 seconds the shared video freezes.

Detection strategies

Fix and prevention

Snippet – permission‑aware screen share (Web)


async function startShare() {
  try {
    const stream = await navigator.mediaDevices.getDisplayMedia({
      video: { cursor: "always" }
    });
    const track = stream.getVideoTracks()[0];
    if (!track.enabled) {
      throw new Error('Screen capture denied');
    }
    // optional: force frame rate to match encoder
    track.applyConstraints({ frameRate: { max: 15 } });
    return track;
  } catch (e) {
    console.error('Screen share failed:', e);
    return null;
  }
}

---

Common Video Calls Bugs and How to Catch Them: Network Latency Impact

High round‑trip time (RTT) and jitter manifest as delayed lip‑sync, frozen video, or audio that sounds “underwater.” While some latency is inevitable on cellular or satellite links, bugs in the congestion control or jitter buffer can turn tolerable delay into unusable quality.

Latency‑related failure modes

Reproducing latency issues

Detection strategies

Fix and prevention

Command – add jitter and delay for testing


# 150 ms base delay, 30 ms jitter (Gaussian)
sudo tc qdisc add dev eth0 root netem delay 150ms 30ms distribution normal

---

Common Video Calls Bugs and How to Catch Them: Permission Handling

Modern browsers and mobile OSes require explicit user consent for camera, microphone, screen capture, and sometimes location (for regional servers). Mishandling these dialogs leads to silent failures where the call starts but no media flows.

Typical permission bugs

Reproducing permission bugs

  1. Delayed grant: In a test harness, mock navigator.mediaDevices.getUserMedia to return a pending promise that resolves after 3 seconds. Start the call immediately; the local video element shows a black frame.
  2. Denial path: Pre‑set the browser permission to “Block” for camera and microphone. Attempt to start a call; the app logs “Failed to get user media” but continues to show a connecting UI.
  3. Android manifest mistake: Build an APK with (missing the android. prefix). On a Pixel 6, the camera opens but returns all‑black frames.

Detection strategies

Fix and prevention

Snippet – robust media request with timeout (JS)


function getUserMediaWithTimeout(constraints, timeout = 2000) {
  return Promise.race([
    navigator.mediaDevices.getUserMedia(constraints),
    new Promise((_, reject) =>
      setTimeout(() => reject(new Error('getUserMedia timeout')), timeout)
    )
  ]);
}

// Usage
getUserMediaWithTimeout({ video: true, audio: true })
  .then(stream => attachStream(stream))
  .catch(err => {
    showPermissionDeniedUI(err);
    console.error(err);
  });

---

Common Video Calls Bugs and How to Catch Them: Device Orientation

When a user rotates their phone or switches a laptop from landscape to portrait, the video orientation can become upside‑down, mirrored, or stretched. This is especially disruptive in multi‑person grids where each tile expects a consistent orientation.

Why orientation bugs appear

Reproducing orientation failures

Detection strategies

Fix and prevention

Code – apply Camera2 rotation before encoding (Java)


private final ImageReader imageReader = ImageReader.newInstance(
    width, height, ImageFormat.YUV_420_888, 2);

imageReader.setOnImageAvailableListener(reader -> {
    Image img = reader.acquireLatestImage();
    if (img == null) return;

    int rotation = img.getTransformMatrix().getRotation(); // pseudo‑API
    Plane[] planes = img.getPlanes();
    ByteBuffer yBuffer = planes[0].getBuffer();
    ByteBuffer uBuffer = planes[1].getBuffer();
    ByteBuffer vBuffer = planes[2].getBuffer();

    // Rotate YUV buffers if needed (simplified)
    if (rotation == 90 || rotation == 270) {
        // swap width/height and re‑index buffers
        // ... implementation omitted for brevity
    }

    encoder.submitInputBuffer(yBuffer, uBuffer, vBuffer);
    img.close();
}, handler);

---

Common Video Calls Bugs and How to Catch Them: Background Noise Suppression

Noise suppression (NS) aims to remove keyboard clicks, fan hum, or background chatter. When the NS algorithm is too aggressive, it can cut off speech onsets, producing a “robotic” or “choppy” voice. When it is too weak, users hear distracting noises that reduce intelligibility.

Failure patterns

Reproducing NS defects

  1. Over‑suppression: Play a recording of a sentence with sharp plosives at –30 dBm, add white noise at –20 dBm, and feed the mix into the mic. Listen to the output; the initial burst of each plosive will be attenuated.
  2. Under‑suppression: Run a call while a YouTube video plays at 60 dB SPL in the background. With NS disabled or set to “low”, the remote participant hears the video audio clearly.
  3. State glitch: Start a call in a silent room (noise floor –60 dB), then suddenly turn on a blender (≥ 40 dB). Observe that the NS continues to suppress speech as if the blender were still absent for ~2 seconds.

Detection strategies

Fix and prevention

Snippet – simple VAD‑based NS pseudo‑code (C)


float noise_estimate = INITIAL_NOISE;
float speech_prob    = 0.0f;
const float alpha_up   = 0.9f;   // adapt when speech likely
const float alpha_down = 0.99f;  // adapt when noise likely

for each frame {
    float frame_energy = computeEnergy(frame);
    speech_prob = vad(frame); // 0..1

    if (speech_prob > 0.5) {
        // speech present: adapt noise estimate slowly downward
        noise_estimate = alpha_down * noise_estimate +
                         (1.0f - alpha_down) * frame_energy;
    } else {
        // likely noise: adapt upward quickly
        noise_estimate = alpha_up * noise_estimate +
                         (1.0f - alpha_up) * frame_energy;
    }

    float gain = 1.0f / (1.0f + expf((noise_estimate - frame_energy) * K));
    applyGain(frame, gain);
}

---

Common Video Calls Bugs and How to Catch Them: Chat Overlay Issues

Many video‑call apps overlay a text chat pane, participant list, or reaction emojis on top of the video feed. Bugs here manifest as the chat covering the speaker’s face, text rendering incorrectly on certain DPI scales, or the overlay stealing pointer events and preventing UI interaction with the call controls.

Why chat overlays break

Reproducing overlay bugs

Detection strategies

Fix and prevention

Snippet – safe overlay layout (CSS/HTML)


<div class="call-container">
  <video id="local-video" autoplay playsinline></video>
  <div id="chat-pane" class="overlay">
    <!-- chat messages -->
  </div>
</div>


.call-container {
  display: flex;
  position: relative;
  width: 100%;
  height: 100%;
}
#local-video {
  flex: 1;
  object-fit: cover;
}
#chat-pane {
  position: absolute;
  inset: 0;
  pointer-events: none; /* let clicks fall through to video */
  display: flex;
  flex-direction: column;
  padding: 8px;
}
#chat-pane .input-box {
  pointer-events: auto; /* only the input captures */
}

---

Common Video Calls Bugs and How to Catch Them: Recording Artifacts

Recording a call for later playback or compliance introduces a separate pipeline: the app must mux audio and video streams, often while simultaneously encoding for transmission. Recording bugs appear as desynchronized audio/video, missing frames, or files that refuse to open in standard players.

Sources of recording defects

Reproducing recording problems

Detection strategies

Fix and prevention

Test Your App Autonomously

Upload your APK or URL. SUSA explores like 10 real users — finds bugs, accessibility violations, and security issues. No scripts.

Try SUSA Free

Related Articles