mirror of
https://github.com/AlexxIT/go2rtc.git
synced 2026-04-22 23:57:20 +08:00
Sergey Krashevich
2b7682cdb3
- replace traditional for loop with range-based for loop for clarity
refactor(ffmpeg): simplify cut function loop
- utilize range-based for loop instead of traditional for loop
refactor(ring): update API response mapping type
- change map type from `interface{}` to `any` for better type safety
refactor(stream): handle nil source in NewStream
- add nil check for source elements before processing
refactor(webrtc): unify payload handling in GetToken
- change map type from `interface{}` to `any` for consistency
refactor(ascii): optimize nested loops in Write function
- replace traditional for loops with range-based for loops for readability
refactor(bits): enhance readability in Reader methods
- replace traditional for loops with range-based for loops in Read functions
refactor(h264): modernize loop structures in DecodeConfig
- switch to range-based for loops for cleaner code
refactor(h265): streamline profile_tier_level loops
- utilize range-based for loops instead of traditional for loops
chore(core): remove commented-out test function for clarity
refactor(core): simplify RandString function loop
- change traditional for loop to range-based for loop
refactor(flvt): optimize timestamp handling in TestTimeToRTP
- switch to range-based for loop for iterating frames
refactor(nest): improve error handling in ExchangeSDP
- format error message with printf-style formatting for clarity
refactor(tapo): enhance securityEncode function
- change traditional for loop to range-based for loop for readability
fix(tcp): correct masking in websocket Write method
- replace traditional for loop with range-based for loop
refactor(tutk): modernize encoding loops in crypto functions
- utilize range-based for loops for better readability
refactor(tuya): unify data types in MQTT message struct
- change map type from `interface{}` to `any` for consistency
refactor(webrtc): standardize codec registration
- change map type from `interface{}` to `any` for type safety
refactor(yaml): simplify Unmarshal function signature
- update parameter type from `interface{}` to `any` for better clarity
121 lines
2.1 KiB
Go
121 lines
2.1 KiB
Go
package core
|
|
|
|
import (
|
|
"fmt"
|
|
"testing"
|
|
|
|
"github.com/stretchr/testify/require"
|
|
)
|
|
|
|
type producer struct {
|
|
Medias []*Media
|
|
Receivers []*Receiver
|
|
|
|
id byte
|
|
}
|
|
|
|
func (p *producer) GetMedias() []*Media {
|
|
return p.Medias
|
|
}
|
|
|
|
func (p *producer) GetTrack(_ *Media, codec *Codec) (*Receiver, error) {
|
|
for _, receiver := range p.Receivers {
|
|
if receiver.Codec == codec {
|
|
return receiver, nil
|
|
}
|
|
}
|
|
receiver := NewReceiver(nil, codec)
|
|
p.Receivers = append(p.Receivers, receiver)
|
|
return receiver, nil
|
|
}
|
|
|
|
func (p *producer) Start() error {
|
|
pkt := &Packet{Payload: []byte{p.id}}
|
|
p.Receivers[0].Input(pkt)
|
|
return nil
|
|
}
|
|
|
|
func (p *producer) Stop() error {
|
|
for _, receiver := range p.Receivers {
|
|
receiver.Close()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
type consumer struct {
|
|
Medias []*Media
|
|
Senders []*Sender
|
|
|
|
cache chan byte
|
|
}
|
|
|
|
func (c *consumer) GetMedias() []*Media {
|
|
return c.Medias
|
|
}
|
|
|
|
func (c *consumer) AddTrack(_ *Media, _ *Codec, track *Receiver) error {
|
|
c.cache = make(chan byte, 1)
|
|
sender := NewSender(nil, track.Codec)
|
|
sender.Output = func(packet *Packet) {
|
|
c.cache <- packet.Payload[0]
|
|
}
|
|
sender.HandleRTP(track)
|
|
c.Senders = append(c.Senders, sender)
|
|
return nil
|
|
}
|
|
|
|
func (c *consumer) Stop() error {
|
|
for _, sender := range c.Senders {
|
|
sender.Close()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (c *consumer) read() byte {
|
|
return <-c.cache
|
|
}
|
|
|
|
func TestName(t *testing.T) {
|
|
GetProducer := func(b byte) Producer {
|
|
return &producer{
|
|
Medias: []*Media{
|
|
{
|
|
Kind: KindVideo,
|
|
Direction: DirectionRecvonly,
|
|
Codecs: []*Codec{
|
|
{Name: CodecH264},
|
|
},
|
|
},
|
|
},
|
|
id: b,
|
|
}
|
|
}
|
|
|
|
// stage1
|
|
prod1 := GetProducer(1)
|
|
cons2 := &consumer{}
|
|
|
|
media1 := prod1.GetMedias()[0]
|
|
track1, _ := prod1.GetTrack(media1, media1.Codecs[0])
|
|
|
|
_ = cons2.AddTrack(nil, nil, track1)
|
|
|
|
_ = prod1.Start()
|
|
require.Equal(t, byte(1), cons2.read())
|
|
|
|
// stage2
|
|
prod2 := GetProducer(2)
|
|
media2 := prod2.GetMedias()[0]
|
|
require.NotEqual(t, fmt.Sprintf("%p", media1), fmt.Sprintf("%p", media2))
|
|
track2, _ := prod2.GetTrack(media2, media2.Codecs[0])
|
|
track1.Replace(track2)
|
|
|
|
_ = prod1.Stop()
|
|
|
|
_ = prod2.Start()
|
|
require.Equal(t, byte(2), cons2.read())
|
|
|
|
// stage3
|
|
_ = prod2.Stop()
|
|
}
|