Added error returns, removed panics

Author: AlexEidt

README.md

@@ -15,6 +15,8 @@ go get github.com/AlexEidt/Vidio
 The `Video` struct stores data about a video file you give it. The code below shows an example of sequentially reading the frames of the given video.
 
 ```go
+vidio.NewVideo() (*Video, error) // Create a new Video struct
+
 FileName() string
 Width() int
 Height() int
@@ -26,33 +28,45 @@ FPS() float64
 Codec() string
 AudioCodec() string
 FrameBuffer() []byte
+
+Read() bool // Read a frame of video and store it in the frame buffer
+Close()
 ```
 
 ```go
-video := vidio.NewVideo("input.mp4")
+video, err := vidio.NewVideo("input.mp4")
+// Error handling...
 for video.Read() {
 	// "frame" stores the video frame as a flattened RGB image in row-major order
 	frame := video.FrameBuffer() // stored as: RGBRGBRGBRGB...
 	// Video processing here...
 }
+// If all frames have been read, "video" will be closed automatically.
+// If not all frames are read, call "video.Close()" to close the video.
 ```
 
 ## `Camera`
 
 The `Camera` can read from any cameras on the device running Vidio. It takes in the stream index. On most machines the webcam device has index 0. Note that audio retrieval from the microphone is not yet supported.
 
 ```go
+vidio.NewCamera(stream int) (*Camera, error) // Create a new Camera struct
+
 Name() string
 Width() int
 Height() int
 Depth() int
 FPS() float64
 Codec() string
 FrameBuffer() []byte
+
+Read() bool // Read a frame of video and store it in the frame buffer
+Close()
 ```
 
 ```go
-camera := vidio.NewCamera(0) // Get Webcam
+camera, err := vidio.NewCamera(0) // Get Webcam
+// Error handling...
 defer camera.Close()
 
 // Stream the webcam
@@ -67,6 +81,8 @@ for camera.Read() {
 The `VideoWriter` is used to write frames to a video file. The only required parameters are the output file name, the width and height of the frames being written, and an `Options` struct. This contains all the desired properties of the new video you want to create.
 
 ```go
+vidio.NewVideoWriter() (*VideoWriter, error) // Create a new VideoWriter struct
+
 FileName() string
 Width() int
 Height() int
@@ -78,6 +94,9 @@ FPS() float64
 Quality() float64
 Codec() string
 AudioCodec() string
+
+Write(frame []byte) error // Write a frame to the video file
+Close()
 ```
 
 ```go
@@ -89,7 +108,7 @@ type Options struct {
 	FPS         float64         // Frames per second. Default 25
 	Quality     float64         // If bitrate not given, use quality instead. Must be between 0 and 1. 0:best, 1:worst
 	Codec       string          // Codec for video. Default libx264
-	Audio       string          // File path for audio for the video. If no audio, audio="".
+	Audio       string          // File path for audio for the video. If no audio, audio=""
 	AudioCodec  string          // Codec for audio. Default aac
 }
 ```
@@ -98,11 +117,13 @@ type Options struct {
 w, h, c := 1920, 1080, 3
 options := vidio.Options{} // Will fill in defaults if empty
 
-writer := vidio.NewVideoWriter("output.mp4", w, h, &options)
+writer, err := vidio.NewVideoWriter("output.mp4", w, h, &options)
+// Error handling...
 defer writer.Close()
 
 frame := make([]byte, w*h*c) // Create Frame as RGB Image and modify
-writer.Write(frame) // Write Frame to video
+err := writer.Write(frame) // Write Frame to video
+// Error handling...
 ```
 
 ## Images
