mirror of
https://github.com/langhuihui/monibuca.git
synced 2025-10-05 22:26:50 +08:00
220 lines
5.6 KiB
Go
220 lines
5.6 KiB
Go
package plugin_webrtc
|
|
|
|
import (
|
|
"fmt"
|
|
"github.com/pion/rtcp"
|
|
. "github.com/pion/webrtc/v3"
|
|
"io"
|
|
"m7s.live/m7s/v5"
|
|
. "m7s.live/m7s/v5/pkg"
|
|
"m7s.live/m7s/v5/pkg/codec"
|
|
mrtp "m7s.live/m7s/v5/plugin/rtp/pkg"
|
|
. "m7s.live/m7s/v5/plugin/webrtc/pkg"
|
|
"net/http"
|
|
"strings"
|
|
)
|
|
|
|
// https://datatracker.ietf.org/doc/html/draft-ietf-wish-whip
|
|
func (conf *WebRTCPlugin) Push_(w http.ResponseWriter, r *http.Request) {
|
|
streamPath := r.URL.Path[len("/push/"):]
|
|
rawQuery := r.URL.RawQuery
|
|
auth := r.Header.Get("Authorization")
|
|
if strings.HasPrefix(auth, "Bearer ") {
|
|
auth = auth[len("Bearer "):]
|
|
if rawQuery != "" {
|
|
rawQuery += "&bearer=" + auth
|
|
} else {
|
|
rawQuery = "bearer=" + auth
|
|
}
|
|
conf.Info("push", "stream", streamPath, "bearer", auth)
|
|
}
|
|
w.Header().Set("Content-Type", "application/sdp")
|
|
w.Header().Set("Location", "/webrtc/api/stop/push/"+streamPath)
|
|
w.Header().Set("Access-Control-Allow-Private-Network", "true")
|
|
if rawQuery != "" {
|
|
streamPath += "?" + rawQuery
|
|
}
|
|
bytes, err := io.ReadAll(r.Body)
|
|
if err != nil {
|
|
http.Error(w, err.Error(), http.StatusBadRequest)
|
|
return
|
|
}
|
|
conn := Connection{
|
|
PLI: conf.PLI,
|
|
SDP: string(bytes),
|
|
}
|
|
conn.Logger = conf.Logger
|
|
if conn.PeerConnection, err = conf.api.NewPeerConnection(Configuration{
|
|
ICEServers: conf.ICEServers,
|
|
}); err != nil {
|
|
http.Error(w, err.Error(), http.StatusInternalServerError)
|
|
return
|
|
}
|
|
if conn.Publisher, err = conf.Publish(conf.Context, streamPath); err != nil {
|
|
http.Error(w, err.Error(), http.StatusBadRequest)
|
|
return
|
|
}
|
|
conf.AddTask(&conn)
|
|
conn.Receive()
|
|
if err := conn.SetRemoteDescription(SessionDescription{Type: SDPTypeOffer, SDP: conn.SDP}); err != nil {
|
|
http.Error(w, err.Error(), http.StatusBadRequest)
|
|
return
|
|
}
|
|
if answer, err := conn.GetAnswer(); err == nil {
|
|
w.WriteHeader(http.StatusCreated)
|
|
fmt.Fprint(w, answer.SDP)
|
|
} else {
|
|
http.Error(w, err.Error(), http.StatusBadRequest)
|
|
return
|
|
}
|
|
}
|
|
|
|
func (conf *WebRTCPlugin) Play_(w http.ResponseWriter, r *http.Request) {
|
|
w.Header().Set("Content-Type", "application/sdp")
|
|
streamPath := r.URL.Path[len("/play/"):]
|
|
rawQuery := r.URL.RawQuery
|
|
var conn Connection
|
|
bytes, err := io.ReadAll(r.Body)
|
|
defer func() {
|
|
if err != nil {
|
|
http.Error(w, err.Error(), http.StatusBadRequest)
|
|
}
|
|
}()
|
|
if err != nil {
|
|
return
|
|
}
|
|
conn.SDP = string(bytes)
|
|
if conn.PeerConnection, err = conf.api.NewPeerConnection(Configuration{
|
|
ICEServers: conf.ICEServers,
|
|
}); err != nil {
|
|
return
|
|
}
|
|
conf.AddTask(&conn)
|
|
var suber *m7s.Subscriber
|
|
if rawQuery != "" {
|
|
streamPath += "?" + rawQuery
|
|
}
|
|
if suber, err = conf.Subscribe(conf.Context, streamPath); err != nil {
|
|
return
|
|
}
|
|
conn.AddTask(suber)
|
|
var useDC bool
|
|
var audioTLSRTP, videoTLSRTP *TrackLocalStaticRTP
|
|
var audioSender, videoSender *RTPSender
|
|
if vt := suber.Publisher.VideoTrack.AVTrack; vt != nil {
|
|
if vt.FourCC() == codec.FourCC_H265 {
|
|
useDC = true
|
|
} else {
|
|
var rcc RTPCodecParameters
|
|
if ctx, ok := vt.ICodecCtx.(mrtp.IRTPCtx); ok {
|
|
rcc = ctx.GetRTPCodecParameter()
|
|
} else {
|
|
var rtpCtx mrtp.RTPData
|
|
var tmpAVTrack AVTrack
|
|
tmpAVTrack.ICodecCtx, _, err = rtpCtx.ConvertCtx(vt.ICodecCtx)
|
|
if err == nil {
|
|
rcc = tmpAVTrack.ICodecCtx.(mrtp.IRTPCtx).GetRTPCodecParameter()
|
|
} else {
|
|
return
|
|
}
|
|
}
|
|
videoTLSRTP, err = NewTrackLocalStaticRTP(rcc.RTPCodecCapability, vt.FourCC().String(), suber.StreamPath)
|
|
if err != nil {
|
|
return
|
|
}
|
|
videoSender, err = conn.PeerConnection.AddTrack(videoTLSRTP)
|
|
if err != nil {
|
|
return
|
|
}
|
|
go func() {
|
|
rtcpBuf := make([]byte, 1500)
|
|
for {
|
|
if n, _, rtcpErr := videoSender.Read(rtcpBuf); rtcpErr != nil {
|
|
suber.Warn("rtcp read error", "error", rtcpErr)
|
|
return
|
|
} else {
|
|
if p, err := rtcp.Unmarshal(rtcpBuf[:n]); err == nil {
|
|
for _, pp := range p {
|
|
switch pp.(type) {
|
|
case *rtcp.PictureLossIndication:
|
|
// fmt.Println("PictureLossIndication")
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}()
|
|
}
|
|
}
|
|
if at := suber.Publisher.AudioTrack.AVTrack; at != nil {
|
|
if at.FourCC() == codec.FourCC_MP4A {
|
|
useDC = true
|
|
} else {
|
|
ctx := at.ICodecCtx.(interface {
|
|
GetRTPCodecCapability() RTPCodecCapability
|
|
})
|
|
audioTLSRTP, err = NewTrackLocalStaticRTP(ctx.GetRTPCodecCapability(), at.FourCC().String(), suber.StreamPath)
|
|
if err != nil {
|
|
return
|
|
}
|
|
audioSender, err = conn.PeerConnection.AddTrack(audioTLSRTP)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
}
|
|
|
|
if conf.EnableDC && useDC {
|
|
dc, err := conn.CreateDataChannel(suber.StreamPath, nil)
|
|
if err != nil {
|
|
return
|
|
}
|
|
// TODO: DataChannel
|
|
go func() {
|
|
// suber.Handle(m7s.SubscriberHandler{
|
|
// OnAudio: func(audio *rtmp.RTMPAudio) error {
|
|
// },
|
|
// OnVideo: func(video *rtmp.RTMPVideo) error {
|
|
// },
|
|
// })
|
|
dc.Close()
|
|
}()
|
|
} else {
|
|
if audioSender == nil {
|
|
suber.SubAudio = false
|
|
}
|
|
if videoSender == nil {
|
|
suber.SubVideo = false
|
|
}
|
|
go m7s.PlayBlock(suber, func(frame *mrtp.Audio) (err error) {
|
|
for _, p := range frame.Packets {
|
|
if err = audioTLSRTP.WriteRTP(p); err != nil {
|
|
return
|
|
}
|
|
}
|
|
return
|
|
}, func(frame *mrtp.Video) error {
|
|
for _, p := range frame.Packets {
|
|
if err := videoTLSRTP.WriteRTP(p); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
return nil
|
|
})
|
|
}
|
|
conn.OnICECandidate(func(ice *ICECandidate) {
|
|
if ice != nil {
|
|
suber.Info(ice.ToJSON().Candidate)
|
|
}
|
|
})
|
|
if err = conn.SetRemoteDescription(SessionDescription{Type: SDPTypeOffer, SDP: conn.SDP}); err != nil {
|
|
http.Error(w, err.Error(), http.StatusInternalServerError)
|
|
return
|
|
}
|
|
if sdp, err := conn.GetAnswer(); err == nil {
|
|
w.Write([]byte(sdp.SDP))
|
|
} else {
|
|
http.Error(w, err.Error(), http.StatusBadRequest)
|
|
}
|
|
}
|