Free, open-source screen sharing for private live streams with friends. Watch together in a browser or self-host Piik. 免费开源的私密屏幕共享,支持游戏直播、一起看电影与自部署。
package nativehost
import (
"context"
"encoding/binary"
"encoding/json"
"io"
"os"
"path/filepath"
"strconv"
"strings"
"sync/atomic"
"testing"
"time"
"github.com/TNTcraftHIM/Piik/internal/app/nativeaudio"
"github.com/TNTcraftHIM/Piik/internal/app/nativecapture"
"github.com/livekit/livekit-server/pkg/sfu"
"github.com/pion/webrtc/v4"
)
func writeCaptureFixtureFrame(frame nativecapture.Frame) {
var header [32]byte
copy(header[:], "SMED")
header[4], header[5], header[7] = 2, byte(frame.Kind), byte(frame.Layer)
if frame.KeyFrame {
header[6] = 1
}
binary.BigEndian.PutUint64(header[8:16], uint64(frame.Timestamp/(100*time.Nanosecond)))
binary.BigEndian.PutUint64(header[16:24], uint64(frame.Duration/(100*time.Nanosecond)))
binary.BigEndian.PutUint16(header[24:26], uint16(frame.Width))
binary.BigEndian.PutUint16(header[26:28], uint16(frame.Height))
binary.BigEndian.PutUint32(header[28:32], uint32(len(frame.Data)))
if _, err := os.Stdout.Write(append(header[:], frame.Data...)); err != nil {
os.Exit(1)
}
}
func audioRecoveryProfile() nativecapture.VideoProfile {
return nativecapture.VideoProfile{Width: 1280, Height: 720, Framerate: 30,
Bitrate: 2_000_000, Preference: "balanced"}
}
// The same stable test executable supplies framed video and PCM, without a
// capture device. Closing stdin ends either child independently.
func runAudioRecoveryCapture() {
stopped := make(chan struct{})
go func() { _, _ = io.Copy(io.Discard, os.Stdin); close(stopped) }()
write := writeCaptureFixtureFrame
microphone := len(os.Args) > 1 && os.Args[1] == "--capture-microphone"
if microphone {
if len(os.Args) == 4 && os.Args[2] == "--device" && os.Args[3] == "missing" {
os.Exit(2)
}
if marker := os.Getenv("PIIK_MICROPHONE_WAIT"); marker != "" {
_ = os.WriteFile(marker, nil, 0600)
<-stopped
return
}
}
audio := microphone || (len(os.Args) > 1 && os.Args[1] == "--capture-audio")
var deviceFailure string
if marker := os.Getenv("PIIK_VIDEO_DEVICE_FAILURE"); !audio && marker != "" {
// Only the first video process fails; a replacement uses the same fixture.
if owner, err := os.OpenFile(marker+".owner", os.O_CREATE|os.O_EXCL|os.O_WRONLY, 0600); err == nil {
_ = owner.Close()
deviceFailure = marker
}
}
startupGate := os.Getenv("PIIK_VIDEO_START_GATE")
if audio && !microphone && startupGate != "" {
if _, err := os.Stat(startupGate + ".active"); err != nil {
_ = os.WriteFile(startupGate+".early-audio", nil, 0600)
os.Exit(2)
}
_ = os.WriteFile(startupGate+".audio", []byte(os.Args[3]+":"+os.Args[4]), 0600)
}
if !audio && os.Getenv("PIIK_VIDEO_FAIL") == "1" {
_, _ = io.WriteString(os.Stderr, "stage=mft-set-output-type\nhresult=0xc00d36b4\ndetail=private capture target\n")
os.Exit(2)
}
if !microphone && audio && os.Args[2] == "exclude" {
if os.Getenv("PIIK_EXCLUSION_FAIL") == "1" {
os.Exit(2)
}
if marker := os.Getenv("PIIK_EXCLUSION_STARTED"); marker != "" {
_ = os.WriteFile(marker, []byte(os.Args[3]+":"+os.Args[4]), 0600)
}
}
if audio && os.Getenv("PIIK_AUDIO_STARTUP") == "no-ready" {
<-stopped
return
}
profile := audioRecoveryProfile()
if !audio {
for index := 1; index+1 < len(os.Args); index++ {
value, _ := strconv.ParseUint(os.Args[index+1], 10, 32)
switch os.Args[index] {
case "--width":
profile.Width = uint32(value)
case "--height":
profile.Height = uint32(value)
case "--fps":
profile.Framerate = uint32(value)
case "--bitrate":
profile.Bitrate = uint32(value)
}
}
}
period := time.Second / time.Duration(profile.Framerate)
status := []byte(`{"state":"active","audio":true}`)
if audio {
period = 20 * time.Millisecond
} else {
outputs := nativecapture.ScreenShareOutputs(profile)
outputs = append(outputs, outputs[0])
status, _ = json.Marshal(CaptureState{State: "active", Codec: "vp8",
Width: profile.Width, Height: profile.Height, FPS: profile.Framerate, Outputs: outputs})
}
marker := os.Getenv("PIIK_AUDIO_WAIT_FOR_VIDEO")
if audio && marker != "" {
ticker := time.NewTicker(5 * time.Millisecond)
defer ticker.Stop()
for {
if _, err := os.Stat(marker); err == nil {
break
}
select {
case <-stopped:
return
case <-ticker.C:
}
}
}
if !audio && startupGate != "" && os.Args[3] == "1" && profile.Width == audioRecoveryProfile().Width {
var starting CaptureState
_ = json.Unmarshal(status, &starting)
starting.State = "starting"
index := uint32(0)
starting.AdapterIndex = &index
starting.AdapterName, starting.AdapterIdentity = "Fixture", "fixture"
starting.EncoderName, starting.EncoderIdentity = "Fixture VP8", "fixture-vp8"
initial, _ := json.Marshal(starting)
write(nativecapture.Frame{Kind: nativecapture.FrameStatus, Data: initial})
ticker := time.NewTicker(5 * time.Millisecond)
defer ticker.Stop()
for {
if _, err := os.Stat(startupGate + ".fail"); err == nil {
_, _ = io.WriteString(os.Stderr, "stage=fixture-video-initialization\n")
os.Exit(2)
}
if _, err := os.Stat(startupGate + ".release"); err == nil {
break
}
select {
case <-stopped:
return
case <-ticker.C:
}
}
}
if !audio && startupGate != "" {
_ = os.WriteFile(startupGate+".active", nil, 0600)
}
write(nativecapture.Frame{Kind: nativecapture.FrameStatus, Data: status})
if !audio && marker != "" {
// Exceed the OS pipe buffer before allowing audio initialization to finish.
data := make([]byte, 256*1024)
copy(data, sfu.VP8KeyFrame8x8)
write(nativecapture.Frame{Kind: nativecapture.FrameBegin, Duration: period})
write(nativecapture.Frame{Kind: nativecapture.FrameVP8, Layer: 1, Width: 8, Height: 8,
Duration: period, KeyFrame: true, Data: data})
_ = os.WriteFile(marker, nil, 0600)
}
if audio && os.Getenv("PIIK_AUDIO_STARTUP") == "silent" {
<-stopped
return
}
ticker := time.NewTicker(period)
defer ticker.Stop()
for pts := period; ; pts += period {
select {
case <-stopped:
return
case <-ticker.C:
}
if audio {
write(nativecapture.Frame{Kind: nativecapture.FramePCM, Timestamp: pts,
Duration: period, Data: make([]byte, nativeaudio.FrameBytes)})
continue
}
if deviceFailure != "" {
if _, err := os.Stat(deviceFailure); err == nil {
if os.Getenv("PIIK_VIDEO_DEVICE_CONTROL") == "1" {
_ = os.Stdin.Close()
write(nativecapture.Frame{Kind: nativecapture.FrameBegin, Timestamp: pts, Duration: period})
time.Sleep(50 * time.Millisecond)
}
_, _ = io.WriteString(os.Stderr, "stage=capture-device-lost\nhresult=0x887a0005\n")
os.Exit(2)
}
}
write(nativecapture.Frame{Kind: nativecapture.FrameBegin, Timestamp: pts, Duration: period})
for layer := range 2 {
write(nativecapture.Frame{Kind: nativecapture.FrameVP8, Layer: layer, Width: 8, Height: 8,
Timestamp: pts, Duration: period, KeyFrame: true, Data: sfu.VP8KeyFrame8x8})
}
}
}
func TestMixedSourceAudioWaitsForActiveVideoWithoutBlockingStart(t *testing.T) {
t.Setenv("PIIK_NATIVEHOST_PIPE_FIXTURE", "audio-recovery")
gate := filepath.Join(t.TempDir(), "video")
t.Setenv("PIIK_VIDEO_START_GATE", gate)
executable, err := os.Executable()
if err != nil {
t.Fatal(err)
}
ctx, cancel := context.WithTimeout(t.Context(), 5*time.Second)
defer cancel()
events := make(chan Event, 32)
video := nativecapture.VideoOptions{Codec: "vp8", Profile: audioRecoveryProfile(),
Target: nativecapture.CaptureTarget{Kind: "window", SourceID: "1", PID: 42, CreationTime: "1", Title: "Fixture"}}
session, err := Start(ctx, Options{ShareID: "staged-audio", CaptureProcess: executable,
Video: video, Profile: QualityProfile{Video: video.Profile, AudioBitrate: 64_000},
AudioEnabled: true, MicrophoneMixing: true, EdgeCapacity: 1, BindAddress: "127.0.0.1:0",
Events: func(_ context.Context, event Event) { events <- event }})
if err != nil {
t.Fatal(err)
}
defer session.Close()
if _, err := os.Stat(gate + ".early-audio"); err == nil {
t.Fatal("source audio initialized before video became active")
}
if !session.HasAudio() || session.SourceAudio() == nil || *session.SourceAudio() {
t.Fatal("pending source audio changed the mixed output shape or claimed readiness")
}
if err := os.WriteFile(gate+".release", nil, 0600); err != nil {
t.Fatal(err)
}
for {
select {
case event := <-events:
if event.Type == "audio-state" && event.SourceAudio {
if _, err := os.Stat(gate + ".audio"); err != nil {
t.Fatal("source audio did not initialize after active video")
}
return
}
case <-ctx.Done():
t.Fatal("active video did not resume pending source audio")
}
}
}
func TestPendingSourceAudioRetiresWithVideoOrLaterSelection(t *testing.T) {
t.Setenv("PIIK_NATIVEHOST_PIPE_FIXTURE", "audio-recovery")
executable, err := os.Executable()
if err != nil {
t.Fatal(err)
}
for _, finish := range []string{"stop", "video-failure", "audio-off", "source-replacement", "audio-profile", "video-profile", "audio-on"} {
t.Run(finish, func(t *testing.T) {
gate := filepath.Join(t.TempDir(), "video")
t.Setenv("PIIK_VIDEO_START_GATE", gate)
ctx, cancel := context.WithTimeout(t.Context(), 5*time.Second)
defer cancel()
events := make(chan Event, 32)
video := nativecapture.VideoOptions{Codec: "vp8", Profile: audioRecoveryProfile(),
Target: nativecapture.CaptureTarget{Kind: "display", SourceID: "1", Title: "Fixture"}}
session, err := Start(ctx, Options{ShareID: "pending-audio", CaptureProcess: executable,
Video: video, Profile: QualityProfile{Video: video.Profile, AudioBitrate: 64_000},
AudioEnabled: true, MicrophoneMixing: true, EdgeCapacity: 1, BindAddress: "127.0.0.1:0",
Events: func(_ context.Context, event Event) { events <- event }})
if err != nil {
t.Fatal(err)
}
defer session.Close()
completed := make(chan error, 1)
switch finish {
case "stop":
go func() { completed <- session.Close() }()
case "video-failure":
if err := os.WriteFile(gate+".fail", nil, 0600); err != nil {
t.Fatal(err)
}
go func() { err := <-session.Done(); completed <- err }()
case "audio-off", "source-replacement":
next := video
if finish == "source-replacement" {
next.Target = nativecapture.CaptureTarget{Kind: "window", SourceID: "2", PID: 99, CreationTime: "2", Title: "Next fixture"}
}
go func() { completed <- session.ReplaceSource(next, false, nil) }()
case "audio-profile":
profile := QualityProfile{Video: video.Profile, AudioBitrate: 32_000}
go func() { completed <- session.UpdateProfile(profile) }()
case "video-profile":
profile := QualityProfile{Video: video.Profile, AudioBitrate: 64_000}
profile.Video.Width, profile.Video.Height = 640, 360
go func() { completed <- session.UpdateProfile(profile) }()
case "audio-on":
go func() { completed <- session.ReplaceSource(video, true, nil) }()
}
select {
case err := <-completed:
if (err != nil) != (finish == "video-failure" || finish == "audio-on") {
t.Fatalf("unexpected %s result: %v", finish, err)
}
case <-ctx.Done():
t.Fatal("pending audio blocked", finish)
}
if _, err := os.Stat(gate + ".early-audio"); err == nil {
t.Fatal("source audio initialized before active video")
}
if finish == "audio-off" || finish == "source-replacement" {
if session.SourceAudio() == nil || *session.SourceAudio() || session.currentAudioStream() != nil {
t.Fatal("late initial audio overwrote the newer source-audio selection")
}
} else if finish != "video-profile" {
if _, err := os.Stat(gate + ".audio"); err == nil {
t.Fatal("retired video still started source audio")
}
}
if finish == "video-profile" {
for {
select {
case event := <-events:
if event.Type == "audio-state" && event.SourceAudio {
return
}
case <-ctx.Done():
t.Fatal("quality replacement lost pending source audio")
}
}
}
})
}
}
func TestFixedSourceAudioWaitsForActiveVideoAndCanCancel(t *testing.T) {
t.Setenv("PIIK_NATIVEHOST_PIPE_FIXTURE", "audio-recovery")
executable, err := os.Executable()
if err != nil {
t.Fatal(err)
}
for _, cancelStartup := range []bool{false, true} {
t.Run(map[bool]string{false: "active", true: "cancelled"}[cancelStartup], func(t *testing.T) {
gate := filepath.Join(t.TempDir(), "video")
t.Setenv("PIIK_VIDEO_START_GATE", gate)
ctx, cancel := context.WithTimeout(t.Context(), 5*time.Second)
defer cancel()
events := make(chan Event, 16)
type result struct {
session *Session
err error
}
started := make(chan result, 1)
go func() {
video := nativecapture.VideoOptions{Codec: "vp8", Profile: audioRecoveryProfile(),
Target: nativecapture.CaptureTarget{Kind: "display", SourceID: "1", Title: "Fixture"}}
session, err := Start(ctx, Options{ShareID: "fixed-audio", CaptureProcess: executable,
Video: video, Profile: QualityProfile{Video: video.Profile, AudioBitrate: 64_000},
AudioEnabled: true, EdgeCapacity: 1, BindAddress: "127.0.0.1:0",
Events: func(_ context.Context, event Event) { events <- event }})
started <- result{session, err}
}()
select {
case event := <-events:
if event.Type != "capture-state" || event.State != "starting" {
t.Fatal("missing video startup progress", event)
}
case <-ctx.Done():
t.Fatal("video startup progress did not arrive")
}
select {
case result := <-started:
if result.session != nil {
_ = result.session.Close()
}
t.Fatal("fixed audio shape committed before video became active", result.err)
default:
}
if cancelStartup {
cancel()
} else if err := os.WriteFile(gate+".release", nil, 0600); err != nil {
t.Fatal(err)
}
select {
case result := <-started:
if result.session != nil {
defer result.session.Close()
}
if cancelStartup {
if result.err == nil || result.session != nil {
t.Fatal("cancelled startup admitted a share")
}
} else if result.err != nil || result.session == nil || !result.session.HasAudio() {
t.Fatal("fixed source audio was not admitted", result.err)
}
case <-time.After(2 * time.Second):
t.Fatal("source audio did not finish startup or cancellation")
}
if _, err := os.Stat(gate + ".early-audio"); err == nil {
t.Fatal("source audio initialized before active video")
}
})
}
}
func TestCaptureStartupReturnsNativeFailureCodesWithoutPrivateDetail(t *testing.T) {
t.Setenv("PIIK_NATIVEHOST_PIPE_FIXTURE", "audio-recovery")
t.Setenv("PIIK_VIDEO_FAIL", "1")
executable, err := os.Executable()
if err != nil {
t.Fatal(err)
}
video := nativecapture.VideoOptions{Codec: "h264", Profile: audioRecoveryProfile(),
Target: nativecapture.CaptureTarget{Kind: "display", SourceID: "1", Title: "Fixture"}}
session, err := Start(t.Context(), Options{ShareID: "startup-failure", CaptureProcess: executable,
Video: video, Profile: QualityProfile{Video: video.Profile, AudioBitrate: 64_000}, EdgeCapacity: 1,
BindAddress: "127.0.0.1:0"})
if session != nil {
_ = session.Close()
t.Fatal("failed capture started a share")
}
if err == nil || !strings.Contains(err.Error(), "mft-set-output-type") || !strings.Contains(err.Error(), "0xc00d36b4") {
t.Fatalf("startup lost native machine codes: %v", err)
}
if strings.Contains(err.Error(), "private") {
t.Fatalf("startup exposed private helper detail: %v", err)
}
}
func TestAudioStartupDoesNotRequireSamplesOrStopVideo(t *testing.T) {
t.Setenv("PIIK_NATIVEHOST_PIPE_FIXTURE", "audio-recovery")
executable, err := os.Executable()
if err != nil {
t.Fatal(err)
}
for _, mode := range []string{"silent", "no-ready", "drain-video"} {
t.Run(mode, func(t *testing.T) {
t.Setenv("PIIK_AUDIO_STARTUP", mode)
if mode == "drain-video" {
t.Setenv("PIIK_AUDIO_WAIT_FOR_VIDEO", filepath.Join(t.TempDir(), "video-drained"))
}
ctx, cancel := context.WithTimeout(t.Context(), 10*time.Second)
defer cancel()
video := nativecapture.VideoOptions{Codec: "vp8", Profile: audioRecoveryProfile(),
Target: nativecapture.CaptureTarget{Kind: "display", SourceID: "1", Title: "Silent fixture"}}
session, err := Start(ctx, Options{ShareID: "audio-startup", CaptureProcess: executable,
Video: video, Profile: QualityProfile{Video: video.Profile, AudioBitrate: 64_000},
AudioEnabled: true, EdgeCapacity: 1, BindAddress: "127.0.0.1:0"})
if err != nil {
t.Fatal(err)
}
defer session.Close()
if session.Codec() != "vp8" || session.HasAudio() != (mode != "no-ready") {
t.Fatalf("codec=%s audio=%v for %s", session.Codec(), session.HasAudio(), mode)
}
cancel()
select {
case err := <-session.Done():
if err != nil {
t.Fatal(err)
}
case <-time.After(3 * time.Second):
t.Fatal("Stop did not release the silent audio and video readers")
}
})
}
}
func TestAudioEOFWaitsForExplicitSourceReplacement(t *testing.T) {
t.Setenv("PIIK_NATIVEHOST_PIPE_FIXTURE", "audio-recovery")
check := func(err error) {
t.Helper()
if err != nil {
t.Fatal(err)
}
}
ctx, cancel := context.WithTimeout(t.Context(), 15*time.Second)
defer cancel()
executable, err := os.Executable()
check(err)
events := make(chan Event, 64)
options := nativecapture.VideoOptions{Codec: "vp8", Profile: audioRecoveryProfile(),
Target: nativecapture.CaptureTarget{Kind: "display", SourceID: "1", Title: "Audio fixture"}}
session, err := Start(ctx, Options{ShareID: "audio-recovery", CaptureProcess: executable,
Video: options, Profile: QualityProfile{Video: options.Profile, AudioBitrate: 64_000},
AudioEnabled: true, EdgeCapacity: 1, BindAddress: "127.0.0.1:0", Events: func(_ context.Context, event Event) {
select {
case events <- event:
case <-ctx.Done():
}
}})
check(err)
defer session.Close()
if !session.HasAudio() {
t.Fatal("fixture did not start audio")
}
settings := webrtc.SettingEngine{}
settings.SetIncludeLoopbackCandidate(true)
settings.SetNetworkTypes([]webrtc.NetworkType{webrtc.NetworkTypeUDP4})
receiver, err := webrtc.NewAPI(webrtc.WithSettingEngine(settings)).NewPeerConnection(webrtc.Configuration{})
check(err)
defer receiver.Close()
var audioPackets, videoPackets atomic.Uint64
receiver.OnTrack(func(track *webrtc.TrackRemote, _ *webrtc.RTPReceiver) {
for {
packet, _, err := track.ReadRTP()
if err != nil {
return
}
if track.Codec().MimeType == webrtc.MimeTypeOpus && len(packet.Payload) > 0 {
audioPackets.Add(1)
} else if track.Kind() == webrtc.RTPCodecTypeVideo {
videoPackets.Add(1)
}
}
})
offer, err := session.PrepareLocalEdge("audio-edge", "local_offer_1", false)
check(err)
check(receiver.SetRemoteDescription(offer))
// A receive preference belongs to this answer, not the upstream offer.
for _, transceiver := range receiver.GetTransceivers() {
if transceiver.Kind() != webrtc.RTPCodecTypeAudio {
continue
}
for _, codec := range transceiver.Receiver().GetParameters().Codecs {
if codec.MimeType == webrtc.MimeTypeOpus {
codec.SDPFmtpLine = "stereo=1;maxaveragebitrate=510000"
check(transceiver.SetCodecPreferences([]webrtc.RTPCodecParameters{codec}))
break
}
}
}
go func() {
for {
select {
case event := <-events:
if event.Type == "edge-candidate" && event.Candidate != nil {
_ = receiver.AddICECandidate(*event.Candidate)
}
case <-ctx.Done():
return
}
}
}()
gathered := webrtc.GatheringCompletePromise(receiver)
answer, err := receiver.CreateAnswer(nil)
check(err)
check(receiver.SetLocalDescription(answer))
select {
case <-gathered:
case <-ctx.Done():
t.Fatal("receiver gathering timed out")
}
check(session.SetAnswer("audio-edge", *receiver.LocalDescription(), "local_offer_1"))
waitPackets := func(counter *atomic.Uint64, minimum uint64, label string) {
t.Helper()
deadline := time.Now().Add(3 * time.Second)
for counter.Load() < minimum {
if time.Now().After(deadline) {
t.Fatalf("%s: received %d, wanted %d", label, counter.Load(), minimum)
}
time.Sleep(10 * time.Millisecond)
}
}
waitPackets(&audioPackets, 3, "initial Opus")
waitPackets(&videoPackets, 3, "initial video")
previousAudio, previousVideo := session.currentAudioStream(), session.currentStream()
edge, audioSource := session.edge("audio-edge"), session.audioSource
check(previousAudio.Close())
waitPackets(&videoPackets, videoPackets.Load()+10, "video after audio EOF")
before := audioPackets.Load()
options.Target.SourceID = "2"
check(session.ReplaceSource(options, true, nil))
if session.currentStream() == previousVideo || session.currentAudioStream() == previousAudio ||
session.edge("audio-edge") != edge || session.audioSource != audioSource {
t.Fatal("explicit replacement did not preserve the media owners")
}
waitPackets(&audioPackets, before+3, "Opus after explicit source replacement")
check(session.currentAudioStream().Close())
waitPackets(&videoPackets, videoPackets.Load()+5, "video after second audio EOF")
closed := make(chan error, 1)
go func() { closed <- session.Close() }()
select {
case err = <-closed:
check(err)
case <-time.After(3 * time.Second):
t.Fatal("Stop did not unblock the audio replacement wait")
}
}