在对象中放大MJPEG

huangapple
go评论126阅读模式
英文:

Zooming mjpeg in object

问题

使用gocv库，我正在将图像流传输到我的HTML5页面上的object元素。

页面代码如下：

  1. <!DOCTYPE html>
  2. <html lang="en">
  3.     <head>
  4.         <title>使用gocv进行摄像头流传输</title>
  5.         <meta charset="UTF-8">
  6.         <meta name="viewport" content="width=device-width, initial-scale=1">
  7.         <link href="css/style.css" rel="stylesheet">
  8.     </head>
  9.     <body>
  10.     <!--<div id ="content"></div>-->
  11.         <object data="http://localhost:8080/camera" width="300" height="200" alt="摄像头流传输"></object>
  12.     </body>
  13.     <<script>
  14.      /*   (function(){
  15.                 document.getElementById("content").innerHTML='<object type="text/html" data="http://localhost:8080/cam" ></object>';
  16.         })();
  17.         */
  18.     </script>
  19. </html>

我的Go代码如下：

  1. // 此示例打开一个视频捕获设备，然后从中流式传输MJPEG。
  2. // 运行后，将浏览器指向命令行中传入的主机名/端口号（例如http://localhost:8080），您应该能够看到实时视频流。
  3. //
  4. // 如何运行：
  5. //
  6. // mjpeg-streamer [camera ID] [host:port]
  7. //
  8. //		go get -u github.com/hybridgroup/mjpeg
  9. // 		go run ./cmd/mjpeg-streamer/main.go 1 0.0.0.0:8080
  10. //
  12. package main
  14. import (
  15. 	"fmt"
  16. 	"log"
  17. 	"net/http"
  19. 	_ "net/http/pprof"
  20. 	"opencv/mjpeg"
  22. 	"gocv.io/x/gocv"
  23. )
  25. var (
  26. 	deviceID int
  27. 	err      error
  28. 	webcam   *gocv.VideoCapture
  29. 	stream   *mjpeg.Stream
  30. )
  32. func main() {
  33. 	/*	if len(os.Args) < 3 {
  34. 			fmt.Println("How to run:\n\tmjpeg-streamer [camera ID] [host:port]")
  35. 			return
  36. 		}
  37. 	*/
  38. 	// 解析参数
  39. 	deviceID := 0   // os.Args[1]
  40. 	host := ":8080" //os.Args[2]
  42. 	// 打开摄像头
  43. 	webcam, err = gocv.OpenVideoCapture(deviceID)
  44. 	if err != nil {
  45. 		fmt.Printf("打开捕获设备时出错：%v\n", deviceID)
  46. 		return
  47. 	}
  48. 	defer webcam.Close()
  50. 	// 创建MJPEG流
  51. 	stream = mjpeg.NewStream()
  53. 	// 开始捕获
  54. 	go mjpegCapture()
  56. 	fmt.Println("正在捕获。请将浏览器指向" + host)
  58. 	// 启动HTTP服务器
  59. 	http.Handle("/camera", stream)
  60. 	log.Fatal(http.ListenAndServe(host, nil))
  61. }
  63. func mjpegCapture() {
  64. 	img := gocv.NewMat()
  65. 	defer img.Close()
  67. 	for {
  68. 		if ok := webcam.Read(&img); !ok {
  69. 			fmt.Printf("设备已关闭：%v\n", deviceID)
  70. 			return
  71. 		}
  72. 		if img.Empty() {
  73. 			continue
  74. 		}
  76. 		buf, _ := gocv.IMEncode(".jpg", img)
  77. 		stream.UpdateJPEG(buf.GetBytes())
  78. 		buf.Close()
  79. 	}
  80. }

