Skip to content

armgit / Piik

Public Imported from GitHub
0

Free, open-source screen sharing for private live streams with friends. Watch together in a browser or self-host Piik. 免费开源的私密屏幕共享,支持游戏直播、一起看电影与自部署。

4.9 KB
Raw Blame
package mediaedge

import (
	"bytes"
	"encoding/binary"
	"io"
	"math"
	"testing"
	"time"

	"github.com/TNTcraftHIM/Piik/internal/app/nativeaudio"
	"github.com/pion/interceptor"
	"github.com/pion/rtp"
	"github.com/pion/webrtc/v4"
	gopus "github.com/thesyncim/gopus"
)

// Exercise Pion's actual shared-track fanout without sockets or retirement races.
type audioBinding struct {
	id      string
	err     error
	packets int
	payload []byte
}

func (binding *audioBinding) CodecParameters() []webrtc.RTPCodecParameters {
	return []webrtc.RTPCodecParameters{{RTPCodecCapability: opusCapability, PayloadType: 111}}
}
func (*audioBinding) HeaderExtensions() []webrtc.RTPHeaderExtensionParameter { return nil }
func (*audioBinding) SSRC() webrtc.SSRC                                      { return 1 }
func (*audioBinding) SSRCRetransmission() webrtc.SSRC                        { return 0 }
func (*audioBinding) SSRCForwardErrorCorrection() webrtc.SSRC                { return 0 }
func (binding *audioBinding) WriteStream() webrtc.TrackLocalWriter           { return binding }
func (binding *audioBinding) ID() string                                     { return binding.id }
func (*audioBinding) RTCPReader() interceptor.RTCPReader                     { return nil }
func (binding *audioBinding) WriteRTP(_ *rtp.Header, payload []byte) (int, error) {
	binding.packets++
	binding.payload = append(binding.payload[:0], payload...)
	return len(payload), binding.err
}

func TestSourceVolumeReachesEveryBindingBeforeOpusEncoding(t *testing.T) {
	engine, err := NewEngine(EngineOptions{BindAddress: "127.0.0.1:0", IncludeLoopback: true})
	if err != nil {
		t.Fatal(err)
	}
	defer engine.Close()
	source, err := engine.NewAudioSource(2, 128_000)
	if err != nil {
		t.Fatal(err)
	}
	defer source.Close()
	first, second := &audioBinding{id: "first"}, &audioBinding{id: "second"}
	for _, binding := range []*audioBinding{first, second} {
		if _, err := source.samples.Bind(binding); err != nil {
			t.Fatal(err)
		}
	}
	decoder, err := gopus.NewDecoder(gopus.DefaultDecoderConfig(nativeaudio.SampleRate, nativeaudio.Channels))
	if err != nil {
		t.Fatal(err)
	}
	pcm := make([]byte, nativeaudio.FrameBytes)
	decoded := make([]int16, nativeaudio.FrameSamples*nativeaudio.Channels)
	for sample := range nativeaudio.FrameSamples {
		for channel, frequency := range []float64{500, 1500} {
			value := int16(float64(2000*(channel+1)) * math.Sin(2*math.Pi*frequency*float64(sample)/nativeaudio.SampleRate))
			binary.LittleEndian.PutUint16(pcm[(sample*2+channel)*2:], uint16(value))
		}
	}
	original := bytes.Clone(pcm)
	var baseline [2]float64
	for _, gain := range []float64{1, 2, 0, 1} {
		if err := source.SetVolume(gain); err != nil {
			t.Fatal(err)
		}
		var energy [2]float64
		for block := range 20 {
			if err := source.WritePCM(pcm, 20*time.Millisecond); err != nil {
				t.Fatal(err)
			}
			if !bytes.Equal(first.payload, second.payload) {
				t.Fatal("gain split shared output")
			}
			count, err := decoder.DecodeInt16(first.payload, decoded)
			if err != nil || count != nativeaudio.FrameSamples {
				t.Fatalf("decode: %d, %v", count, err)
			}
			if block < 5 {
				continue
			} // Exclude the gain ramp and codec settling.
			for sample, value := range decoded {
				energy[sample%2] += float64(value) * float64(value)
			}
		}
		if !bytes.Equal(pcm, original) {
			t.Fatal("gain modified capture-owned PCM")
		}
		for channel := range 2 {
			level := math.Sqrt(energy[channel])
			if baseline[channel] == 0 {
				baseline[channel] = level
			}
			ratio := level / baseline[channel]
			if math.Abs(ratio-gain) > .1 {
				t.Fatalf("channel %d gain %g decoded as %.3f", channel, gain, ratio)
			}
		}
	}
}
func (binding *audioBinding) Write(payload []byte) (int, error) {
	return binding.WriteRTP(nil, payload)
}

func TestAudioSourceIsolatesBindingWriteFailure(t *testing.T) {
	engine, err := NewEngine(EngineOptions{BindAddress: "127.0.0.1:0", IncludeLoopback: true})
	if err != nil {
		t.Fatal(err)
	}
	defer engine.Close()
	source, err := engine.NewAudioSource(2, 128_000)
	if err != nil {
		t.Fatal(err)
	}
	defer source.Close()
	failed := &audioBinding{id: "retiring", err: io.ErrClosedPipe}
	healthy := &audioBinding{id: "healthy"}
	for _, binding := range []*audioBinding{failed, healthy} {
		if _, err = source.samples.Bind(binding); err != nil {
			t.Fatal(err)
		}
	}
	pcm := make([]byte, nativeaudio.FrameBytes)
	for expected := 1; expected <= 2; expected++ {
		if err = source.WritePCM(pcm, 20*time.Millisecond); err != nil {
			t.Fatalf("one failed binding stopped the shared source: %v", err)
		}
		if healthy.packets != expected || failed.packets != expected {
			t.Fatalf("fanout stopped: healthy=%d failed=%d", healthy.packets, failed.packets)
		}
	}
	if err = source.WritePCM(pcm[:1], 20*time.Millisecond); err == nil {
		t.Fatal("invalid PCM was accepted")
	}
	if err = source.Close(); err != nil {
		t.Fatal(err)
	}
	if err = source.WritePCM(pcm, 20*time.Millisecond); err == nil {
		t.Fatal("closed audio source was accepted")
	}
}