Files
monibuca/plugin/webrtc/api.go
2024-10-08 20:32:55 +08:00

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)
}
}