opencv/mjpeg中的流式传输函数如下：

  1. // 包mjpeg实现了一个简单的MJPEG流传输器。
  2. //
  3. // Stream对象实现了http.Handler接口，可以像下面这样与net/http包一起使用：
  4. //	stream = mjpeg.NewStream()
  5. //	http.Handle("/camera", stream)
  6. // 然后使用stream.UpdateJPEG()将新的JPEG帧推送到连接的客户端。
  7. package mjpeg
  9. import (
  10. 	"fmt"
  11. 	"log"
  12. 	"net/http"
  13. 	"sync"
  14. 	"time"
  15. )
  17. // Stream表示单个视频源。
  18. type Stream struct {
  19. 	m             map[chan []byte]bool
  20. 	frame         []byte
  21. 	lock          sync.Mutex
  22. 	FrameInterval time.Duration
  23. }
  25. const boundaryWord = "MJPEGBOUNDARY"
  26. const headerf = "\r\n" +
  27. 	"--" + boundaryWord + "\r\n" +
  28. 	"Content-Type: image/jpeg\r\n" +
  29. 	"Content-Length: %d\r\n" +
  30. 	"X-Timestamp: 0.000000\r\n" +
  31. 	"\r\n"
  33. // ServeHTTP使用MJPEG流响应HTTP请求，实现了http.Handler接口。
  34. func (s *Stream) ServeHTTP(w http.ResponseWriter, r *http.Request) {
  35. 	log.Println("流：", r.RemoteAddr, "已连接")
  36. 	w.Header().Add("Content-Type", "multipart/x-mixed-replace;boundary="+boundaryWord)
  38. 	c := make(chan []byte)
  39. 	s.lock.Lock()
  40. 	s.m[c] = true
  41. 	s.lock.Unlock()
  43. 	for {
  44. 		time.Sleep(s.FrameInterval)
  45. 		b := <-c
  46. 		_, err := w.Write(b)
  47. 		if err != nil {
  48. 			break
  49. 		}
  50. 	}
  52. 	s.lock.Lock()
  53. 	delete(s.m, c)
  54. 	s.lock.Unlock()
  55. 	log.Println("流：", r.RemoteAddr, "已断开连接")
  56. }
  58. // UpdateJPEG将新的JPEG帧推送到客户端。
  59. func (s *Stream) UpdateJPEG(jpeg []byte) {
  60. 	header := fmt.Sprintf(headerf, len(jpeg))
  61. 	if len(s.frame) < len(jpeg)+len(header) {
  62. 		s.frame = make([]byte, (len(jpeg)+len(header))*2)
  63. 	}
  65. 	copy(s.frame, header)
  66. 	copy(s.frame[len(header):], jpeg)
  68. 	s.lock.Lock()
  69. 	for c := range s.m {
  70. 		// 选择跳过正在休眠以丢弃帧的流。
  71. 		// 这可能需要更多的思考。
  72. 		select {
  73. 		case c <- s.frame:
  74. 		default:
  75. 		}
  76. 	}
  77. 	s.lock.Unlock()
  78. }
  80. // NewStream初始化并返回一个新的Stream。
  81. func NewStream() *Stream {
  82. 	return &Stream{
  83. 		m:             make(map[chan []byte]bool),
  84. 		frame:         make([]byte, len(headerf)),
  85. 		FrameInterval: 50 * time.Millisecond,
  86. 	}
  87. }

我的输出如下：

在对象中放大MJPEG

我的问题是：

  1. 如何将流式传输的图像适应所选的object元素尺寸？
  2. 是否有办法将其流式传输到video元素？我尝试过但失败了。
英文:

Using gocv I'm streaming an image to an object element at my html5 page.

The page is:

  1. &lt;!DOCTYPE html&gt;
  2. &lt;html lang=&quot;en&quot;&gt;
  3. &lt;head&gt;
  4. &lt;title&gt;Cam Streaming with gocv&lt;/title&gt;
  5. &lt;meta charset=&quot;UTF-8&quot;&gt;
  6. &lt;meta name=&quot;viewport&quot; content=&quot;width=device-width, initial-scale=1&quot;&gt;
  7. &lt;link href=&quot;css/style.css&quot; rel=&quot;stylesheet&quot;&gt;
  8. &lt;/head&gt;
  9. &lt;body&gt;
  10. &lt;!-- &lt;div id =&quot;content&quot;&gt;&lt;/div&gt; --&gt;
  11. &lt;object data=&quot;http://localhost:8080/camera&quot; width=&quot;300&quot; height=&quot;200&quot; alt=&quot;Cam streaming&quot;&gt;&lt;/object&gt;
  12. &lt;/body&gt;
  13. &lt;&lt;script&gt;
  14. /*   (function(){
  15. document.getElementById(&quot;content&quot;).innerHTML=&#39;&lt;object type=&quot;text/html&quot; data=&quot;http://localhost:8080/cam&quot; &gt;&lt;/object&gt;&#39;;
  16. })();
  17. */
  18. &lt;/script&gt;
  19. &lt;/html&gt;