@@ -111,44 +132,51 @@ Vidio provides some convenience functions for reading and writing to images usin
 
 ```go
 // Read png image
-w, h, img := vidio.Read("input.png")
+w, h, img, err := vidio.Read("input.png")
+// Error handling...
 
 // w - width of image
 // h - height of image
 // img - byte array in RGB format. RGBRGBRGBRGB...
 
-vidio.Write("output.jpg", w, h, img)
+err := vidio.Write("output.jpg", w, h, img)
+// Error handling...
 ```
 
 ## Examples
 
 Copy `input.mp4` to `output.mp4`. Copy the audio from `input.mp4` to `output.mp4` as well.
 
 ```go
-video := vidio.NewVideo("input.mp4")
+video, err := vidio.NewVideo("input.mp4")
+// Error handling...
 options := vidio.Options{
 	FPS: video.FPS(),
 	Bitrate: video.Bitrate(),
 	Audio: "input.mp4",
 }
 
-writer := vidio.NewVideoWriter("output.mp4", video.Width(), video.Height(), &options)
+writer, err := vidio.NewVideoWriter("output.mp4", video.Width(), video.Height(), &options)
+// Error handling...
 defer writer.Close()
 
 for video.Read() {
-    writer.Write(video.FrameBuffer())
+    err := writer.Write(video.FrameBuffer())
+	// Error handling...
 }
 ```
 
 Grayscale 1000 frames of webcam stream and store in `output.mp4`.
 
 ```go
-webcam := vidio.NewCamera(0)
+webcam, err := vidio.NewCamera(0)
+// Error handling...
 defer webcam.Close()
 
 options := vidio.Options{FPS: webcam.FPS()}
 
-writer := vidio.NewVideoWriter("output.mp4", webcam.Width(), webcam.Height(), &options)
+writer, err := vidio.NewVideoWriter("output.mp4", webcam.Width(), webcam.Height(), &options)
+// Error handling...
 defer writer.Close()
 
 count := 0
@@ -162,7 +190,8 @@ for webcam.Read() {
 		frame[i+1] = gray
 		frame[i+2] = gray
 	}
-	writer.Write(frame)
+	err := writer.Write(frame)
+	// Error handling...
 	count++
 	if count > 1000 {
 		break
@@ -173,16 +202,20 @@ for webcam.Read() {
 Create a gif from a series of `png` files enumerated from 1 to 10 that loops continuously with a final frame delay of 1000 centiseconds.
 
 ```go
-w, h, _ := vidio.Read("1.png") // Get frame dimensions from first image
+w, h, _, err := vidio.Read("1.png") // Get frame dimensions from first image
+// Error handling...
 
 options := vidio.Options{FPS: 1, Loop: 0, Delay: 1000}
 
