A simple Video I/O library written in Go. This library relies on FFmpeg, and FFProbe which must be downloaded before usage and added to the system path.
All frames are encoded and decoded in 8-bit RGB format.
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.
vidio.NewVideo() (*Video, error) // Create a new Video struct
FileName() string
Width() int
Height() int
Depth() int
Bitrate() int
Frames() int
Duration() float64
FPS() float64
Codec() string
AudioCodec() string
FrameBuffer() []byte
Read() bool // Read a frame of video and store it in the frame buffer
Close()
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.
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.
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()
camera, err := vidio.NewCamera(0) // Get Webcam
// Error handling...
defer camera.Close()
// Stream the webcam
for camera.Read() {
frame := camera.FrameBuffer()
// Video processing here...
}
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.
vidio.NewVideoWriter() (*VideoWriter, error) // Create a new VideoWriter struct
FileName() string
Width() int
Height() int
Bitrate() int
Loop() int
Delay() int
Macro() int
FPS() float64
Quality() float64
Codec() string
AudioCodec() string
Write(frame []byte) error // Write a frame to the video file
Close()
type Options struct {
Bitrate int // Bitrate
Loop int // For GIFs only. -1=no loop, 0=loop forever, >0=loop n times
Delay int // Delay for Final Frame of GIFs. Default -1 (Use same delay as previous frame)
Macro int // macro size for determining how to resize frames for codecs. Default 16
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=""
AudioCodec string // Codec for audio. Default aac
}
w, h, c := 1920, 1080, 3
options := vidio.Options{} // Will fill in defaults if empty
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
err := writer.Write(frame) // Write Frame to video
// Error handling...
Vidio provides some convenience functions for reading and writing to images using an array of bytes. Currently, only png
and jpeg
formats are supported.
// Read png image
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...
err := vidio.Write("output.jpg", w, h, img)
// Error handling...
Copy input.mp4
to output.mp4
. Copy the audio from input.mp4
to output.mp4
as well.
video, err := vidio.NewVideo("input.mp4")
// Error handling...
options := vidio.Options{
FPS: video.FPS(),
Bitrate: video.Bitrate(),
Audio: "input.mp4",
}
writer, err := vidio.NewVideoWriter("output.mp4", video.Width(), video.Height(), &options)
// Error handling...
defer writer.Close()
for video.Read() {
err := writer.Write(video.FrameBuffer())
// Error handling...
}
Grayscale 1000 frames of webcam stream and store in output.mp4
.
webcam, err := vidio.NewCamera(0)
// Error handling...
defer webcam.Close()
options := vidio.Options{FPS: webcam.FPS()}
writer, err := vidio.NewVideoWriter("output.mp4", webcam.Width(), webcam.Height(), &options)
// Error handling...
defer writer.Close()
count := 0
for webcam.Read() {
frame := webcam.FrameBuffer()
for i := 0; i < len(frame); i += 3 {
rgb := frame[i : i+3]
r, g, b := int(rgb[0]), int(rgb[1]), int(rgb[2])
gray := uint8((3*r + 4*g + b) / 8)
frame[i] = gray
frame[i+1] = gray
frame[i+2] = gray
}
err := writer.Write(frame)
// Error handling...
count++
if count > 1000 {
break
}
}
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.
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, err := vidio.NewVideoWriter("output.gif", w, h, &options)
// Error handling...
defer gif.Close()
for i := 1; i <= 10; i++ {
_, _, img, err := vidio.Read(strconv.Itoa(i)+".png")
// Error handling...
err := gif.Write(img)
// Error handling...
}
- Special thanks to Zulko and his blog post about using FFmpeg to process video.
- The ImageIO-FFMPEG project on GitHub.