golang rtsp vers http

Avec le développement continu de la technologie Internet et la popularité des applications réseau, la technologie de streaming vidéo a progressivement retenu l'attention. Dans la technologie de streaming vidéo, RTSP est un protocole de transmission multimédia en streaming couramment utilisé, qui permet aux utilisateurs de transmettre et de lire des données audio et vidéo sur le réseau. Cependant, étant donné que le protocole RTSP utilise le protocole TCP pendant le processus de transmission, la vitesse de transmission sera relativement lente et la bande passante occupée sera relativement élevée, ce qui aura un certain impact sur l'expérience de visionnage vidéo de l'utilisateur. Afin de résoudre ce problème, nous pouvons utiliser la méthode de conversion du flux RTSP en flux HTTP, ce qui permettra d'économiser de la bande passante et d'augmenter la vitesse de transmission. Cet article explique comment utiliser Golang pour implémenter le processus de conversion de rtsp en http.

1. Utilisez Golang pour implémenter RTSP sur HTTP

Avant d'implémenter RTSP sur HTTP, nous devons d'abord comprendre la différence entre RTSP et HTTP. Le protocole RTSP doit implémenter la partie contrôle du protocole de transmission multimédia en streaming, mais le protocole HTTP implémente la transmission de pages statiques et la transmission de données. Par conséquent, si vous souhaitez convertir le flux RTSP en flux HTTP, vous devez ajouter une couche intermédiaire pour réaliser la transmission de la partie contrôle et de la page statique HTTP.

Golang est un langage de programmation efficace, simple, stable et hautement concurrent, très adapté au traitement des données de streaming audio et vidéo en temps réel. Par conséquent, nous avons choisi d'utiliser Golang pour implémenter le processus de conversion de RTSP en HTTP.

Tout d'abord, nous devons utiliser la bibliothèque de Golang pour implémenter l'analyse et le traitement du protocole RTSP. Dans Golang, il existe une bibliothèque tierce appelée "gosip", qui implémente l'analyse et le traitement du protocole RTSP. Nous pouvons utiliser cette bibliothèque pour implémenter le processus de conversion de RTSP en HTTP. De plus, nous devons également utiliser la bibliothèque HTTP de Golang pour implémenter la transmission du protocole HTTP.

Les étapes spécifiques de mise en œuvre sont les suivantes :

1. Tout d'abord, utilisez la bibliothèque gosip pour implémenter l'analyse et le traitement du protocole RTSP.

import (
    "github.com/gorilla/mux"
    "github.com/nareix/srtcp"
    "github.com/nareix/udp"
    "github.com/nareix/webrtc"
    "github.com/nareix/xtcp"
    "github.com/nareix/joy4/format"
    "github.com/nareix/joy4/format/ts"
    "github.com/nareix/joy4/av"
    "github.com/nareix/joy4/container/rtp"
    "github.com/nareix/joy4/av/pubsub"
    "github.com/nareix/joy4/cgo/ffmpeg"
    "github.com/nareix/joy4/av/pktque"
    "net/http"
    "io"
    "fmt"
    "bytes"
    "strconv"
)

...