Ang my go code is:

  1. // This example opens a video capture device, then streams MJPEG from it.
  2. // Once running point your browser to the hostname/port you passed in the
  3. // command line (for example http://localhost:8080) and you should see
  4. // the live video stream.
  5. //
  6. // How to run:
  7. //
  8. // mjpeg-streamer [camera ID] [host:port]
  9. //
  10. //		go get -u github.com/hybridgroup/mjpeg
  11. // 		go run ./cmd/mjpeg-streamer/main.go 1 0.0.0.0:8080
  12. //
  14. package main
  16. import (
  17. 	&quot;fmt&quot;
  18. 	&quot;log&quot;
  19. 	&quot;net/http&quot;
  21. 	_ &quot;net/http/pprof&quot;
  22. 	&quot;opencv/mjpeg&quot;
  24. 	&quot;gocv.io/x/gocv&quot;
  25. )
  27. var (
  28. 	deviceID int
  29. 	err      error
  30. 	webcam   *gocv.VideoCapture
  31. 	stream   *mjpeg.Stream
  32. )
  34. func main() {
  35. 	/*	if len(os.Args) &lt; 3 {
  36. 			fmt.Println(&quot;How to run:\n\tmjpeg-streamer [camera ID] [host:port]&quot;)
  37. 			return
  38. 		}
  39. 	*/
  40. 	// parse args
  41. 	deviceID := 0   // os.Args[1]
  42. 	host := &quot;:8080&quot; //os.Args[2]
  44. 	// open webcam
  45. 	webcam, err = gocv.OpenVideoCapture(deviceID)
  46. 	if err != nil {
  47. 		fmt.Printf(&quot;Error opening capture device: %v\n&quot;, deviceID)
  48. 		return
  49. 	}
  50. 	defer webcam.Close()
  52. 	// create the mjpeg stream
  53. 	stream = mjpeg.NewStream()
  55. 	// start capturing
  56. 	go mjpegCapture()
  58. 	fmt.Println(&quot;Capturing. Point your browser to &quot; + host)
  60. 	// start http server
  61. 	http.Handle(&quot;/camera&quot;, stream)
  62. 	log.Fatal(http.ListenAndServe(host, nil))
  63. }
  65. func mjpegCapture() {
  66. 	img := gocv.NewMat()
  67. 	defer img.Close()
  69. 	for {
  70. 		if ok := webcam.Read(&amp;img); !ok {
  71. 			fmt.Printf(&quot;Device closed: %v\n&quot;, deviceID)
  72. 			return
  73. 		}
  74. 		if img.Empty() {
  75. 			continue
  76. 		}
  78. 		buf, _ := gocv.IMEncode(&quot;.jpg&quot;, img)
  79. 		stream.UpdateJPEG(buf.GetBytes())
  80. 		buf.Close()
  81. 	}
  82. }

