Блог

У меня есть приведенный ниже код, который считывает 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(amp;img)
        window.IMShow(img)
        // Want to do streaming here to localhost:8080/cam
        if window.WaitKey(1) == 27 { // 27 => Esc
            break
        }
    }
}
  

Я нашел решение с помощью этого пакета, ответвления этого

 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 = "rn"  
    "--"   boundaryWord   "rn"  
    "Content-Type: image/jpegrn"  
    "Content-Length: %drn"  
    "X-Timestamp: 0.000000rn"  
    "rn"

// 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 amp;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: %vn", 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: %vn", deviceID)
        for {
            if ok := webcam.Read(amp;img); !ok {
                fmt.Printf("Device closed: %vn", 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))
}