av/revid/revid.go

610 lines
16 KiB
Go
Raw Normal View History

/*
NAME
revid.go
DESCRIPTION
See Readme.md
AUTHORS
2018-06-07 14:50:57 +03:00
Saxon A. Nelson-Milton <saxon@ausocean.org>
Alan Noble <alan@ausocean.org>
LICENSE
2018-06-08 03:02:13 +03:00
revid is Copyright (C) 2017-2018 the Australian Ocean Lab (AusOcean)
It is free software: you can redistribute it and/or modify them
under the terms of the GNU General Public License as published by the
Free Software Foundation, either version 3 of the License, or (at your
option) any later version.
It is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
for more details.
You should have received a copy of the GNU General Public License
2018-06-07 14:50:57 +03:00
along with revid in gpl.txt. If not, see http://www.gnu.org/licenses.
*/
// revid is a testbed for re-muxing and re-directing video streams as MPEG-TS over various protocols.
package revid
import (
2018-01-31 04:00:03 +03:00
"errors"
"fmt"
"io"
"os"
"os/exec"
"strconv"
2018-09-19 15:32:50 +03:00
"strings"
"sync"
2018-04-16 07:54:21 +03:00
"time"
2018-02-14 10:02:57 +03:00
2018-08-20 01:19:02 +03:00
"bitbucket.org/ausocean/av/stream"
"bitbucket.org/ausocean/av/stream/flv"
"bitbucket.org/ausocean/av/stream/lex"
2018-08-20 01:19:02 +03:00
"bitbucket.org/ausocean/av/stream/mts"
"bitbucket.org/ausocean/iot/pi/netsender"
"bitbucket.org/ausocean/utils/logger"
2018-06-27 01:20:05 +03:00
"bitbucket.org/ausocean/utils/ring"
)
// Ring buffer sizes and read/write timeouts.
const (
2019-03-09 07:58:07 +03:00
ringBufferSize = 1000
ringBufferElementSize = 100000
writeTimeout = 10 * time.Millisecond
readTimeout = 10 * time.Millisecond
2018-01-10 06:57:56 +03:00
)
// RTMP connection properties.
const (
2019-01-13 09:40:17 +03:00
rtmpConnectionMaxTries = 5
rtmpConnectionTimeout = 10
)
// Duration of video for each clip sent out.
const clipDuration = 1 * time.Second
// Time duration between bitrate checks.
const bitrateTime = 1 * time.Minute
// After a send fail, this is the delay before another send.
const sendFailedDelay = 5 * time.Millisecond
const ffmpegPath = "/usr/local/bin/ffmpeg"
const pkg = "revid:"
2018-01-10 06:57:56 +03:00
type Logger interface {
SetLevel(int8)
Log(level int8, message string, params ...interface{})
}
2018-04-16 08:12:16 +03:00
// Revid provides methods to control a revid session; providing methods
// to start, stop and change the state of an instance using the Config struct.
2018-06-09 05:01:21 +03:00
type Revid struct {
// config holds the Revid configuration.
// For historical reasons it also handles logging.
// FIXME(kortschak): The relationship of concerns
// in config/ns is weird.
config Config
// ns holds the netsender.Sender responsible for HTTP.
ns *netsender.Sender
// setupInput holds the current approach to setting up
// the input stream.
setupInput func() error
// cmd is the exec'd process that may be used to produce
// the input stream.
// FIXME(kortschak): This should not exist. Replace this
// with a context.Context cancellation.
cmd *exec.Cmd
// lexTo, encoder and packer handle transcoding the input stream.
2019-03-09 07:58:07 +03:00
lexTo func(dest io.Writer, src io.Reader, delay time.Duration) error
// buffer handles passing frames from the transcoder
// to the target destination.
2019-03-09 07:58:07 +03:00
buffer *buffer
2019-03-10 04:51:53 +03:00
// encoder holds the required encoders, which then write to destinations.
2019-03-09 07:58:07 +03:00
encoder []stream.Encoder
// bitrate hold the last send bitrate calculation result.
bitrate int
mu sync.Mutex
isRunning bool
wg sync.WaitGroup
err chan error
2018-01-23 06:15:06 +03:00
}
2019-03-10 04:51:53 +03:00
// buffer is a wrapper for a ring.Buffer and provides function to write and
// flush in one Write call.
2019-03-09 07:58:07 +03:00
type buffer ring.Buffer
2019-03-10 04:51:53 +03:00
// Write implements the io.Writer interface. It will write to the underlying
// ring.Buffer and then flush to indicate a complete ring.Buffer write.
2019-03-09 07:58:07 +03:00
func (b *buffer) Write(d []byte) (int, error) {
r := (*ring.Buffer)(b)
n, err := r.Write(d)
r.Flush()
return n, err
}
// New returns a pointer to a new Revid with the desired configuration, and/or
// an error if construction of the new instance was not successful.
func New(c Config, ns *netsender.Sender) (*Revid, error) {
r := Revid{ns: ns, err: make(chan error)}
2018-06-09 05:01:21 +03:00
err := r.reset(c)
if err != nil {
2018-06-09 05:01:21 +03:00
return nil, err
}
go r.handleErrors()
return &r, nil
}
// TODO(Saxon): put more thought into error severity.
func (r *Revid) handleErrors() {
for {
err := <-r.err
if err != nil {
r.config.Logger.Log(logger.Error, pkg+"async error", "error", err.Error())
r.Stop()
err = r.Start()
if err != nil {
r.config.Logger.Log(logger.Error, pkg+"failed to restart revid", "error", err.Error())
}
}
}
}
2018-06-27 01:20:05 +03:00
// Bitrate returns the result of the most recent bitrate check.
func (r *Revid) Bitrate() int {
return r.bitrate
2018-04-24 08:38:30 +03:00
}
2018-06-09 05:01:21 +03:00
// reset swaps the current config of a Revid with the passed
// configuration; checking validity and returning errors if not valid.
2018-06-09 05:01:21 +03:00
func (r *Revid) reset(config Config) error {
r.config.Logger = config.Logger
2018-02-10 10:08:14 +03:00
err := config.Validate(r)
if err != nil {
return errors.New("Config struct is bad: " + err.Error())
}
r.config = config
2019-03-09 07:58:07 +03:00
r.buffer = (*buffer)(ring.NewBuffer(ringBufferSize, ringBufferElementSize, writeTimeout))
// mtsSenders will hold the senders the require MPEGTS encoding, and flvSenders
// will hold senders that require FLV encoding.
var mtsSenders, flvSenders []loadSender
2019-03-09 07:58:07 +03:00
// We will go through our outputs and create the corresponding senders to add
// to mtsSenders if the output requires MPEGTS encoding, or flvSenders if the
// output requires FLV encoding.
2019-03-09 07:58:07 +03:00
for _, out := range r.config.Outputs {
switch out {
case Http:
s := newMtsSender(newMinimalHttpSender(r.ns, r.config.Logger.Log), nil)
mtsSenders = append(mtsSenders, s)
2019-03-09 07:58:07 +03:00
case Rtp:
s, err := newRtpSender(r.config.RtpAddress, r.config.Logger.Log, r.config.FrameRate)
if err != nil {
return err
}
mtsSenders = append(mtsSenders, s)
2019-03-09 07:58:07 +03:00
case File:
s, err := newFileSender(r.config.OutputPath)
if err != nil {
return err
}
mtsSenders = append(mtsSenders, s)
2019-03-09 07:58:07 +03:00
case Rtmp:
s, err := newRtmpSender(r.config.RtmpUrl, rtmpConnectionTimeout, rtmpConnectionMaxTries, r.config.Logger.Log)
if err != nil {
return err
}
flvSenders = append(flvSenders, s)
2019-03-09 07:58:07 +03:00
}
}
// If we have some senders that require MPEGTS encoding then add an MPEGTS
// encoder to revid's encoder slice, and give this encoder the mtsSenders
// as a destination.
if len(mtsSenders) != 0 {
ms := newMultiSender(r, mtsSenders)
e := mts.NewEncoder(ms, float64(r.config.FrameRate))
r.encoder = append(r.encoder, e)
2019-03-09 07:58:07 +03:00
}
// If we have some senders that require FLV encoding then add an FLV
// encoder to revid's encoder slice, and give this encoder the flvSenders
// as a destination.
if len(flvSenders) != 0 {
ms := newMultiSender(r, flvSenders)
2019-03-11 19:35:36 +03:00
e, err := flv.NewEncoder(ms, true, true, int(r.config.FrameRate))
2019-03-09 07:58:07 +03:00
if err != nil {
return err
}
2019-03-11 19:35:36 +03:00
r.encoder = append(r.encoder, e)
}
switch r.config.Input {
case Raspivid:
2018-06-24 15:01:09 +03:00
r.setupInput = r.startRaspivid
case V4L:
r.setupInput = r.startV4L
case File:
r.setupInput = r.setupInputForFile
2018-01-10 04:32:16 +03:00
}
2019-03-09 07:58:07 +03:00
switch r.config.InputCodec {
case H264:
r.config.Logger.Log(logger.Info, pkg+"using H264 lexer")
r.lexTo = lex.H264
case Mjpeg:
r.config.Logger.Log(logger.Info, pkg+"using MJPEG lexer")
r.lexTo = lex.MJPEG
}
return nil
2018-01-10 04:32:16 +03:00
}
// IsRunning returns true if revid is running.
2018-06-09 05:01:21 +03:00
func (r *Revid) IsRunning() bool {
r.mu.Lock()
ret := r.isRunning
r.mu.Unlock()
return ret
}
func (r *Revid) Config() Config {
r.mu.Lock()
cfg := r.config
r.mu.Unlock()
return cfg
}
// setIsRunning sets r.isRunning using b.
func (r *Revid) setIsRunning(b bool) {
r.mu.Lock()
r.isRunning = b
r.mu.Unlock()
}
2018-06-09 05:01:21 +03:00
// Start invokes a Revid to start processing video from a defined input
// and packetising (if theres packetization) to a defined output.
func (r *Revid) Start() error {
if r.IsRunning() {
r.config.Logger.Log(logger.Warning, pkg+"start called, but revid already running")
return nil
}
r.config.Logger.Log(logger.Info, pkg+"starting Revid")
// TODO: this doesn't need to be here
r.config.Logger.Log(logger.Debug, pkg+"setting up output")
r.setIsRunning(true)
r.config.Logger.Log(logger.Info, pkg+"starting output routine")
r.wg.Add(1)
2018-05-06 11:03:44 +03:00
go r.outputClips()
r.config.Logger.Log(logger.Info, pkg+"setting up input and receiving content")
err := r.setupInput()
if err != nil {
r.Stop()
}
return err
}
// Stop halts any processing of video data from a camera or file
func (r *Revid) Stop() {
if !r.IsRunning() {
r.config.Logger.Log(logger.Warning, pkg+"stop called but revid isn't running")
return
2018-03-17 16:29:42 +03:00
}
2018-05-07 05:53:50 +03:00
r.config.Logger.Log(logger.Info, pkg+"stopping revid")
r.setIsRunning(false)
2018-05-06 10:18:17 +03:00
r.config.Logger.Log(logger.Info, pkg+"killing input proccess")
2018-04-16 07:54:21 +03:00
// If a cmd process is running, we kill!
if r.cmd != nil && r.cmd.Process != nil {
r.cmd.Process.Kill()
}
r.wg.Wait()
}
func (r *Revid) Update(vars map[string]string) error {
if r.IsRunning() {
r.Stop()
}
//look through the vars and update revid where needed
for key, value := range vars {
switch key {
case "Output":
outputs := strings.Split(value, ",")
r.config.Outputs = make([]uint8, len(outputs))
for i, output := range outputs {
switch output {
case "File":
r.config.Outputs[i] = File
case "Http":
r.config.Outputs[i] = Http
case "Rtmp":
r.config.Outputs[i] = Rtmp
case "Rtp":
r.config.Outputs[i] = Rtp
default:
r.config.Logger.Log(logger.Warning, pkg+"invalid output param", "value", value)
continue
}
}
case "RtmpUrl":
r.config.RtmpUrl = value
case "RtpAddr":
r.config.RtpAddress = value
case "Bitrate":
v, err := strconv.ParseUint(value, 10, 0)
if err != nil {
r.config.Logger.Log(logger.Warning, pkg+"invalid framerate param", "value", value)
break
}
r.config.Bitrate = uint(v)
case "OutputPath":
r.config.OutputPath = value
case "InputPath":
r.config.InputPath = value
case "Height":
h, err := strconv.ParseUint(value, 10, 0)
if err != nil {
r.config.Logger.Log(logger.Warning, pkg+"invalid height param", "value", value)
break
}
r.config.Height = uint(h)
case "Width":
w, err := strconv.ParseUint(value, 10, 0)
if err != nil {
r.config.Logger.Log(logger.Warning, pkg+"invalid width param", "value", value)
break
}
r.config.Width = uint(w)
case "FrameRate":
v, err := strconv.ParseUint(value, 10, 0)
if err != nil {
r.config.Logger.Log(logger.Warning, pkg+"invalid framerate param", "value", value)
break
}
r.config.FrameRate = uint(v)
case "Rotation":
v, err := strconv.ParseUint(value, 10, 0)
if err != nil || v > 359 {
r.config.Logger.Log(logger.Warning, pkg+"invalid rotation param", "value", value)
break
}
r.config.Rotation = uint(v)
case "HttpAddress":
r.config.HttpAddress = value
case "Quantization":
q, err := strconv.ParseUint(value, 10, 0)
if err != nil {
r.config.Logger.Log(logger.Warning, pkg+"invalid quantization param", "value", value)
break
}
r.config.Quantization = uint(q)
case "IntraRefreshPeriod":
p, err := strconv.ParseUint(value, 10, 0)
if err != nil {
r.config.Logger.Log(logger.Warning, pkg+"invalid intrarefreshperiod param", "value", value)
break
}
r.config.IntraRefreshPeriod = uint(p)
case "HorizontalFlip":
switch strings.ToLower(value) {
case "true":
r.config.FlipHorizontal = true
case "false":
r.config.FlipHorizontal = false
default:
r.config.Logger.Log(logger.Warning, pkg+"invalid HorizontalFlip param", "value", value)
}
case "VerticalFlip":
switch strings.ToLower(value) {
case "true":
r.config.FlipVertical = true
case "false":
r.config.FlipVertical = false
default:
r.config.Logger.Log(logger.Warning, pkg+"invalid VerticalFlip param", "value", value)
}
case "BurstPeriod":
v, err := strconv.ParseUint(value, 10, 0)
if err != nil {
r.config.Logger.Log(logger.Warning, pkg+"invalid BurstPeriod param", "value", value)
break
}
r.config.BurstPeriod = uint(v)
}
}
2019-02-25 11:09:01 +03:00
r.config.Logger.Log(logger.Info, pkg+"revid config changed", "config", fmt.Sprintf("%+v", r.config))
return r.reset(r.config)
}
// outputClips takes the clips produced in the packClips method and outputs them
2018-04-16 08:12:16 +03:00
// to the desired output defined in the revid config
2018-06-09 05:01:21 +03:00
func (r *Revid) outputClips() {
defer r.wg.Done()
lastTime := time.Now()
var count int
loop:
for r.IsRunning() {
// If the ring buffer has something we can read and send off
2019-03-09 07:58:07 +03:00
chunk, err := (*ring.Buffer)(r.buffer).Next(readTimeout)
switch err {
case nil:
// Do nothing.
case ring.ErrTimeout:
r.config.Logger.Log(logger.Debug, pkg+"ring buffer read timeout")
continue
default:
r.config.Logger.Log(logger.Error, pkg+"unexpected error", "error", err.Error())
fallthrough
case io.EOF:
break loop
}
2018-05-03 07:58:14 +03:00
2019-03-09 07:58:07 +03:00
// Get bytes from the chunk.
bytes := chunk.Bytes()
2019-03-09 07:58:07 +03:00
// Loop over encoders and hand bytes over to each one.
for _, enc := range r.encoder {
_, err := enc.Write(bytes)
if err != nil {
r.err <- err
}
}
// Release the chunk back to the ring buffer.
2019-03-09 07:58:07 +03:00
chunk.Close()
2019-03-09 07:58:07 +03:00
// FIXME(saxon): this doesn't work anymore.
now := time.Now()
deltaTime := now.Sub(lastTime)
2018-06-08 06:18:11 +03:00
if deltaTime > bitrateTime {
// FIXME(kortschak): For subsecond deltaTime, this will give infinite bitrate.
r.bitrate = int(float64(count*8) / float64(deltaTime/time.Second))
r.config.Logger.Log(logger.Debug, pkg+"bitrate (bits/s)", "bitrate", r.bitrate)
2019-03-09 07:58:07 +03:00
r.config.Logger.Log(logger.Debug, pkg+"ring buffer size", "value", (*ring.Buffer)(r.buffer).Len())
lastTime = now
count = 0
}
}
r.config.Logger.Log(logger.Info, pkg+"not outputting clips anymore")
}
2018-06-24 15:01:09 +03:00
// startRaspivid sets up things for input from raspivid i.e. starts
// a raspivid process and pipes it's data output.
2018-06-24 15:01:09 +03:00
func (r *Revid) startRaspivid() error {
r.config.Logger.Log(logger.Info, pkg+"starting raspivid")
const disabled = "0"
args := []string{
"--output", "-",
"--nopreview",
"--timeout", disabled,
"--width", fmt.Sprint(r.config.Width),
"--height", fmt.Sprint(r.config.Height),
"--bitrate", fmt.Sprint(r.config.Bitrate),
"--framerate", fmt.Sprint(r.config.FrameRate),
"--rotation", fmt.Sprint(r.config.Rotation),
}
if r.config.FlipVertical {
args = append(args, "--vflip")
}
if r.config.FlipHorizontal {
args = append(args, "--hflip")
}
switch r.config.InputCodec {
default:
return fmt.Errorf("revid: invalid input codec: %v", r.config.InputCodec)
case H264:
args = append(args,
"--codec", "H264",
"--inline",
"--intra", fmt.Sprint(r.config.IntraRefreshPeriod),
)
if r.config.Quantize {
args = append(args, "-qp", fmt.Sprint(r.config.Quantization))
2018-05-05 07:15:07 +03:00
}
case Mjpeg:
args = append(args, "--codec", "MJPEG")
}
r.config.Logger.Log(logger.Info, pkg+"raspivid args", "raspividArgs", strings.Join(args, " "))
r.cmd = exec.Command("raspivid", args...)
2018-06-24 15:01:09 +03:00
stdout, err := r.cmd.StdoutPipe()
if err != nil {
return err
}
err = r.cmd.Start()
if err != nil {
r.config.Logger.Log(logger.Fatal, pkg+"cannot start raspivid", "error", err.Error())
2018-06-24 15:01:09 +03:00
}
r.wg.Add(1)
go r.processFrom(stdout, 0)
return nil
}
func (r *Revid) startV4L() error {
const defaultVideo = "/dev/video0"
2019-01-03 03:55:06 +03:00
r.config.Logger.Log(logger.Info, pkg+"starting webcam")
if r.config.InputPath == "" {
r.config.Logger.Log(logger.Info, pkg+"using default video device", "device", defaultVideo)
r.config.InputPath = defaultVideo
}
args := []string{
"-i", r.config.InputPath,
"-f", "h264",
"-r", fmt.Sprint(r.config.FrameRate),
}
args = append(args,
"-b:v", fmt.Sprint(r.config.Bitrate),
"-maxrate", fmt.Sprint(r.config.Bitrate),
"-bufsize", fmt.Sprint(r.config.Bitrate/2),
"-s", fmt.Sprintf("%dx%d", r.config.Width, r.config.Height),
"-",
)
r.config.Logger.Log(logger.Info, pkg+"ffmpeg args", "args", strings.Join(args, " "))
r.cmd = exec.Command("ffmpeg", args...)
stdout, err := r.cmd.StdoutPipe()
if err != nil {
return err
}
err = r.cmd.Start()
if err != nil {
2019-01-03 03:55:06 +03:00
r.config.Logger.Log(logger.Fatal, pkg+"cannot start webcam", "error", err.Error())
return err
}
r.wg.Add(1)
go r.processFrom(stdout, time.Duration(0))
return nil
}
2018-06-24 15:01:09 +03:00
// setupInputForFile sets things up for getting input from a file
func (r *Revid) setupInputForFile() error {
f, err := os.Open(r.config.InputPath)
if err != nil {
r.config.Logger.Log(logger.Error, err.Error())
r.Stop()
return err
}
2018-06-24 15:01:09 +03:00
defer f.Close()
// TODO(kortschak): Maybe we want a context.Context-aware parser that we can stop.
r.wg.Add(1)
go r.processFrom(f, time.Second/time.Duration(r.config.FrameRate))
return nil
}
func (r *Revid) processFrom(read io.Reader, delay time.Duration) {
r.config.Logger.Log(logger.Info, pkg+"reading input data")
2019-03-09 07:58:07 +03:00
r.err <- r.lexTo(r.buffer, read, delay)
r.config.Logger.Log(logger.Info, pkg+"finished reading input data")
r.wg.Done()
}