Add new frame type and framer factory, support multiple image types. Add snapshot and imageserver.

.gitignore

@@ -0,0 +1,4 @@
+examples/getcontrols/getcontrols
+examples/http_mjpeg_streamer/http_mjpeg_streamer
+examples/stdout_streamer/stdout_streamer
+examples/imageserver/imageserver

examples/getcontrols/getcontrols.go

@@ -4,17 +4,24 @@ package main
 import (
 	"flag"
 	"fmt"
+	"sort"
 
 	"github.com/blackjack/webcam"
 )
 
 var device = flag.String("input", "/dev/video0", "Input video device")
 
+type control struct {
+	id       webcam.ControlID
+	name     string
+	min, max int32
+}
+
 func main() {
 	flag.Parse()
 	cam, err := webcam.Open(*device)
 	if err != nil {
-		panic(err.Error())
+		panic(fmt.Errorf("%s: %v", *device, err.Error()))
 	}
 	defer cam.Close()
 
@@ -34,7 +41,20 @@ func main() {
 
 	cmap := cam.GetControls()
 	fmt.Println("Available controls: ")
-	for id, c := range cmap {
-		fmt.Printf("ID:%08x %-32s  Min: %4d  Max: %5d\n", id, c.Name, c.Min, c.Max)
+	var clist []control
+	for id, cm := range cmap {
+		var c control
+		c.id = id
+		c.name = cm.Name
+		c.min = cm.Min
+		c.max = cm.Max
+		clist = append(clist, c)
+	}
+	sort.Slice(clist, func(i, j int) bool {
+		return clist[i].name < clist[j].name
+	})
+	for _, cl := range clist {
+		fmt.Printf("ID:%08x %-32s  Min: %4d  Max: %5d\n", cl.id,
+			cl.name, cl.min, cl.max)
 	}
 }

examples/http_mjpeg_streamer/webcam.go

@@ -118,7 +118,7 @@ FMT:
 	}
 
 	fmt.Fprintln(os.Stderr, "Requesting", format_desc[format], size.GetString())
-	f, w, h, err := cam.SetImageFormat(format, uint32(size.MaxWidth), uint32(size.MaxHeight))
+	f, w, h, _, _, err := cam.SetImageFormat(format, uint32(size.MaxWidth), uint32(size.MaxHeight))
 	if err != nil {
 		log.Println("SetImageFormat return error", err)
 		return

examples/imageserver/README.md

@@ -0,0 +1,2 @@
+# imageserver
+A simple web server to capture still images from a webcam.

examples/imageserver/imageserver.service

@@ -0,0 +1,16 @@
+[Unit]
+Description=webcam image server
+After=network.target
+
+[Service]
+User=root
+Type=simple
+TimeoutStopSec=10
+ExecStart=/usr/local/bin/imageserver --delay=2 --controls=focus=175,power_line_frequency=1
+
+Restart=on-failure
+RestartSec=15s
+SuccessExitStatus=SIGKILL
+
+[Install]
+WantedBy=default.target

examples/imageserver/server.go

@@ -0,0 +1,148 @@
+// Program that serves images taken from a webcam.
+package main
+
+import (
+	"flag"
+	"fmt"
+	"image/gif"
+	"image/jpeg"
+	"image/png"
+	"log"
+	"net/http"
+	"strconv"
+	"strings"
+	"time"
+
+	"github.com/blackjack/webcam"
+	"github.com/blackjack/webcam/frame"
+	"github.com/blackjack/webcam/snapshot"
+)
+
+var port = flag.Int("port", 8080, "Web server port number")
+var path = flag.String("path", "image", "Image base filename")
+var device = flag.String("input", "/dev/video0", "Input video device")
+var resolution = flag.String("resolution", "800x600", "Camera resolution")
+var format = flag.String("format", "YUYV", "Pixel format of camera")
+var controls = flag.String("controls", "",
+	"Control parameters for camera (use --controls=list to list controls)")
+var startDelay = flag.Int("delay", 2, "Delay at start (seconds)")
+var verbose = flag.Bool("v", false, "Log more information")
+
+var cnames map[string]webcam.ControlID = map[string]webcam.ControlID{
+	"focus":                0x009a090a,
+	"power_line_frequency": 0x00980918,
+	"brightness":           0x00980900,
+	"contrast":             0x00980901,
+	"autoiso":              0x009a0918,
+	"autoexp":              0x009a0901,
+	"saturation":           0x00980902,
+	"sharpness":            0x0098091b,
+	"rotate":               0x00980922,
+	"stabilization":        0x009a0916,
+}
+
+func main() {
+	flag.Parse()
+	s := strings.Split(*resolution, "x")
+	if len(s) != 2 {
+		log.Fatalf("%s: Illegal resolution", *resolution)
+	}
+	x, err := strconv.Atoi(s[0])
+	if err != nil {
+		log.Fatalf("%s: illegal width: %v", s[0], err)
+	}
+	y, err := strconv.Atoi(s[1])
+	if err != nil {
+		log.Fatalf("%s: illegal height: %v", s[1], err)
+	}
+	if *controls == "list" {
+		fmt.Printf("Control list (not all cameras may support all options):\n")
+		for c, _ := range cnames {
+			fmt.Printf("    %s\n", c)
+		}
+		return
+	}
+	if *startDelay != 0 {
+		time.Sleep(time.Duration(*startDelay) * time.Second)
+	}
+	cm := snapshot.NewSnapper()
+	if err := cm.Open(*device, frame.FourCC(*format), x, y); err != nil {
+		log.Fatalf("%s: %v", *device, err)
+	}
+	if *startDelay != 0 {
+		time.Sleep(time.Duration(*startDelay) * time.Second)
+	}
+	defer cm.Close()
+	// Set camera controls.
+	if len(*controls) != 0 {
+		for _, control := range strings.Split(*controls, ",") {
+			s := strings.Split(control, "=")
+			if len(s) != 2 {
+				log.Fatalf("Bad control option: %s", control)
+			}
+			id, ok := cnames[s[0]]
+			if !ok {
+				log.Fatalf("%s: Unknown control", s[0])
+			}
+			val, err := strconv.Atoi(s[1])
+			if err != nil {
+				log.Fatalf("Bad control value: %s (%v)", control, err)
+			}
+			if *verbose {
+				fmt.Printf("Setting control '%s' to %d\n", s[0], val)
+			}
+			if err = cm.SetControl(id, int32(val)); err != nil {
+				log.Fatalf("SetControl error: %s (%v)", control, err)
+			}
+		}
+	}
+	encodeJpeg := func(w http.ResponseWriter, f frame.Frame) error {
+		w.Header().Set("Content-Type", "image/jpeg")
+		return jpeg.Encode(w, f, nil)
+	}
+	encodePNG := func(w http.ResponseWriter, f frame.Frame) error {
+		w.Header().Set("Content-Type", "image/png")
+		return png.Encode(w, f)
+	}
+	encodeGIF := func(w http.ResponseWriter, f frame.Frame) error {
+		w.Header().Set("Content-Type", "image/gif")
+		return gif.Encode(w, f, nil)
+	}
+	http.Handle(fmt.Sprintf("/%s.jpg", *path), http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		publishImage(cm, w, r, encodeJpeg)
+	}))
+	http.Handle(fmt.Sprintf("/%s.jpeg", *path), http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		publishImage(cm, w, r, encodeJpeg)
+	}))
+	http.Handle(fmt.Sprintf("/%s.png", *path), http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		publishImage(cm, w, r, encodePNG)
+	}))
+	http.Handle(fmt.Sprintf("/%s.gif", *path), http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		publishImage(cm, w, r, encodeGIF)
+	}))
+	url := fmt.Sprintf(":%d", *port)
+	if *verbose {
+		log.Printf("Starting server on %s", url)
+	}
+	server := &http.Server{Addr: url}
+	log.Fatal(server.ListenAndServe())
+}
+
+func publishImage(cm *snapshot.Snapper, w http.ResponseWriter, r *http.Request, encode func(http.ResponseWriter, frame.Frame) error) {
+	if *verbose {
+		log.Printf("URL request: %v", r.URL)
+	}
+	f, err := cm.Snap()
+	if err != nil {
+		log.Printf("Getframe: %v", err)
+		w.WriteHeader(http.StatusInternalServerError)
+		return
+	}
+	defer f.Release()
+	if err := encode(w, f); err != nil {
+		log.Printf("Error writing image: %v\n", err)
+		w.WriteHeader(http.StatusInternalServerError)
+	} else if *verbose {
+		log.Printf("Wrote image successfully\n")
+	}
+}