The streaming function at opencv/mjpeg is:

  1. // Package mjpeg implements a simple MJPEG streamer.
  2. //
  3. // Stream objects implement the http.Handler interface, allowing to use them with the net/http package like so:
  4. //	stream = mjpeg.NewStream()
  5. //	http.Handle(&quot;/camera&quot;, stream)
  6. // Then push new JPEG frames to the connected clients using stream.UpdateJPEG().
  7. package mjpeg
  9. import (
  10. 	&quot;fmt&quot;
  11. 	&quot;log&quot;
  12. 	&quot;net/http&quot;
  13. 	&quot;sync&quot;
  14. 	&quot;time&quot;
  15. )
  17. // Stream represents a single video feed.
  18. type Stream struct {
  19. 	m             map[chan []byte]bool
  20. 	frame         []byte
  21. 	lock          sync.Mutex
  22. 	FrameInterval time.Duration
  23. }
  25. const boundaryWord = &quot;MJPEGBOUNDARY&quot;
  26. const headerf = &quot;\r\n&quot; +
  27. 	&quot;--&quot; + boundaryWord + &quot;\r\n&quot; +
  28. 	&quot;Content-Type: image/jpeg\r\n&quot; +
  29. 	&quot;Content-Length: %d\r\n&quot; +
  30. 	&quot;X-Timestamp: 0.000000\r\n&quot; +
  31. 	&quot;\r\n&quot;
  33. // ServeHTTP responds to HTTP requests with the MJPEG stream, implementing the http.Handler interface.
  34. func (s *Stream) ServeHTTP(w http.ResponseWriter, r *http.Request) {
  35. 	log.Println(&quot;Stream:&quot;, r.RemoteAddr, &quot;connected&quot;)
  36. 	w.Header().Add(&quot;Content-Type&quot;, &quot;multipart/x-mixed-replace;boundary=&quot;+boundaryWord)
  38. 	c := make(chan []byte)
  39. 	s.lock.Lock()
  40. 	s.m[c] = true
  41. 	s.lock.Unlock()
  43. 	for {
  44. 		time.Sleep(s.FrameInterval)
  45. 		b := &lt;-c
  46. 		_, err := w.Write(b)
  47. 		if err != nil {
  48. 			break
  49. 		}
  50. 	}
  52. 	s.lock.Lock()
  53. 	delete(s.m, c)
  54. 	s.lock.Unlock()
  55. 	log.Println(&quot;Stream:&quot;, r.RemoteAddr, &quot;disconnected&quot;)
  56. }
  58. // UpdateJPEG pushes a new JPEG frame onto the clients.
  59. func (s *Stream) UpdateJPEG(jpeg []byte) {
  60. 	header := fmt.Sprintf(headerf, len(jpeg))
  61. 	if len(s.frame) &lt; len(jpeg)+len(header) {
  62. 		s.frame = make([]byte, (len(jpeg)+len(header))*2)
  63. 	}
  65. 	copy(s.frame, header)
  66. 	copy(s.frame[len(header):], jpeg)
  68. 	s.lock.Lock()
  69. 	for c := range s.m {
  70. 		// Select to skip streams which are sleeping to drop frames.
  71. 		// This might need more thought.
  72. 		select {
  73. 		case c &lt;- s.frame:
  74. 		default:
  75. 		}
  76. 	}
  77. 	s.lock.Unlock()
  78. }
  80. // NewStream initializes and returns a new Stream.
  81. func NewStream() *Stream {
  82. 	return &amp;Stream{
  83. 		m:             make(map[chan []byte]bool),
  84. 		frame:         make([]byte, len(headerf)),
  85. 		FrameInterval: 50 * time.Millisecond,
  86. 	}
  87. }

My output is as below:

在对象中放大MJPEG

My question is:

  1. How can I fit the streamed image into the selected object dimensions
  2. Is there a way to stream it to video element, I tried but failed.

答案1

得分: 0

我在go代码中找到了一个答案，它使用以下方式进行图像调整大小：

  1. "image/jpeg"
  2. "golang.org/x/image/draw"

代码如下：

  1. 	// 解码图像（从PNG到image.Image）：
  2. 	src, _ := j.Decode(bytes.NewReader(jpeg))
  4. 	// 设置所需的大小：
  5. 	dst := image.NewRGBA(image.Rect(0, 0, src.Bounds().Max.X/3, src.Bounds().Max.Y/3))
  7. 	// 调整大小：
  8. 	draw.NearestNeighbor.Scale(dst, dst.Rect, src, src.Bounds(), draw.Over, nil)
  10. 	buf := new(bytes.Buffer)
  12. 	// 编码到`buf`：
  13. 	j.Encode(buf, dst, nil)
  15. 	copy(s.frame, header)
  16. 	//	copy(s.frame[len(header):], jpeg)
  17. 	copy(s.frame[len(header):], buf.Bytes())