-gif := vidio.NewVideoWriter("output.gif", w, h, &options)
+gif, err := vidio.NewVideoWriter("output.gif", w, h, &options)
+// Error handling...
 defer gif.Close()
 
 for i := 1; i <= 10; i++ {
-	_, _, img := vidio.Read(strconv.Itoa(i)+".png")
-	gif.Write(img)
+	_, _, img, err := vidio.Read(strconv.Itoa(i)+".png")
+	// Error handling...
+	err := gif.Write(img)
+	// Error handling...
 }
 ```
 

camera.go

@@ -1,6 +1,7 @@
 package vidio
 
 import (
+	"errors"
 	"io"
 	"os"
 	"os/exec"
@@ -52,7 +53,7 @@ func (camera *Camera) FrameBuffer() []byte {
 
 // Returns the webcam device name.
 // On windows, ffmpeg output from the -list_devices command is parsed to find the device name.
-func getDevicesWindows() []string {
+func getDevicesWindows() ([]string, error) {
 	// Run command to get list of devices.
 	cmd := exec.Command(
 		"ffmpeg",
@@ -63,10 +64,12 @@ func getDevicesWindows() []string {
 	)
 	pipe, err := cmd.StderrPipe()
 	if err != nil {
-		panic(err)
+		pipe.Close()
+		return nil, err
 	}
 	if err := cmd.Start(); err != nil {
-		panic(err)
+		cmd.Process.Kill()
+		return nil, err
 	}
 	// Read list devices from Stdout.
 	buffer := make([]byte, 2<<10)
@@ -80,28 +83,34 @@ func getDevicesWindows() []string {
 	}
 	cmd.Wait()
 	devices := parseDevices(buffer)
-	return devices
+	return devices, nil
 }
 
 // Get camera meta data such as width, height, fps and codec.
-func getCameraData(device string, camera *Camera) {
+func getCameraData(device string, camera *Camera) error {
 	// Run command to get camera data.
 	// Webcam will turn on and then off in quick succession.
+	webcamDeviceName, err := webcam()
+	if err != nil {
+		return err
+	}
 	cmd := exec.Command(
 		"ffmpeg",
 		"-hide_banner",
-		"-f", webcam(),
+		"-f", webcamDeviceName,
 		"-i", device,
 	)
 	// The command will fail since we do not give a file to write to, therefore
 	// it will write the meta data to Stderr.
 	pipe, err := cmd.StderrPipe()
 	if err != nil {
-		panic(err)
+		pipe.Close()
+		return err
 	}
 	// Start the command.
 	if err := cmd.Start(); err != nil {
-		panic(err)
+		cmd.Process.Kill()
+		return err
 	}
 	// Read ffmpeg output from Stdout.
 	buffer := make([]byte, 2<<11)
@@ -117,51 +126,61 @@ func getCameraData(device string, camera *Camera) {
 	cmd.Wait()
 
 	parseWebcamData(buffer[:total], camera)
+	return nil
 }
 
 // Creates a new camera struct that can read from the device with the given stream index.
-func NewCamera(stream int) *Camera {
+func NewCamera(stream int) (*Camera, error) {
 	// Check if ffmpeg is installed on the users machine.
-	checkExists("ffmpeg")
+	if err := checkExists("ffmpeg"); err != nil {
+		return nil, err
+	}
 
 	var device string
 	switch runtime.GOOS {
 	case "linux":
 		device = "/dev/video" + strconv.Itoa(stream)
-		break
 	case "darwin":
 		device = strconv.Itoa(stream)
-		break
 	case "windows":
 		// If OS is windows, we need to parse the listed devices to find which corresponds to the
 		// given "stream" index.
-		devices := getDevicesWindows()
+		devices, err := getDevicesWindows()
+		if err != nil {
+			return nil, err
+		}
 		if stream >= len(devices) {
-			panic("Could not find devices with index: " + strconv.Itoa(stream))
+			return nil, errors.New("Could not find device with index: " + strconv.Itoa(stream))
 		}
 		device = "video=" + devices[stream]
-		break
 	default:
-		panic("Unsupported OS: " + runtime.GOOS)
+		return nil, errors.New("Unsupported OS: " + runtime.GOOS)
 	}
 
 	camera := Camera{name: device, depth: 3}
-	getCameraData(device, &camera)
-	return &camera
+	if err := getCameraData(device, &camera); err != nil {
+		return nil, err
+	}
+	return &camera, nil
 }
 
 // Once the user calls Read() for the first time on a Camera struct,
 // the ffmpeg command which is used to read the camera device is started.
-func initCamera(camera *Camera) {
+func initCamera(camera *Camera) error {
 	// If user exits with Ctrl+C, stop ffmpeg process.
 	camera.cleanup()
 
+	webcamDeviceName, err := webcam()
+	if err != nil {
+		return err
+	}
+
 	// Use ffmpeg to pipe webcam to stdout.
 	cmd := exec.Command(
 		"ffmpeg",
 		"-hide_banner",
 		"-loglevel", "quiet",
-		"-f", webcam(),
+		"-f", webcamDeviceName,
 		"-i", camera.name,
 		"-f", "image2pipe",
 		"-pix_fmt", "rgb24",
@@ -171,21 +190,27 @@ func initCamera(camera *Camera) {
 	camera.cmd = cmd
 	pipe, err := cmd.StdoutPipe()
 	if err != nil {
-		panic(err)
+		pipe.Close()
+		return err
 	}
 
 	camera.pipe = &pipe
 	if err := cmd.Start(); err != nil {
-		panic(err)
+		cmd.Process.Kill()
+		return err
 	}
+
 	camera.framebuffer = make([]byte, camera.width*camera.height*camera.depth)
+	return nil
 }
 
 // Reads the next frame from the webcam and stores in the framebuffer.
 func (camera *Camera) Read() bool {
 	// If cmd is nil, video reading has not been initialized.
 	if camera.cmd == nil {
-		initCamera(camera)
+		if err := initCamera(camera); err != nil {
+			return false
+		}
 	}
 	total := 0
 	for total < camera.width*camera.height*camera.depth {