-
Notifications
You must be signed in to change notification settings - Fork 0
/
main.go
128 lines (103 loc) · 2.71 KB
/
main.go
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
package main
import (
"github.com/disintegration/gift"
"github.com/blackjack/webcam"
"os"
"fmt"
"bytes"
"image/jpeg"
"net/http"
"image"
"image/color"
"image/draw"
"log"
"strconv"
"sync"
)
var (
frameImage image.Image
frameImageMutex = &sync.Mutex{}
)
func webcamFrameGrabber() {
// ...
cam, err := webcam.Open("/dev/video0") // Open webcam
if err != nil { panic(err.Error()) }
defer cam.Close()
// ...
// Setup webcam image format and frame size here (see examples or documentation)
// ...
format_desc := cam.GetSupportedFormats()
var formats []webcam.PixelFormat
for f := range format_desc {
formats = append(formats, f)
fmt.Printf("%v\n", format_desc[f])
}
format := formats[0]
// size := cam.GetSupportedFrameSizes(format)[0]
_, _, _, err = cam.SetImageFormat(format, uint32(1920), uint32(1080))
if err != nil { panic(err.Error()) }
err = cam.StartStreaming()
if err != nil { panic(err.Error()) }
timeout := uint32(5) // 5 seconds
for {
err = cam.WaitForFrame(timeout)
switch err.(type) {
case nil:
case *webcam.Timeout:
fmt.Fprint(os.Stderr, err.Error())
continue
default:
panic(err.Error())
}
frame, err := cam.ReadFrame()
if len(frame) != 0 {
// Process frame
reader := bytes.NewReader(frame)
frameImageMutex.Lock()
frameImage, err = jpeg.Decode(reader)
frameImageMutex.Unlock()
if err == nil {
fmt.Printf("Got frame! %v, %v\n", frameImage.Bounds().Size().X, frameImage.Bounds().Size().Y)
// toimg, _ := os.Create("testing.jpg")
// jpeg.Encode(toimg, image, &jpeg.Options{jpeg.DefaultQuality})
// toimg.Close()
}
} else if err != nil {
panic(err.Error())
}
}
}
func main() {
// Start webcam frame grabbing
go webcamFrameGrabber()
http.HandleFunc("/cam/", camHandler)
err := http.ListenAndServe(":8080", nil)
if err != nil {
log.Fatal("ListenAndServe:", err)
}
}
// writeImage encodes an image 'img' in jpeg format and writes it into ResponseWriter.
func writeImage(w http.ResponseWriter, img *image.Image) {
buffer := new(bytes.Buffer)
if err := jpeg.Encode(buffer, *img, nil); err != nil {
log.Println("unable to encode image.")
}
w.Header().Set("Content-Type", "image/jpeg")
w.Header().Set("Content-Length", strconv.Itoa(len(buffer.Bytes())))
if _, err := w.Write(buffer.Bytes()); err != nil {
log.Println("unable to write image.")
}
}
func camHandler(w http.ResponseWriter, r *http.Request) {
frameImageMutex.Lock()
g := gift.New(
gift.Sobel(),
)
m := image.NewRGBA(g.Bounds(frameImage.Bounds()))
g.Draw(m, frameImage)
blue := color.RGBA{0, 0, 255, 255}
draw.Draw(m, image.Rect(0,0,100,100), &image.Uniform{blue}, image.ZP, draw.Src)
var img image.Image = m
writeImage(w, &img)
frameImageMutex.Unlock()
}