因此，我的完整流式代码如下：

  1. // Package mjpeg implements a simple MJPEG streamer.
  2. //
  3. // Stream objects implement the http.Handler interface, allowing to use them with the net/http package like so:
  4. //	stream = mjpeg.NewStream()
  5. //	http.Handle("/camera", stream)
  6. // Then push new JPEG frames to the connected clients using stream.UpdateJPEG().
  7. package mjpeg
  9. import (
  10. 	"bytes"
  11. 	"fmt"
  12. 	"image"
  13. 	j "image/jpeg"
  14. 	"log"
  15. 	"net/http"
  16. 	"sync"
  17. 	"time"
  19. 	"golang.org/x/image/draw"
  20. )
  22. // Stream represents a single video feed.
  23. type Stream struct {
  24. 	m             map[chan []byte]bool
  25. 	frame         []byte
  26. 	lock          sync.Mutex
  27. 	FrameInterval time.Duration
  28. }
  30. const boundaryWord = "MJPEGBOUNDARY"
  31. const headerf = "\r\n" +
  32. 	"--" + boundaryWord + "\r\n" +
  33. 	"Content-Type: image/jpeg\r\n" +
  34. 	"Content-Length: %d\r\n" +
  35. 	"X-Timestamp: 0.000000\r\n" +
  36. 	"\r\n"
  38. // ServeHTTP responds to HTTP requests with the MJPEG stream, implementing the http.Handler interface.
  39. func (s *Stream) ServeHTTP(w http.ResponseWriter, r *http.Request) {
  40. 	log.Println("Stream:", r.RemoteAddr, "connected")
  41. 	w.Header().Add("Content-Type", "multipart/x-mixed-replace;boundary="+boundaryWord)
  43. 	c := make(chan []byte)
  44. 	s.lock.Lock()
  45. 	s.m[c] = true
  46. 	s.lock.Unlock()
  48. 	for {
  49. 		time.Sleep(s.FrameInterval)
  50. 		b := <-c
  51. 		_, err := w.Write(b)
  52. 		if err != nil {
  53. 			break
  54. 		}
  55. 	}
  57. 	s.lock.Lock()
  58. 	delete(s.m, c)
  59. 	s.lock.Unlock()
  60. 	log.Println("Stream:", r.RemoteAddr, "disconnected")
  61. }
  63. // UpdateJPEG pushes a new JPEG frame onto the clients.
  64. func (s *Stream) UpdateJPEG(jpeg []byte) {
  65. 	header := fmt.Sprintf(headerf, len(jpeg))
  66. 	if len(s.frame) < len(jpeg)+len(header) {
  67. 		s.frame = make([]byte, (len(jpeg)+len(header))*2)
  68. 	}
  70. 	// 解码图像（从PNG到image.Image）：
  71. 	src, _ := j.Decode(bytes.NewReader(jpeg))
  73. 	// 设置所需的大小：
  74. 	dst := image.NewRGBA(image.Rect(0, 0, src.Bounds().Max.X/3, src.Bounds().Max.Y/3))
  76. 	// 调整大小：
  77. 	draw.NearestNeighbor.Scale(dst, dst.Rect, src, src.Bounds(), draw.Over, nil)
  79. 	buf := new(bytes.Buffer)
  81. 	// 编码到`buf`：
  82. 	j.Encode(buf, dst, nil)
  84. 	copy(s.frame, header)
  85. 	//	copy(s.frame[len(header):], jpeg)
  86. 	copy(s.frame[len(header):], buf.Bytes())
  88. 	s.lock.Lock()
  89. 	for c := range s.m {
  90. 		// 选择跳过正在休眠以丢弃帧的流。
  91. 		// 这可能需要更多的思考。
  92. 		select {
  93. 		case c <- s.frame:
  94. 		default:
  95. 		}
  96. 	}
  97. 	s.lock.Unlock()
  98. }
  100. // NewStream initializes and returns a new Stream.
  101. func NewStream() *Stream {
  102. 	return &Stream{
  103. 		m:             make(map[chan []byte]bool),
  104. 		frame:         make([]byte, len(headerf)),
  105. 		FrameInterval: 50 * time.Millisecond,
  106. 	}
  107. }

我的输出如下：

在对象中放大MJPEG

英文:

I found the an answer in the go code, that is doing image resizing using:

  1. &quot;image/jpeg&quot;
  2. &quot;golang.org/x/image/draw&quot;

As:

  1. 	// Decode the image (from PNG to image.Image):
  2. 	src, _ := j.Decode(bytes.NewReader(jpeg))
  4. 	// Set the expected size that you want:
  5. 	dst := image.NewRGBA(image.Rect(0, 0, src.Bounds().Max.X/3, src.Bounds().Max.Y/3))
  7. 	// Resize:
  8. 	draw.NearestNeighbor.Scale(dst, dst.Rect, src, src.Bounds(), draw.Over, nil)
  10. 	buf := new(bytes.Buffer)
  12. 	// Encode to `buf`:
  13. 	j.Encode(buf, dst, nil)
  15. 	copy(s.frame, header)
  16. 	//	copy(s.frame[len(header):], jpeg)
  17. 	copy(s.frame[len(header):], buf.Bytes())