// 使用gosip库解析RTSP请求
func processRTSP(rtspRequest io.ReadWriteCloser, pubsub1 *pubsub.PubSub, aacWrite io.WriteCloser, h264Write io.WriteCloser) {
    sessionHandle := func(s *rtsp.Session) {
        p, err := s.Streams()
        checkError(err)

        var vtrack av.CodecData
        var atracks []av.CodecData
        for _, vi := range p {
            switch vi.Type().(type) {
            case av.H264CodecData:
                vtrack = vi.(av.H264CodecData)
                break
            case av.AACCodecData:
                atracks = append(atracks, vi.(av.AACCodecData))
                break
            }
        }

        var streamDialers []av.MuxCloser
        var streamWriters []av.MuxCloser

        // 创建H264的PubSub并添加到H264 Pub集
        H264Pub := pubsub.NewSimpleMuxer(100)
        streamDialers = append(streamDialers, H264Pub)
        go func() {
            H264Out := <-H264Pub.Out
            H264Outs, err := rtp.Encode(H264Out, vtrack.(av.VideoCodecData).Sdp())
            checkError(err)
            defer H264Outs.Close()
            n, err := s.WriteInterleaved(H264Outs)
            checkError(err)
            fmt.Println("Sent", n, "bytes. H264")
        }()

        // 创建AAC的PubSub并添加到AAC Pub集
        AACPubs := make([]*pubsub.PubSub, len(atracks))
        for i, atrack := range atracks {
            AACPubs[i] = pubsub.NewSimpleMuxer(100)
            streamDialers = append(streamDialers, AACPubs[i])
            go func(atrack av.CodecData, AACPubs1 *pubsub.PubSub) {
                out := <-AACPubs1.Out
                aacOut, _ := atrack.NewMuxer(out)
                defer aacOut.Close()

                outs, err := rtp.Encode(aacOut, atrack.(av.AudioCodecData).Sdp())
                checkError(err)
                defer outs.Close()
                n, err := s.WriteInterleaved(outs)
                checkError(err)
                fmt.Println("Sent", n, "bytes. Audio")
            }(atrack, AACPubs[i])
        }

        // 打开相应的转换器
        if aacWrite != nil {
            streamWriters = append(streamWriters, aacWrite)
            pubAACOut := make(chan []byte)
            AACPubs[0].Out <- pubAACOut
            go func() { // 把音频包推送到channel，再写到文件 
                for {
                    samples := <-pubAACOut
                    _, err := aacWrite.Write(samples)
                    checkError(err)
                }
            }()
        }
        if h264Write != nil {
            streamWriters = append(streamWriters, h264Write)
            H264Pub.Out <- h264Write
        }

        // 等待停止
        <-s.Done()
        for _, dialer := range streamDialers {
            fmt.Println("Closing dialer")
            dialer.Close()
        }
        for _, writer := range streamWriters {
            fmt.Println("Closing writer")
            writer.Close()
        }
    }

    for {
        req, err := rtsp.NewRequest()
        checkError(err)
        s, err := rtsp.NewSession(req, rtspRequest)
        if err != nil {
            fmt.Println(err)
            break
        }
        sessionHandle(s)
    }
}

2. Utilisez la bibliothèque HTTP pour implémenter et transmettre le protocole HTTP.

...

// 使用HTTP协议请求推送的HLS流
func processHTTP(w http.ResponseWriter, r *http.Request) {
    ctx := &av.Context{Logger: logger}

    fmt.Println("New connection")
    defer fmt.Println("Closing write")

    v := mux.Vars(r)
    streamName := v["name"]

    if r.Method == "GET" {
        fmt.Println("HTTP GET request received...")

        segSeq := 0
        for {
            writer := NewHTTPStreamer(streamName, segSeq, w)
            segSeq++
            pubsub1 := pubsub.NewSimpleMuxer(100)

            // 创建http请求推送流着音视频流
            go func() {
                defer writer.Close()

                fmt.Println("Connected HTTP Writer. Waiting for output.")

                for {
                    Out := <-pubsub1.Out
                    fmt.Println("Received output")
                    ctx := &av.Context{Logger: logger, Write: writer}
                    fmt.Println(ctx)
                    defer ctx.Flush()
                    stream := Out[0]
                    fmt.Println(stream)
                    _ = avutil.CopyPackets(ctx, stream)
                }
            }()
            aacWrite, h264Write := getHLS(path.Join(videoTempDir, streamName), segSeq)
            processRTSP(NewRTSPReader(streamName), pubsub1, aacWrite, h264Write)
        }
    }
}

// 实现HTTP音视频流
func NewHTTPStreamer(base string, sn int, w http.ResponseWriter) *HTTPStreamer {
    str := fmt.Sprintf("%v/%v-%d.ts", videoTempDir, base, sn)
    f, _ := os.Create(str)
    return &HTTPStreamer{Writer: f, ResponseWriter: w}
}

...

3. Enfin, nous connectons la requête RTSP à la réponse HTTP pour réaliser le processus de conversion de RTSP en HTTP.

...

// 连接RTSP请求和HTTP响应
func streamInvoke(w http.ResponseWriter, r *http.Request) {
    fmt.Println(r.URL.Path)
    if strings.HasPrefix(r.URL.Path, "/stream/") {
        processHTTP(w, r)
    } else if strings.HasPrefix(r.URL.Path, "/hls/") {
        processHLS(w, r)
    } else {
        fmt.Println(r.URL.Path)
        w.WriteHeader(404)
    }
}

...

Ce qui précède est la méthode de mise en œuvre spécifique pour réaliser le processus de conversion de RTSP en HTTP via Golang. En convertissant le flux RTSP en flux HTTP, la transmission des médias vidéo peut être rendue plus rapide et plus efficace, améliorant ainsi l'expérience visuelle de l'utilisateur.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!