examples/stdout_streamer/stdout_streamer.go

@@ -74,7 +74,7 @@ func main() {
 	choice = readChoice(fmt.Sprintf("Choose format [1-%d]: ", len(frames)))
 	size := frames[choice-1]
 
-	f, w, h, err := cam.SetImageFormat(format, uint32(size.MaxWidth), uint32(size.MaxHeight))
+	f, w, h, _, _, err := cam.SetImageFormat(format, uint32(size.MaxWidth), uint32(size.MaxHeight))
 
 	if err != nil {
 		panic(err.Error())

frame/frame.go

@@ -0,0 +1,53 @@
+// package frame wraps raw webcam frames as an image.
+package frame
+
+import (
+	"fmt"
+	"image"
+
+	"github.com/blackjack/webcam"
+)
+
+type FourCC string
+
+// Release is called when the frame is no longer in use.
+// The implementation may set a finalizer on the frame as a precaution
+// in case Release is not called (which would cause a kernel resource leak).
+type Frame interface {
+	image.Image
+	Release()
+}
+
+var framerFactoryMap = map[FourCC]func(int, int, int, int) func([]byte, func()) (Frame, error){}
+
+// RegisterFramer registers a framer factory for a format.
+// Note that only one handler can be registered for any single format.
+func RegisterFramer(format FourCC, factory func(int, int, int, int) func([]byte, func()) (Frame, error)) {
+	framerFactoryMap[format] = factory
+}
+
+// GetFramer returns a function that wraps the frame for this format.
+func GetFramer(format FourCC, w, h, stride, size int) (func([]byte, func()) (Frame, error), error) {
+	if factory, ok := framerFactoryMap[format]; ok {
+		return factory(w, h, stride, size), nil
+	}
+	return nil, fmt.Errorf("No handler for format '%s'", format)
+}
+
+// PixelFormatToFourCC converts the v4l2 PixelFormat to a FourCC.
+func PixelFormatToFourCC(pf webcam.PixelFormat) FourCC {
+	b := make([]byte, 4)
+	b[0] = byte(pf)
+	b[1] = byte(pf >> 8)
+	b[2] = byte(pf >> 16)
+	b[3] = byte(pf >> 24)
+	return FourCC(b)
+}
+
+// FourCCToPixelFormat converts the four character string to a v4l2 PixelFormat.
+func FourCCToPixelFormat(f FourCC) (webcam.PixelFormat, error) {
+	if len(f) != 4 {
+		return 0, fmt.Errorf("%s: Illegal FourCC", f)
+	}
+	return webcam.PixelFormat(uint32(f[0]) | uint32(f[1])<<8 | uint32(f[2])<<16 | uint32(f[3])<<24), nil
+}

frame/jpeg.go

@@ -0,0 +1,61 @@
+package frame
+
+import (
+	"bytes"
+	"image"
+	"image/color"
+	"image/jpeg"
+	"runtime"
+)
+
+type fJPEG struct {
+	img     image.Image
+	release func()
+}
+
+// Register this framer for this format.
+func init() {
+	RegisterFramer("JPEG", newJPEGFramer)
+}
+
+// Return a framer for JPEG.
+func newJPEGFramer(w, h, stride, size int) func([]byte, func()) (Frame, error) {
+	return jpegFramer
+}
+
+// Wrap a jpeg block in a Frame so that it can be used as an image.
+func jpegFramer(f []byte, rel func()) (Frame, error) {
+	img, err := jpeg.Decode(bytes.NewBuffer(f))
+	if err != nil {
+		if rel != nil {
+			rel()
+		}
+		return nil, err
+	}
+	fr := &fJPEG{img: img, release: rel}
+	runtime.SetFinalizer(fr, func(obj Frame) {
+		obj.Release()
+	})
+	return fr, nil
+}
+
+func (f *fJPEG) ColorModel() color.Model {
+	return f.img.ColorModel()
+}
+
+func (f *fJPEG) Bounds() image.Rectangle {
+	return f.img.Bounds()
+}
+
+func (f *fJPEG) At(x, y int) color.Color {
+	return f.img.At(x, y)
+}
+
+// Done with frame, release back to camera (if required).
+func (f *fJPEG) Release() {
+	if f.release != nil {
+		f.release()
+		// Make sure it only gets called once.
+		f.release = nil
+	}
+}