Quasar Stream

Initialization

This creates a new WebRTC peer connection instance. You can optionally pass a RTCConfiguration object here if you want to customize ICE servers or DTLS certificates(See above example).

$pc = new RTCPeerConnection();

Handling Incoming DataChannels

$pc->on("datachannel", function (RTCDataChannel $channel) {
    $channel->on("message", function (string $message) use ($channel) {
        $channel->send($message); // Echo the message
    });
});

• When the remote peer creates a DataChannel, the datachannel event is fired.
• Inside this event, you can listen for message events and react.
• In this example, we echo the incoming message back to the sender.

Handling Media Tracks

$pc->on("track", function (MediaStreamTrack $track) use ($pc) {
    $pc->addTrack($track);
});

• When a remote peer adds a media track (audio/video), the track event fires.
• You can optionally choose to call $pc->addTrack($track) to register it on your end, or attach it to a MediaStream.

Negotiating Session Descriptions

The following code snippet demonstrates how to handle an incoming SDP offer in a WebRTC session using PHP. It follows the offer/answer exchange model defined by the WebRTC standard and mirrors the behavior seen in JavaScript-based implementations.

$pc->setRemoteDescription($request->getOffer())
    ->then(fn() => $pc->createAnswer())
    ->then(fn(RTCSessionDescription $description) => $pc->setLocalDescription($description))
    ->then(fn() => $request->sendOffer($pc->getLocalDescription()))
    ->catch(fn(Throwable $e) => $request->respondError($e->getMessage(), 400));

This performs the classic WebRTC "answer" process:

• 1. Set Remote Offer – from the other peer
• 2. Create Answer – your SDP response
• 3. Create Answer – your generated SDP answer
• 4. Send Local SDP back – e.g., via your signaling server

State Changes

You can observe the internal state transitions of a WebRTC RTCPeerConnection instance using event listeners. These events help track the lifecycle and connectivity status of the connection, which is essential for debugging and diagnostics.

This code sets up event listeners on a WebRTC RTCPeerConnection object ($pc) to log changes in its internal states. When state transitions occur in the connection (connectionstatechange), ICE connection (iceconnectionstatechange), ICE gathering (icegatheringstatechange), or signaling (signalingstatechange), corresponding messages are printed to the console. This is useful for debugging or observing connection lifecycle events in real time during a WebRTC session.

// state changes trigger
$pc->on("connectionstatechange", function () use ($pc) {
    echo sprintf("connectionstatechange: %s\n", $pc->getConnectionState()->name);
});

$pc->on("iceconnectionstatechange", function () use ($pc) {
    echo sprintf("iceconnectionstatechange: %s\n", $pc->getIceConnectionState()->name);
});

$pc->on("icegatheringstatechange", function () use ($pc) {
    echo sprintf("icegatheringstatechange: %s\n", $pc->getIceGatheringState()->name);
});

$pc->on("signalingstatechange", function () use ($pc) {
    echo sprintf("signalingstatechange: %s\n", $pc->getSignalingState()->name);
});

Stats

WebRTC provides detailed statistics through the getStats() method—similar to the JavaScript WebRTC API —allowing developers to inspect media streams, transports, and encoding performance.

In this example, we use a periodic timer to gather key statistics from a RTCPeerConnection. Specifically, we calculate the current upload and download bandwidth by summing byte counts from RTCTransportStats. You can also use RTCOutboundRTPStreamStats and RTCInboundRTPStreamStats for calculating bandwidth

This gives you real-time visibility into media transmission performance, helping you monitor network conditions, track degradation, or trigger adaptive behaviors (e.g. lowering bitrate on poor connections).

//Stats
use React\EventLoop\Loop;

$loop = Loop::get();

$lastBytesSent = 0;
$lastBytesReceived = 0;

$loop->addPeriodicTimer(1, function () use ($pc, &$lastBytesSent, &$lastBytesReceived) {
    $stats = $pc->getStats();

    $bytesSent = 0;
    $bytesReceived = 0;

    foreach ($stats->getStats() as $stat) {
//      if ($stat instanceof RTCOutboundRTPStreamStats) {
//          $bytesSent += $stat->bytesSent;
//      }
//
//      if ($stat instanceof RTCInboundRTPStreamStats) {
//          $bytesReceived += $stat->packetsReceived;
//      }

        if ($stat instanceof RTCTransportStats) {
            $bytesSent += $stat->bytesSent;
            $bytesReceived += $stat->bytesReceived;
        }
    }

    echo sprintf(
        "\rUpload Bandwidth: %d Kbps | Download Bandwidth: %d Kbps",
        intval(($bytesSent - $lastBytesSent) / 1024),
        intval(($bytesReceived - $lastBytesReceived) / 1024)
    );

    $lastBytesSent = $bytesSent;
    $lastBytesReceived = $bytesReceived;
});

Creating Datachannel:

$channel = $pc->createDataChannel("chat");

$channel->on("open", function () use ($channel) {
    $channel->send("Hello!");
});

$channel->on("message", function (string $msg) {
    echo "Received: $msg\n";
});