apps/plugin-webrtc
1
0
Fork 0
mirror of https://github.com/Monibuca/plugin-webrtc.git synced 2025-10-04 22:42:44 +08:00
Code Issues Actions Packages Projects Releases Wiki Activity

采用pion webrtc v3.0

Browse Source
This commit is contained in:
dexter
2021-01-27 17:26:10 +08:00
parent 2f2c1ad1bd
commit 58dce7a811
15 changed files with 223 additions and 11031 deletions
Download Patch File Download Diff File Expand all files Collapse all files

226
main.go
View File

@@ -10,12 +10,13 @@ import (
"sync"
"time"
. "github.com/Monibuca/engine/v2"
"github.com/Monibuca/engine/v2/avformat"
"github.com/Monibuca/engine/v3"
. "github.com/Monibuca/plugin-rtp"
"github.com/Monibuca/utils/v3"
"github.com/Monibuca/utils/v3/codec"
"github.com/pion/rtcp"
. "github.com/pion/webrtc/v2"
"github.com/pion/webrtc/v2/pkg/media"
. "github.com/pion/webrtc/v3"
"github.com/pion/webrtc/v3/pkg/media"
)
var config struct {
@@ -75,10 +76,9 @@ func (wl *WaitList) Get(k string) *WebRTC {
return wl.m[k]
}
func init() {
InstallPlugin(&PluginConfig{
engine.InstallPlugin(&engine.PluginConfig{
Config: &config,
Name: "WebRTC",
Type: PLUGIN_PUBLISHER | PLUGIN_SUBSCRIBER,
Run: run,
})
}
@@ -87,93 +87,111 @@ type WebRTC struct {
RTP
*PeerConnection
RemoteAddr string
audioTrack *Track
videoTrack *Track
audioTrack *TrackLocalStaticSample
videoTrack *TrackLocalStaticSample
m MediaEngine
s SettingEngine
api *API
payloader avformat.H264
payloader codec.H264
// codecs.H264Packet
// *os.File
}
func (rtc *WebRTC) Play(streamPath string) bool {
var sub Subscriber
var sub engine.Subscriber
sub.ID = rtc.RemoteAddr
sub.Type = "WebRTC"
var lastTimeStampV, lastTiimeStampA uint32
sub.OnData = func(packet *avformat.SendPacket) error {
if packet.Type == avformat.FLV_TAG_TYPE_AUDIO {
var s uint32
if lastTiimeStampA > 0 {
s = packet.Timestamp - lastTiimeStampA
}
lastTiimeStampA = packet.Timestamp
rtc.audioTrack.WriteSample(media.Sample{
Data: packet.Payload[1:],
Samples: s * 8,
})
return nil
}
if packet.IsSequence {
rtc.payloader.PPS = sub.PPS
rtc.payloader.SPS = sub.SPS
} else {
var s uint32
onVideo := func(pack engine.VideoPack){
var s uint32
if lastTimeStampV > 0 {
s = packet.Timestamp - lastTimeStampV
s = pack.Timestamp - lastTimeStampV
}
lastTimeStampV = packet.Timestamp
rtc.videoTrack.WriteSample(media.Sample{
Data: packet.Payload,
Samples: s * 90,
})
// if packet.IsKeyFrame {
// rtc.videoTrack.WriteSample(media.Sample{
// Data: sub.SPS,
// Samples: 0,
// })
// rtc.videoTrack.WriteSample(media.Sample{
// Data: sub.PPS,
// Samples: 0,
// })
// }
// for payload := packet.Payload[5:]; len(payload) > 4; {
// var naulLen = int(util.BigEndian.Uint32(payload))
// payload = payload[4:]
// rtc.videoTrack.WriteSample(media.Sample{
// Data: payload[:naulLen],
// Samples: s * 90,
// })
// s = 0
// payload = payload[naulLen:]
// }
}
return nil
lastTimeStampV = pack.Timestamp
if pack.NalType == codec.NALU_IDR_Picture {
rtc.videoTrack.WriteSample(media.Sample{
Data:sub.VideoTracks[0].SPS,
})
rtc.videoTrack.WriteSample(media.Sample{
Data:sub.VideoTracks[0].PPS,
})
}
rtc.videoTrack.WriteSample(media.Sample{
Data:pack.Payload,
Duration:time.Millisecond*time.Duration(s),
})
}
onAudio := func(pack engine.AudioPack){
var s uint32
if lastTiimeStampA > 0 {
s = pack.Timestamp - lastTiimeStampA
}
lastTiimeStampA = pack.Timestamp
rtc.audioTrack.WriteSample(media.Sample{
Data:pack.Payload,Duration: time.Millisecond*time.Duration(s),
})
}
// sub.OnData = func(packet *codec.SendPacket) error {
// if packet.Type == codec.FLV_TAG_TYPE_AUDIO {
// var s uint32
// if lastTiimeStampA > 0 {
// s = packet.Timestamp - lastTiimeStampA
// }
// lastTiimeStampA = packet.Timestamp
// rtc.audioTrack.WriteSample(media.Sample{
// Data: packet.Payload[1:],
// Samples: s * 8,
// })
// return nil
// }
// if packet.IsSequence {
// rtc.payloader.PPS = sub.PPS
// rtc.payloader.SPS = sub.SPS
// } else {
// var s uint32
// if lastTimeStampV > 0 {
// s = packet.Timestamp - lastTimeStampV
// }
// lastTimeStampV = packet.Timestamp
// rtc.videoTrack.WriteSample(media.Sample{
// Data: packet.Payload,
// Samples: s * 90,
// })
// }
// return nil
// }
// go sub.Subscribe(streamPath)
rtc.OnICEConnectionStateChange(func(connectionState ICEConnectionState) {
Printf("%s Connection State has changed %s ", streamPath, connectionState.String())
utils.Printf("%s Connection State has changed %s ", streamPath, connectionState.String())
switch connectionState {
case ICEConnectionStateDisconnected:
sub.Close()
rtc.Close()
case ICEConnectionStateConnected:
//rtc.videoTrack = rtc.GetSenders()[0].Track()
sub.Subscribe(streamPath)
if err := sub.Subscribe(streamPath);err== nil {
go sub.VideoTracks[0].Play(sub.Context,onVideo)
go sub.AudioTracks[0].Play(sub.Context,onAudio)
}
}
})
return true
}
func (rtc *WebRTC) Publish(streamPath string) bool {
rtc.m.RegisterCodec(NewRTPCodec(RTPCodecTypeVideo,
H264,
90000,
0,
"level-asymmetry-allowed=1;packetization-mode=1;profile-level-id=42001f",
DefaultPayloadTypeH264,
new(avformat.H264)))
rtc.m.RegisterDefaultCodecs()
// rtc.m.RegisterCodec(NewRTPCodec(RTPCodecTypeVideo,
// H264,
// 90000,
// 0,
// "level-asymmetry-allowed=1;packetization-mode=1;profile-level-id=42001f",
// DefaultPayloadTypeH264,
// new(codec.H264)))
// rtc.m.RegisterCodec(RTPCodecParameters{
// RTPCodecCapability: RTPCodecCapability{MimeType: "video/h264", ClockRate: 90000, Channels: 0, SDPFmtpLine: "", RTCPFeedback: nil},
// PayloadType: 96,
// }, RTPCodecTypeVideo);
//m.RegisterCodec(NewRTPPCMUCodec(DefaultPayloadTypePCMU, 8000))
if !strings.HasPrefix(rtc.RemoteAddr, "127.0.0.1") && !strings.HasPrefix(rtc.RemoteAddr, "[::1]") {
rtc.s.SetNAT1To1IPs(config.PublicIP, ICECandidateTypeHost)
@@ -181,7 +199,7 @@ func (rtc *WebRTC) Publish(streamPath string) bool {
if config.PortMin > 0 && config.PortMax > 0 {
rtc.s.SetEphemeralUDPPortRange(config.PortMin, config.PortMax)
}
rtc.api = NewAPI(WithMediaEngine(rtc.m), WithSettingEngine(rtc.s))
rtc.api = NewAPI(WithMediaEngine(&rtc.m), WithSettingEngine(rtc.s))
peerConnection, err := rtc.api.NewPeerConnection(Configuration{
ICEServers: []ICEServer{
{
@@ -190,12 +208,12 @@ func (rtc *WebRTC) Publish(streamPath string) bool {
},
})
if err != nil {
Println(err)
utils.Println(err)
return false
}
if _, err = peerConnection.AddTransceiverFromKind(RTPCodecTypeVideo); err != nil {
if err != nil {
Println(err)
utils.Println(err)
return false
}
}
@@ -203,7 +221,7 @@ func (rtc *WebRTC) Publish(streamPath string) bool {
return false
}
peerConnection.OnICEConnectionStateChange(func(connectionState ICEConnectionState) {
Printf("%s Connection State has changed %s ", streamPath, connectionState.String())
utils.Printf("%s Connection State has changed %s ", streamPath, connectionState.String())
switch connectionState {
case ICEConnectionStateDisconnected, ICEConnectionStateFailed:
if rtc.Stream != nil {
@@ -215,13 +233,13 @@ func (rtc *WebRTC) Publish(streamPath string) bool {
if rtc.RTP.Publish(streamPath) {
//f, _ := os.OpenFile("resource/live/rtc.h264", os.O_TRUNC|os.O_WRONLY, 0666)
rtc.Stream.Type = "WebRTC"
peerConnection.OnTrack(func(track *Track, receiver *RTPReceiver) {
peerConnection.OnTrack(func(track *TrackRemote, receiver *RTPReceiver) {
defer rtc.Stream.Close()
go func() {
ticker := time.NewTicker(time.Second * 2)
select {
case <-ticker.C:
if rtcpErr := peerConnection.WriteRTCP([]rtcp.Packet{&rtcp.PictureLossIndication{MediaSSRC: track.SSRC()}}); rtcpErr != nil {
if rtcpErr := peerConnection.WriteRTCP([]rtcp.Packet{&rtcp.PictureLossIndication{MediaSSRC: uint32(track.SSRC())}}); rtcpErr != nil {
fmt.Println(rtcpErr)
}
case <-rtc.Done():
@@ -232,7 +250,7 @@ func (rtc *WebRTC) Publish(streamPath string) bool {
Type: RTPType(track.Kind() - 1),
}
for b := make([]byte, 1460); ; rtc.PushPack(pack) {
i, err := track.Read(b)
i,_, err := track.Read(b)
if err != nil {
return
}
@@ -254,12 +272,13 @@ func (rtc *WebRTC) GetAnswer() ([]byte, error) {
if err != nil {
return nil, err
}
//gatherComplete := webrtc.GatheringCompletePromise(rtc.PeerConnection)
if err := rtc.SetLocalDescription(answer); err != nil {
Println(err)
utils.Println(err)
return nil, err
}
if bytes, err := json.Marshal(answer); err != nil {
Println(err)
utils.Println(err)
return bytes, err
} else {
return bytes, nil
@@ -284,7 +303,7 @@ func run() {
bytes, err := ioutil.ReadAll(r.Body)
defer func() {
if err != nil {
Println(err)
utils.Println(err)
fmt.Fprintf(w, `{"errmsg":"%s"}`, err)
return
}
@@ -298,28 +317,35 @@ func run() {
}
pli := "42001f"
if stream := FindStream(streamPath); stream != nil {
if stream := engine.FindStream(streamPath); stream != nil {
<-stream.WaitPub
pli = fmt.Sprintf("%x", stream.SPS[1:4])
pli = fmt.Sprintf("%x", stream.VideoTracks[0].SPS[1:4])
}
if !strings.Contains(offer.SDP, pli) {
pli = reg_level.FindAllStringSubmatch(offer.SDP, -1)[0][1]
}
rtc.m.RegisterCodec(NewRTPCodec(RTPCodecTypeVideo,
H264,
90000,
0,
"level-asymmetry-allowed=1;packetization-mode=1;profile-level-id="+pli,
DefaultPayloadTypeH264,
&rtc.payloader))
rtc.m.RegisterCodec(NewRTPPCMACodec(DefaultPayloadTypePCMA, 8000))
if !strings.HasPrefix(r.RemoteAddr, "127.0.0.1") && !strings.HasPrefix(r.RemoteAddr, "[::1]") {
rtc.s.SetNAT1To1IPs(config.PublicIP, ICECandidateTypeHost)
}
// rtc.m.RegisterCodec(NewRTPCodec(RTPCodecTypeVideo,
// H264,
// 90000,
// 0,
// "level-asymmetry-allowed=1;packetization-mode=1;profile-level-id="+pli,
// DefaultPayloadTypeH264,
// &rtc.payloader))
rtc.m.RegisterDefaultCodecs()
// rtc.m.RegisterCodec(RTPCodecParameters{
// RTPCodecCapability: RTPCodecCapability{MimeType: "video/h264", ClockRate: 90000, Channels: 0, SDPFmtpLine: "", RTCPFeedback: nil},
// PayloadType: 102,
// }, RTPCodecTypeVideo);
// rtc.m.RegisterCodec(NewRTPPCMACodec(DefaultPayloadTypePCMA, 8000))
// if !strings.HasPrefix(r.RemoteAddr, "127.0.0.1") && !strings.HasPrefix(r.RemoteAddr, "[::1]") {
// rtc.s.SetNAT1To1IPs(config.PublicIP, ICECandidateTypeHost)
// }
if config.PortMin > 0 && config.PortMax > 0 {
rtc.s.SetEphemeralUDPPortRange(config.PortMin, config.PortMax)
}
rtc.api = NewAPI(WithMediaEngine(rtc.m), WithSettingEngine(rtc.s))
rtc.api = NewAPI(WithMediaEngine(&rtc.m), WithSettingEngine(rtc.s))
if rtc.PeerConnection, err = rtc.api.NewPeerConnection(Configuration{
// ICEServers: []ICEServer{
@@ -332,7 +358,7 @@ func run() {
}
rtc.OnICECandidate(func(ice *ICECandidate) {
if ice != nil {
Println(ice.ToJSON().Candidate)
utils.Println(ice.ToJSON().Candidate)
}
})
// if r, err := peerConnection.AddTransceiverFromKind(RTPCodecTypeVideo); err == nil {
@@ -356,10 +382,14 @@ func run() {
// }
// }
// println(vpayloadType)
if rtc.videoTrack, err = rtc.NewTrack(DefaultPayloadTypeH264, 8, "video", "monibuca"); err != nil {
return
}
if rtc.audioTrack, err = rtc.NewTrack(DefaultPayloadTypePCMA, 9, "audio", "monibuca"); err != nil {
// if rtc.videoTrack, err = rtc.Track(DefaultPayloadTypeH264, 8, "video", "monibuca"); err != nil {
// return
// }
// if rtc.audioTrack, err = rtc.Track(DefaultPayloadTypePCMA, 9, "audio", "monibuca"); err != nil {
// return
// }
if rtc.videoTrack,err = NewTrackLocalStaticSample(RTPCodecCapability{MimeType:"video/h264",SDPFmtpLine: "level-asymmetry-allowed=1;packetization-mode=1;profile-level-id="+pli},"video","m7s");err!=nil{
return
}
if _, err = rtc.AddTrack(rtc.videoTrack); err != nil {
@@ -378,20 +408,20 @@ func run() {
bytes, err := ioutil.ReadAll(r.Body)
err = json.Unmarshal(bytes, &offer)
if err != nil {
Println(err)
utils.Println(err)
return
}
rtc := new(WebRTC)
rtc.RemoteAddr = r.RemoteAddr
if rtc.Publish(streamPath) {
if err := rtc.SetRemoteDescription(offer); err != nil {
Println(err)
utils.Println(err)
return
}
if bytes, err = rtc.GetAnswer(); err == nil {
w.Write(bytes)
} else {
Println(err)
utils.Println(err)
w.Write([]byte(err.Error()))
return
}