Rewrite exec pipe, TCP and HTTP sources
This commit is contained in:
Alexey Khit
@@ -0,0 +1,207 @@
|
||||
package magic
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"encoding/hex"
|
||||
"errors"
|
||||
"github.com/AlexxIT/go2rtc/pkg/core"
|
||||
"github.com/AlexxIT/go2rtc/pkg/h264"
|
||||
"github.com/AlexxIT/go2rtc/pkg/h265"
|
||||
"github.com/AlexxIT/go2rtc/pkg/mpegts"
|
||||
"github.com/pion/rtp"
|
||||
"io"
|
||||
)
|
||||
|
||||
// Client - can read unknown bytestream and autodetect format
|
||||
type Client struct {
|
||||
Desc string
|
||||
URL string
|
||||
|
||||
Handle func() error
|
||||
|
||||
r io.ReadCloser
|
||||
sniff []byte
|
||||
|
||||
medias []*core.Media
|
||||
receiver *core.Receiver
|
||||
|
||||
recv int
|
||||
}
|
||||
|
||||
func NewClient(r io.ReadCloser) *Client {
|
||||
return &Client{r: r}
|
||||
}
|
||||
|
||||
func (c *Client) Probe() (err error) {
|
||||
c.sniff = make([]byte, mpegts.PacketSize*3) // MPEG-TS: SDT+PAT+PMT
|
||||
c.recv, err = io.ReadFull(c.r, c.sniff)
|
||||
if err != nil {
|
||||
_ = c.Close()
|
||||
return
|
||||
}
|
||||
|
||||
var codec *core.Codec
|
||||
|
||||
if bytes.HasPrefix(c.sniff, []byte{0, 0, 0, 1}) {
|
||||
switch {
|
||||
case h264.NALUType(c.sniff) == h264.NALUTypeSPS:
|
||||
codec = &core.Codec{
|
||||
Name: core.CodecH264,
|
||||
ClockRate: 90000,
|
||||
PayloadType: core.PayloadTypeRAW,
|
||||
}
|
||||
c.Handle = c.ReadBitstreams
|
||||
|
||||
case h265.NALUType(c.sniff) == h265.NALUTypeVPS:
|
||||
codec = &core.Codec{
|
||||
Name: core.CodecH265,
|
||||
ClockRate: 90000,
|
||||
PayloadType: core.PayloadTypeRAW,
|
||||
}
|
||||
c.Handle = c.ReadBitstreams
|
||||
}
|
||||
|
||||
} else if bytes.HasPrefix(c.sniff, []byte{0xFF, 0xD8}) {
|
||||
codec = &core.Codec{
|
||||
Name: core.CodecJPEG,
|
||||
ClockRate: 90000,
|
||||
PayloadType: core.PayloadTypeRAW,
|
||||
}
|
||||
c.Handle = c.ReadMJPEG
|
||||
|
||||
} else if c.sniff[0] == mpegts.SyncByte {
|
||||
ts := mpegts.NewReader()
|
||||
ts.AppendBuffer(c.sniff)
|
||||
_ = ts.GetPacket()
|
||||
for _, streamType := range ts.GetStreamTypes() {
|
||||
switch streamType {
|
||||
case mpegts.StreamTypeH264:
|
||||
codec = &core.Codec{
|
||||
Name: core.CodecH264,
|
||||
ClockRate: 90000,
|
||||
PayloadType: core.PayloadTypeRAW,
|
||||
}
|
||||
c.Handle = c.ReadMPEGTS
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if codec == nil {
|
||||
_ = c.Close()
|
||||
return errors.New("unknown format: " + hex.EncodeToString(c.sniff[:8]))
|
||||
}
|
||||
|
||||
c.medias = append(c.medias, &core.Media{
|
||||
Kind: core.KindVideo,
|
||||
Direction: core.DirectionRecvonly,
|
||||
Codecs: []*core.Codec{codec},
|
||||
})
|
||||
|
||||
return
|
||||
}
|
||||
|
||||
func (c *Client) ReadBitstreams() error {
|
||||
buf := c.sniff // total bufer
|
||||
b := make([]byte, 1024*1024) // reading buffer
|
||||
|
||||
var decodeStream func([]byte) ([]byte, int)
|
||||
switch c.receiver.Codec.Name {
|
||||
case core.CodecH264:
|
||||
decodeStream = h264.DecodeStream
|
||||
case core.CodecH265:
|
||||
decodeStream = h265.DecodeStream
|
||||
}
|
||||
|
||||
for {
|
||||
payload, n := decodeStream(buf)
|
||||
if payload == nil {
|
||||
n, err := c.r.Read(b)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
buf = append(buf, b[:n]...)
|
||||
c.recv += n
|
||||
continue
|
||||
}
|
||||
|
||||
buf = buf[n:]
|
||||
|
||||
//log.Printf("[AVC] %v, len: %d", h264.Types(payload), len(payload))
|
||||
|
||||
pkt := &rtp.Packet{
|
||||
Header: rtp.Header{Timestamp: core.Now90000()},
|
||||
Payload: payload,
|
||||
}
|
||||
c.receiver.WriteRTP(pkt)
|
||||
}
|
||||
}
|
||||
|
||||
func (c *Client) ReadMJPEG() error {
|
||||
buf := c.sniff // total bufer
|
||||
b := make([]byte, 1024*1024) // reading buffer
|
||||
|
||||
for {
|
||||
// one JPEG end and next start
|
||||
i := bytes.Index(buf, []byte{0xFF, 0xD9, 0xFF, 0xD8})
|
||||
if i < 0 {
|
||||
n, err := c.r.Read(b)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
buf = append(buf, b[:n]...)
|
||||
c.recv += n
|
||||
|
||||
// if we receive frame
|
||||
if n >= 2 && b[n-2] == 0xFF && b[n-1] == 0xD9 {
|
||||
i = len(buf)
|
||||
} else {
|
||||
continue
|
||||
}
|
||||
} else {
|
||||
i += 2
|
||||
}
|
||||
|
||||
pkt := &rtp.Packet{
|
||||
Header: rtp.Header{Timestamp: core.Now90000()},
|
||||
Payload: buf[:i],
|
||||
}
|
||||
c.receiver.WriteRTP(pkt)
|
||||
|
||||
buf = buf[i:]
|
||||
}
|
||||
}
|
||||
|
||||
func (c *Client) ReadMPEGTS() error {
|
||||
b := make([]byte, 1024*1024) // reading buffer
|
||||
|
||||
ts := mpegts.NewReader()
|
||||
ts.AppendBuffer(c.sniff)
|
||||
|
||||
for {
|
||||
packet := ts.GetPacket()
|
||||
if packet == nil {
|
||||
n, err := c.r.Read(b)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
ts.AppendBuffer(b[:n])
|
||||
c.recv += n
|
||||
continue
|
||||
}
|
||||
|
||||
//log.Printf("[AVC] %v, len: %d, ts: %10d", h264.Types(packet.Payload), len(packet.Payload), packet.Timestamp)
|
||||
|
||||
if packet.PayloadType != mpegts.StreamTypeH264 {
|
||||
continue
|
||||
}
|
||||
|
||||
c.receiver.WriteRTP(packet)
|
||||
}
|
||||
}
|
||||
|
||||
func (c *Client) Close() error {
|
||||
return c.r.Close()
|
||||
}
|
||||
@@ -0,0 +1,91 @@
|
||||
package magic
|
||||
|
||||
import (
|
||||
"github.com/AlexxIT/go2rtc/pkg/core"
|
||||
"github.com/AlexxIT/go2rtc/pkg/h264"
|
||||
"github.com/AlexxIT/go2rtc/pkg/h265"
|
||||
"github.com/AlexxIT/go2rtc/pkg/mjpeg"
|
||||
"github.com/pion/rtp"
|
||||
)
|
||||
|
||||
type Keyframe struct {
|
||||
core.Listener
|
||||
|
||||
UserAgent string
|
||||
RemoteAddr string
|
||||
|
||||
medias []*core.Media
|
||||
sender *core.Sender
|
||||
}
|
||||
|
||||
func (k *Keyframe) GetMedias() []*core.Media {
|
||||
if k.medias == nil {
|
||||
k.medias = append(k.medias, &core.Media{
|
||||
Kind: core.KindVideo,
|
||||
Direction: core.DirectionSendonly,
|
||||
Codecs: []*core.Codec{
|
||||
{Name: core.CodecH264},
|
||||
{Name: core.CodecH265},
|
||||
{Name: core.CodecJPEG},
|
||||
},
|
||||
})
|
||||
}
|
||||
return k.medias
|
||||
}
|
||||
|
||||
func (k *Keyframe) AddTrack(media *core.Media, _ *core.Codec, track *core.Receiver) error {
|
||||
var handler core.HandlerFunc
|
||||
|
||||
switch track.Codec.Name {
|
||||
case core.CodecH264:
|
||||
handler = func(packet *rtp.Packet) {
|
||||
if !h264.IsKeyframe(packet.Payload) {
|
||||
return
|
||||
}
|
||||
b := h264.AVCtoAnnexB(packet.Payload)
|
||||
k.Fire(b)
|
||||
}
|
||||
|
||||
if track.Codec.IsRTP() {
|
||||
handler = h264.RTPDepay(track.Codec, handler)
|
||||
}
|
||||
case core.CodecH265:
|
||||
handler = func(packet *rtp.Packet) {
|
||||
if !h265.IsKeyframe(packet.Payload) {
|
||||
return
|
||||
}
|
||||
k.Fire(packet.Payload)
|
||||
}
|
||||
|
||||
if track.Codec.IsRTP() {
|
||||
handler = h265.RTPDepay(track.Codec, handler)
|
||||
}
|
||||
case core.CodecJPEG:
|
||||
handler = func(packet *rtp.Packet) {
|
||||
k.Fire(packet.Payload)
|
||||
}
|
||||
|
||||
if track.Codec.IsRTP() {
|
||||
handler = mjpeg.RTPDepay(handler)
|
||||
}
|
||||
}
|
||||
|
||||
k.sender = core.NewSender(media, track.Codec)
|
||||
k.sender.Handler = handler
|
||||
k.sender.HandleRTP(track)
|
||||
return nil
|
||||
}
|
||||
|
||||
func (k *Keyframe) CodecName() string {
|
||||
if k.sender != nil {
|
||||
return k.sender.Codec.Name
|
||||
}
|
||||
return ""
|
||||
}
|
||||
|
||||
func (k *Keyframe) Stop() error {
|
||||
if k.sender != nil {
|
||||
k.sender.Close()
|
||||
}
|
||||
return nil
|
||||
}
|
||||
@@ -0,0 +1,41 @@
|
||||
package magic
|
||||
|
||||
import (
|
||||
"encoding/json"
|
||||
"github.com/AlexxIT/go2rtc/pkg/core"
|
||||
)
|
||||
|
||||
func (c *Client) GetMedias() []*core.Media {
|
||||
return c.medias
|
||||
}
|
||||
|
||||
func (c *Client) GetTrack(media *core.Media, codec *core.Codec) (*core.Receiver, error) {
|
||||
if c.receiver == nil {
|
||||
c.receiver = core.NewReceiver(media, codec)
|
||||
}
|
||||
return c.receiver, nil
|
||||
}
|
||||
|
||||
func (c *Client) Start() error {
|
||||
return c.Handle()
|
||||
}
|
||||
|
||||
func (c *Client) Stop() (err error) {
|
||||
if c.receiver != nil {
|
||||
c.receiver.Close()
|
||||
}
|
||||
return c.Close()
|
||||
}
|
||||
|
||||
func (c *Client) MarshalJSON() ([]byte, error) {
|
||||
info := &core.Info{
|
||||
Type: c.Desc,
|
||||
URL: c.URL,
|
||||
Medias: c.medias,
|
||||
Recv: c.recv,
|
||||
}
|
||||
if c.receiver != nil {
|
||||
info.Receivers = append(info.Receivers, c.receiver)
|
||||
}
|
||||
return json.Marshal(info)
|
||||
}
|
||||
Reference in New Issue
Block a user