go - 如何将视频捕获流式传输到Web

Question

我下面的代码读取了cam并将其显示在GUI窗口中，我想将相同的内容通过url localhost:8080/cam推送到我的服务器，该怎么做？

package main

import (
    "gocv.io/x/gocv"
)

func main() {
    webcam, _ := gocv.VideoCaptureDevice(0)
    defer webcam.Close() // Close the cam once execution completed
    window := gocv.NewWindow("Hello")
    defer window.Close() // Close the GUI once execution completed, though it is done automatically
    img := gocv.NewMat()
    defer img.Close() // Close the img once execution completed

    for {
        webcam.Read(&img)
        window.IMShow(img)
        // Want to do streaming here to localhost:8080/cam
        if window.WaitKey(1) == 27 { // 27 => Esc
            break
        }
    }
}

Answer 1

我找到了this包this包，找到了解决方案

package mjpeg

import (
    "fmt"
    "log"
    "net/http"
    "sync"
    "time"
)

// Stream represents a single video feed.
type Stream struct {
    m             map[chan []byte]bool
    frame         []byte
    lock          sync.Mutex
    FrameInterval time.Duration
}

const boundaryWord = "MJPEGBOUNDARY"
const headerf = "\r\n" +
    "--" + boundaryWord + "\r\n" +
    "Content-Type: image/jpeg\r\n" +
    "Content-Length: %d\r\n" +
    "X-Timestamp: 0.000000\r\n" +
    "\r\n"

// ServeHTTP responds to HTTP requests with the MJPEG stream, implementing the http.Handler interface.
func (s *Stream) ServeHTTP(w http.ResponseWriter, r *http.Request) {
    log.Println("Stream:", r.RemoteAddr, "connected")
    w.Header().Add("Content-Type", "multipart/x-mixed-replace;boundary="+boundaryWord)

    c := make(chan []byte)
    s.lock.Lock()
    s.m[c] = true
    s.lock.Unlock()

    for {
        time.Sleep(s.FrameInterval)
        b := <-c
        _, err := w.Write(b)
        if err != nil {
            break
        }
    }

    s.lock.Lock()
    delete(s.m, c)
    s.lock.Unlock()
    log.Println("Stream:", r.RemoteAddr, "disconnected")
}

// UpdateJPEG pushes a new JPEG frame onto the clients.
func (s *Stream) UpdateJPEG(jpeg []byte) {
    header := fmt.Sprintf(headerf, len(jpeg))
    if len(s.frame) < len(jpeg)+len(header) {
        s.frame = make([]byte, (len(jpeg)+len(header))*2)
    }

    copy(s.frame, header)
    copy(s.frame[len(header):], jpeg)

    s.lock.Lock()
    for c := range s.m {
        // Select to skip streams which are sleeping to drop frames.
        // This might need more thought.
        select {
        case c <- s.frame:
        default:
        }
    }
    s.lock.Unlock()
}

// NewStream initializes and returns a new Stream.
func NewStream() *Stream {
    return &Stream{
        m:             make(map[chan []byte]bool),
        frame:         make([]byte, len(headerf)),
        FrameInterval: 50 * time.Millisecond,
    }
}

我正在运行的任何代码是:

package main

import (
    "fmt"
    "log"
    "net/http"

    "github.com/hybridgroup/mjpeg"
    _ "github.com/hybridgroup/mjpeg"
    "gocv.io/x/gocv"
)

func main() {
    deviceID := 0
    webcam, err := gocv.OpenVideoCapture(deviceID)
    if err != nil {
        fmt.Printf("Error opening video capture device: %v\n", deviceID)
        return
    }

    // create the mjpeg stream
    stream := mjpeg.NewStream()

    // start capturing
    go func(webcam *gocv.VideoCapture, stream *mjpeg.Stream) {
        defer webcam.Close()

        window := gocv.NewWindow("Capture Window")
        defer window.Close()

        img := gocv.NewMat()
        defer img.Close()

        fmt.Printf("Start reading device: %v\n", deviceID)
        for {
            if ok := webcam.Read(&img); !ok {
                fmt.Printf("Device closed: %v\n", deviceID)
                return
            }
            if img.Empty() {
                continue
            }
            buf, _ := gocv.IMEncode(".jpg", img)
            stream.UpdateJPEG(buf)
            window.IMShow(img)
            if window.WaitKey(1) == 27 { // 27 => Esc
                break
            }
        }
    }(webcam, stream)

    http.Handle("/", stream)
    log.Fatal(http.ListenAndServe(":8080", nil))
}