So, my streaming full code became:

  1. // Package mjpeg implements a simple MJPEG streamer.
  2. //
  3. // Stream objects implement the http.Handler interface, allowing to use them with the net/http package like so:
  4. //	stream = mjpeg.NewStream()
  5. //	http.Handle(&quot;/camera&quot;, stream)
  6. // Then push new JPEG frames to the connected clients using stream.UpdateJPEG().
  7. package mjpeg
  9. import (
  10. 	&quot;bytes&quot;
  11. 	&quot;fmt&quot;
  12. 	&quot;image&quot;
  13. 	j &quot;image/jpeg&quot;
  14. 	&quot;log&quot;
  15. 	&quot;net/http&quot;
  16. 	&quot;sync&quot;
  17. 	&quot;time&quot;
  19. 	&quot;golang.org/x/image/draw&quot;
  20. )
  22. // Stream represents a single video feed.
  23. type Stream struct {
  24. 	m             map[chan []byte]bool
  25. 	frame         []byte
  26. 	lock          sync.Mutex
  27. 	FrameInterval time.Duration
  28. }
  30. const boundaryWord = &quot;MJPEGBOUNDARY&quot;
  31. const headerf = &quot;\r\n&quot; +
  32. 	&quot;--&quot; + boundaryWord + &quot;\r\n&quot; +
  33. 	&quot;Content-Type: image/jpeg\r\n&quot; +
  34. 	&quot;Content-Length: %d\r\n&quot; +
  35. 	&quot;X-Timestamp: 0.000000\r\n&quot; +
  36. 	&quot;\r\n&quot;
  38. // ServeHTTP responds to HTTP requests with the MJPEG stream, implementing the http.Handler interface.
  39. func (s *Stream) ServeHTTP(w http.ResponseWriter, r *http.Request) {
  40. 	log.Println(&quot;Stream:&quot;, r.RemoteAddr, &quot;connected&quot;)
  41. 	w.Header().Add(&quot;Content-Type&quot;, &quot;multipart/x-mixed-replace;boundary=&quot;+boundaryWord)
  43. 	c := make(chan []byte)
  44. 	s.lock.Lock()
  45. 	s.m[c] = true
  46. 	s.lock.Unlock()
  48. 	for {
  49. 		time.Sleep(s.FrameInterval)
  50. 		b := &lt;-c
  51. 		_, err := w.Write(b)
  52. 		if err != nil {
  53. 			break
  54. 		}
  55. 	}
  57. 	s.lock.Lock()
  58. 	delete(s.m, c)
  59. 	s.lock.Unlock()
  60. 	log.Println(&quot;Stream:&quot;, r.RemoteAddr, &quot;disconnected&quot;)
  61. }
  63. // UpdateJPEG pushes a new JPEG frame onto the clients.
  64. func (s *Stream) UpdateJPEG(jpeg []byte) {
  65. 	header := fmt.Sprintf(headerf, len(jpeg))
  66. 	if len(s.frame) &lt; len(jpeg)+len(header) {
  67. 		s.frame = make([]byte, (len(jpeg)+len(header))*2)
  68. 	}
  70. 	// Decode the image (from PNG to image.Image):
  71. 	src, _ := j.Decode(bytes.NewReader(jpeg))
  73. 	// Set the expected size that you want:
  74. 	dst := image.NewRGBA(image.Rect(0, 0, src.Bounds().Max.X/3, src.Bounds().Max.Y/3))
  76. 	// Resize:
  77. 	draw.NearestNeighbor.Scale(dst, dst.Rect, src, src.Bounds(), draw.Over, nil)
  79. 	buf := new(bytes.Buffer)
  81. 	// Encode to `buf`:
  82. 	j.Encode(buf, dst, nil)
  84. 	copy(s.frame, header)
  85. 	//	copy(s.frame[len(header):], jpeg)
  86. 	copy(s.frame[len(header):], buf.Bytes())
  88. 	s.lock.Lock()
  89. 	for c := range s.m {
  90. 		// Select to skip streams which are sleeping to drop frames.
  91. 		// This might need more thought.
  92. 		select {
  93. 		case c &lt;- s.frame:
  94. 		default:
  95. 		}
  96. 	}
  97. 	s.lock.Unlock()
  98. }
  100. // NewStream initializes and returns a new Stream.
  101. func NewStream() *Stream {
  102. 	return &amp;Stream{
  103. 		m:             make(map[chan []byte]bool),
  104. 		frame:         make([]byte, len(headerf)),
  105. 		FrameInterval: 50 * time.Millisecond,
  106. 	}
  107. }

Any my output became:

在对象中放大MJPEG

huangapple
  • 本文由 发表于 2022年6月11日 18:42:17
  • 转载请务必保留本文链接：https://go.coder-hub.com/72583642.html
  • css
  • go
  • html
  • html5-video
  • javascript
匿名

发表评论

匿名网友

:?: :razz: :sad: :evil: :!: :smile: :oops: :grin: :eek: :shock: :???: :cool: :lol: :mad: :twisted: :roll: :wink: :idea: :arrow: :neutral: :cry: :mrgreen:

确定