petere/TeleportFling
1
0
Fork 0
Code Issues 3 Pull Requests Actions Packages Projects Releases Wiki Activity

feat: add bitrate measurement and quality presets

Browse Source 
- sender tracks payload bytes; engine measures stream bitrate over a
  sliding window and exposes it in Status
- GUI status label and tray tooltip show the live bitrate (e.g. 36 Mbps)
- add a Preset dropdown (Low/Medium/High/Ultra) that sets quality+fps
  together and applies live via SetConfig

Verified: 36 Mbps shown for Medium (quality 70 @ 30fps) matches the
wire measurement.
This commit is contained in:
petere
2026-09-19 17:53:49 +01:00
parent 95f47abadb
commit 583274d9e6
4 changed files with 172 additions and 3 deletions
Download Patch File Download Diff File Expand all files Collapse all files
internal/flinger/flinger.go
+59 -2
View File
@@ -10,6 +10,7 @@ package flinger
import (
"errors"
"fmt"
"image"
"image/color"
"io"
@@ -92,6 +93,9 @@ type Status struct {
Frames int64
Dropped int64
Conns int
// Bitrate is the measured stream bandwidth in bits per second, averaged
// over the previous measurement window.
Bitrate int64
// Err is the most recent runtime error encountered (capture, encode,
// packet or audio), or nil if the stream is healthy.
Err error
@@ -112,8 +116,15 @@ type Engine struct {
stop chan struct{}
frames atomic.Int64
errMu sync.RWMutex
lastErr error
// bitrate tracking
bitMu sync.Mutex
bitLast time.Time
bitBytes int64
bitrate int64
}
// setErr records the most recent runtime error. Pass nil to clear it.
@@ -254,15 +265,48 @@ func (e *Engine) Status() Status {
e.errMu.RLock()
err := e.lastErr
e.errMu.RUnlock()
return Status{
Running: e.stop != nil,
Frames: e.frames.Load(),
Dropped: e.sender.Dropped(),
Conns: e.sender.NumConns(),
Bitrate: e.measureBitrate(),
Err: err,
}
}
// bitrateWindow is the sliding window over which bitrate is averaged.
const bitrateWindow = 2 * time.Second
// measureBitrate computes the current stream bitrate (bits/sec) over a
// sliding window. It is called from Status.
func (e *Engine) measureBitrate() int64 {
e.bitMu.Lock()
defer e.bitMu.Unlock()
now := time.Now()
bytes := e.sender.BytesSent()
if e.bitLast.IsZero() {
e.bitLast = now
e.bitBytes = bytes
return 0
}
elapsed := now.Sub(e.bitLast)
if elapsed < bitrateWindow {
return e.bitrate
}
// Bytes accumulated since the previous sample.
delta := bytes - e.bitBytes
e.bitrate = int64(float64(delta*8) / elapsed.Seconds())
e.bitLast = now
e.bitBytes = bytes
return e.bitrate
}
// audioLoop reads raw PCM and emits WAVE packets. start is the shared
// reference clock used by the video loop so audio and video timestamps stay
// aligned on the receiver.
@@ -375,10 +419,11 @@ func (e *Engine) statsLoop() {
select {
case <-tick.C:
st := e.Status()
rate := formatBitrate(st.Bitrate)
if st.Dropped > 0 {
log.Printf("flinger: %d frames, %d dropped, %d conns", st.Frames, st.Dropped, st.Conns)
log.Printf("flinger: %d frames, %d dropped, %d conns, %s", st.Frames, st.Dropped, st.Conns, rate)
} else {
log.Printf("flinger: %d frames, %d conns", st.Frames, st.Conns)
log.Printf("flinger: %d frames, %d conns, %s", st.Frames, st.Conns, rate)
}
case <-e.stop:
return
@@ -386,6 +431,18 @@ func (e *Engine) statsLoop() {
}
}
// formatBitrate renders a bits/sec value in a human-readable form.
func formatBitrate(bps int64) string {
switch {
case bps >= 1_000_000:
return fmt.Sprintf("%.1f Mbps", float64(bps)/1_000_000)
case bps >= 1_000:
return fmt.Sprintf("%.0f kbps", float64(bps)/1_000)
default:
return fmt.Sprintf("%d bps", bps)
}
}
// frameSource abstracts the frame source: real capture or the test pattern.
type frameSource interface {
Next() (*capture.VideoFrame, error)
internal/flinger/flinger_test.go
+57
View File
@@ -129,6 +129,63 @@ func TestValidate(t *testing.T) {
}
}
// TestBitrateMeasurement verifies the engine reports a non-zero bitrate once
// it has been streaming for a bit.
func TestBitrateMeasurement(t *testing.T) {
cfg := DefaultConfig()
cfg.Source = "pattern"
cfg.Port = 19759
eng, err := New(cfg)
if err != nil {
t.Fatalf("New: %v", err)
}
eng.Start()
defer eng.Stop()
// Connect a receiver so packets actually flow, and wait for the bitrate
// window to produce a measurement.
conn, err := net.Dial("tcp", "127.0.0.1:"+itoa(eng.sender.Port()))
if err != nil {
t.Fatalf("dial: %v", err)
}
defer func() { _ = conn.Close() }()
go func() {
buf := make([]byte, 64*1024)
for {
if _, err := conn.Read(buf); err != nil {
return
}
}
}()
deadline := time.Now().Add(4 * time.Second)
for time.Now().Before(deadline) {
if eng.Status().Bitrate > 0 {
return
}
time.Sleep(200 * time.Millisecond)
}
t.Error("bitrate stayed 0 after 4s of streaming")
}
// TestFormatBitrate checks the human-readable bitrate formatting.
func TestFormatBitrate(t *testing.T) {
cases := []struct {
bps int64
want string
}{
{500, "500 bps"},
{5_000, "5 kbps"},
{5_000_000, "5.0 Mbps"},
}
for _, c := range cases {
if got := formatBitrate(c.bps); got != c.want {
t.Errorf("formatBitrate(%d) = %q, want %q", c.bps, got, c.want)
}
}
}
func itoa(v int) string {
if v == 0 {
return "0"
internal/gui/gui.go
+45
View File
@@ -61,6 +61,7 @@ type App struct {
portEnt *widget.Entry
qualitySel *widget.Select
fpsSel *widget.Select
presetSel *widget.Select
nameEnt *widget.Entry
audioChk *widget.Check
announceChk *widget.Check
@@ -147,6 +148,12 @@ func (g *App) buildUI() {
g.fpsSel = widget.NewSelect([]string{"15", "30", "60"}, g.applyLiveSettings)
g.fpsSel.SetSelected(itoa(g.cfg.FPS))
// Preset: one-click quality/fps combos. Choosing one sets the Quality and
// Frame rate selectors and applies them (live if running). Created after
// the quality/fps selects so applyPreset's references are valid.
g.presetSel = widget.NewSelect([]string{"Low", "Medium", "High", "Ultra"}, g.applyPreset)
g.presetSel.SetSelected("High")
// Audio.
g.audioChk = widget.NewCheck("Capture system audio", nil)
g.audioChk.SetChecked(g.cfg.Audio)
@@ -173,6 +180,7 @@ func (g *App) buildUI() {
{Text: "Port", Widget: g.portEnt},
{Text: "Source", Widget: g.srcSel},
{Text: "Monitor", Widget: g.monSel},
{Text: "Preset", Widget: g.presetSel},
{Text: "Quality", Widget: g.qualitySel},
{Text: "Frame rate", Widget: g.fpsSel},
{Text: "", Widget: g.audioChk},
@@ -241,6 +249,25 @@ func (g *App) selectedMonitorIndex() int {
return g.cfg.StreamIndex
}
// applyPreset applies a named quality/fps preset to the Quality and Frame
// rate selectors, then pushes it live if the engine is running.
func (g *App) applyPreset(string) {
var q, f int
switch g.presetSel.Selected {
case "Low":
q, f = 50, 15
case "Medium":
q, f = 70, 30
case "Ultra":
q, f = 100, 60
default: // High
q, f = 85, 30
}
g.qualitySel.SetSelected(itoa(q))
g.fpsSel.SetSelected(itoa(f))
g.applyLiveSettings("")
}
// applyLiveSettings pushes the current form values (quality, fps, name,
// audio, announce) into a running engine via SetConfig so changes take
// effect without restarting the stream. When the engine is not running it is
@@ -354,6 +381,9 @@ func (g *App) watchStats() {
g.statusLab.Importance = widget.SuccessImportance
}
tip := "TeleportFling · " + frames + " frames, " + dropped + " dropped"
if st.Bitrate > 0 {
tip += " · " + formatBitrate(st.Bitrate)
}
if st.Err != nil {
tip += " · error"
}
@@ -372,12 +402,27 @@ func formatStatus(st flinger.Status) string {
if st.Dropped > 0 {
base += " · " + itoa(int(st.Dropped)) + " dropped"
}
if st.Bitrate > 0 {
base += " · " + formatBitrate(st.Bitrate)
}
if st.Err != nil {
base += "\nError: " + st.Err.Error()
}
return base
}
// formatBitrate renders a bits/sec value in a human-readable form.
func formatBitrate(bps int64) string {
switch {
case bps >= 1_000_000:
return fmt.Sprintf("%.1f Mbps", float64(bps)/1_000_000)
case bps >= 1_000:
return fmt.Sprintf("%.0f kbps", float64(bps)/1_000)
default:
return fmt.Sprintf("%d bps", bps)
}
}
// stop halts the engine and returns the UI to the stopped state.
func (g *App) stop() {
if g.statsDone != nil {
internal/output/sender.go
+10
View File
@@ -37,6 +37,7 @@ type Sender struct {
port int
dropped atomic.Int64
bytes atomic.Int64
}
// New creates an unconnected Sender.
@@ -95,6 +96,10 @@ func (s *Sender) Send(b []byte) {
s.mu.Lock()
defer s.mu.Unlock()
// Count the packet once as produced bandwidth (independent of how many
// receivers are attached).
s.bytes.Add(int64(len(b)))
for c, ch := range s.conns {
switch {
case len(ch) > dropAt:
@@ -125,6 +130,11 @@ func (s *Sender) Dropped() int64 {
return s.dropped.Load()
}
// BytesSent returns the total number of payload bytes handed to Send.
func (s *Sender) BytesSent() int64 {
return s.bytes.Load()
}
// Close shuts down the listener and waits for all writer goroutines to
// drain. After Close returns the Sender must not be reused.
func (s *Sender) Close() {