petere
0cb96b5792
Capture the Wayland desktop via xdg-desktop-portal + PipeWire using go2tv.app/screencast (MIT), and stream it to OBS: - internal/capture: Capture/FrameSource/AudioSource interfaces and the PipeWire backend (BGRA frames at monitor resolution, S16 48 kHz stereo system audio) - protocol: EncodeBGRA fast path producing 4:2:0 YCbCr JPEGs - cmd: --source screen|pattern, --audio, --stream-index flags; real capture feeds the existing sender - share one wall-clock reference between the audio and video loops so OBS receives aligned A/V timestamps (avoids multi-second latency) Verified end-to-end: real desktop at 30 fps renders in OBS with sub-second latency.
85 lines
2.3 KiB
Go
85 lines
2.3 KiB
Go
// Package capture provides the PipeWire backend for Wayland screen + audio
|
|
// capture.
|
|
//
|
|
// This uses go2tv.app/screencast (MIT) which implements the full
|
|
// xdg-desktop-portal ScreenCast negotiation and then receives frames over
|
|
// PipeWire. The portal session is responsible for the screen-share consent
|
|
// dialog presented by the compositor (Hyprland in our dev environment).
|
|
//
|
|
// Frames arrive as raw BGRA at the monitor's native resolution/refresh rate.
|
|
// Audio is signed 16-bit, 48 kHz, stereo interleaved PCM from the system's
|
|
// default output.
|
|
package capture
|
|
|
|
import (
|
|
"errors"
|
|
"io"
|
|
|
|
"go2tv.app/screencast/capture"
|
|
)
|
|
|
|
// PipeWire implements Capture on top of the screencast library.
|
|
type PipeWire struct {
|
|
stream *capture.Stream
|
|
}
|
|
|
|
// OpenPipeWire opens a PipeWire capture session. streamIndex selects which
|
|
// monitor to capture when multiple are present. Triggering the portal
|
|
// consent dialog is expected; the compositor decides whether to show it.
|
|
func OpenPipeWire(streamIndex int, audio bool) (*PipeWire, error) {
|
|
s, err := capture.Open(&capture.Options{
|
|
StreamIndex: streamIndex,
|
|
IncludeAudio: audio,
|
|
})
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &PipeWire{stream: s}, nil
|
|
}
|
|
|
|
// Video returns the BGRA frame source.
|
|
func (p *PipeWire) Video() FrameSource {
|
|
return &pipewireVideo{stream: p.stream}
|
|
}
|
|
|
|
// Audio returns the system audio source, or nil if unavailable.
|
|
func (p *PipeWire) Audio() AudioSource {
|
|
if p.stream.Audio == nil {
|
|
return nil
|
|
}
|
|
return p.stream.Audio
|
|
}
|
|
|
|
// Close releases the capture session and portal resources.
|
|
func (p *PipeWire) Close() error {
|
|
return p.stream.Close()
|
|
}
|
|
|
|
// pipewireVideo adapts the screencast io.ReadCloser into FrameSource.
|
|
type pipewireVideo struct {
|
|
stream *capture.Stream
|
|
frame *VideoFrame
|
|
}
|
|
|
|
// NextFrame blocks until the next full frame is delivered. The screencast
|
|
// library writes one complete BGRA frame per Read, so we assemble it with
|
|
// ReadFull and reuse the underlying buffer across calls.
|
|
func (v *pipewireVideo) NextFrame() (*VideoFrame, error) {
|
|
w, h := int(v.stream.Width), int(v.stream.Height)
|
|
if v.frame == nil {
|
|
v.frame = &VideoFrame{
|
|
Pix: make([]byte, w*h*4),
|
|
Width: w,
|
|
Height: h,
|
|
Stride: w * 4,
|
|
}
|
|
}
|
|
if _, err := io.ReadFull(v.stream, v.frame.Pix); err != nil {
|
|
if errors.Is(err, io.EOF) {
|
|
return nil, io.ErrClosedPipe
|
|
}
|
|
return nil, err
|
|
}
|
|
return v.frame, nil
|
|
}
|