2018-01-09 07:26:34 +03:00
|
|
|
/*
|
|
|
|
NAME
|
2019-02-04 11:44:02 +03:00
|
|
|
revid.go
|
2018-01-09 07:26:34 +03:00
|
|
|
|
|
|
|
AUTHORS
|
2018-06-07 14:50:57 +03:00
|
|
|
Saxon A. Nelson-Milton <saxon@ausocean.org>
|
|
|
|
Alan Noble <alan@ausocean.org>
|
2019-04-18 09:51:18 +03:00
|
|
|
Dan Kortschak <dan@ausocean.org>
|
2019-05-08 13:01:25 +03:00
|
|
|
Trek Hopton <trek@ausocean.org>
|
2020-01-20 10:10:45 +03:00
|
|
|
Scott Barnard <scott@ausocean.org>
|
2018-01-09 07:26:34 +03:00
|
|
|
|
|
|
|
LICENSE
|
2020-01-02 06:08:31 +03:00
|
|
|
revid is Copyright (C) 2017-2020 the Australian Ocean Lab (AusOcean)
|
2018-01-09 07:26:34 +03:00
|
|
|
|
|
|
|
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
|
2019-04-22 08:44:08 +03:00
|
|
|
for more details.
|
2018-01-09 07:26:34 +03:00
|
|
|
|
|
|
|
You should have received a copy of the GNU General Public License
|
2019-04-22 08:44:08 +03:00
|
|
|
in gpl.txt. If not, see http://www.gnu.org/licenses.
|
2018-01-09 07:26:34 +03:00
|
|
|
*/
|
|
|
|
|
2019-05-08 13:01:25 +03:00
|
|
|
// Package revid provides an API for reading, transcoding, and writing audio/video streams and files.
|
2018-01-09 07:26:34 +03:00
|
|
|
package revid
|
|
|
|
|
|
|
|
import (
|
2018-01-31 04:00:03 +03:00
|
|
|
"errors"
|
2018-10-03 15:39:51 +03:00
|
|
|
"fmt"
|
2018-01-16 08:06:51 +03:00
|
|
|
"io"
|
2019-02-01 02:17:31 +03:00
|
|
|
"sync"
|
2018-04-16 07:54:21 +03:00
|
|
|
"time"
|
2018-02-14 10:02:57 +03:00
|
|
|
|
2019-06-03 11:20:48 +03:00
|
|
|
"bitbucket.org/ausocean/av/codec/codecutil"
|
2019-04-26 14:16:43 +03:00
|
|
|
"bitbucket.org/ausocean/av/codec/h264"
|
2019-05-14 05:26:04 +03:00
|
|
|
"bitbucket.org/ausocean/av/codec/h265"
|
2019-09-24 01:12:26 +03:00
|
|
|
"bitbucket.org/ausocean/av/codec/mjpeg"
|
2019-03-25 04:21:03 +03:00
|
|
|
"bitbucket.org/ausocean/av/container/flv"
|
|
|
|
"bitbucket.org/ausocean/av/container/mts"
|
2019-11-12 08:34:07 +03:00
|
|
|
"bitbucket.org/ausocean/av/device"
|
|
|
|
"bitbucket.org/ausocean/av/device/file"
|
|
|
|
"bitbucket.org/ausocean/av/device/geovision"
|
|
|
|
"bitbucket.org/ausocean/av/device/raspivid"
|
|
|
|
"bitbucket.org/ausocean/av/device/webcam"
|
2019-12-20 03:12:51 +03:00
|
|
|
"bitbucket.org/ausocean/av/filter"
|
2019-11-06 09:57:10 +03:00
|
|
|
"bitbucket.org/ausocean/av/revid/config"
|
2018-06-26 09:23:55 +03:00
|
|
|
"bitbucket.org/ausocean/iot/pi/netsender"
|
2020-01-20 10:10:45 +03:00
|
|
|
"bitbucket.org/ausocean/utils/bitrate"
|
2019-04-08 12:32:42 +03:00
|
|
|
"bitbucket.org/ausocean/utils/ioext"
|
2019-01-02 08:09:47 +03:00
|
|
|
"bitbucket.org/ausocean/utils/logger"
|
2020-04-09 09:25:01 +03:00
|
|
|
"bitbucket.org/ausocean/utils/ring"
|
|
|
|
)
|
|
|
|
|
2020-05-19 06:07:34 +03:00
|
|
|
// Misc consts.
|
2019-05-20 13:15:59 +03:00
|
|
|
const (
|
2020-05-19 06:07:34 +03:00
|
|
|
rbStartingElementSize = 10000 // Bytes.
|
2019-11-06 09:57:10 +03:00
|
|
|
rtmpConnectionMaxTries = 5
|
2019-05-20 13:15:59 +03:00
|
|
|
)
|
|
|
|
|
2018-09-11 10:26:33 +03:00
|
|
|
type Logger interface {
|
|
|
|
SetLevel(int8)
|
|
|
|
Log(level int8, message string, params ...interface{})
|
|
|
|
}
|
|
|
|
|
2020-05-02 15:19:39 +03:00
|
|
|
type encLog struct{ Logger }
|
|
|
|
|
2020-05-03 08:38:15 +03:00
|
|
|
func (el *encLog) Debug(msg string, args ...interface{}) { el.Log(logger.Debug, msg, args...) }
|
|
|
|
func (el *encLog) Info(msg string, args ...interface{}) { el.Log(logger.Info, msg, args...) }
|
|
|
|
func (el *encLog) Warning(msg string, args ...interface{}) { el.Log(logger.Warning, msg, args...) }
|
|
|
|
func (el *encLog) Error(msg string, args ...interface{}) { el.Log(logger.Error, msg, args...) }
|
|
|
|
func (el *encLog) Fatal(msg string, args ...interface{}) { el.Log(logger.Fatal, msg, args...) }
|
2020-05-02 15:19:39 +03:00
|
|
|
|
2018-04-16 08:12:16 +03:00
|
|
|
// Revid provides methods to control a revid session; providing methods
|
2018-01-31 02:51:53 +03:00
|
|
|
// 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 {
|
2018-10-04 04:02:41 +03:00
|
|
|
// config holds the Revid configuration.
|
|
|
|
// For historical reasons it also handles logging.
|
|
|
|
// FIXME(kortschak): The relationship of concerns
|
|
|
|
// in config/ns is weird.
|
2019-11-06 09:57:10 +03:00
|
|
|
cfg config.Config
|
2019-04-15 02:12:56 +03:00
|
|
|
|
2018-10-04 04:02:41 +03:00
|
|
|
// ns holds the netsender.Sender responsible for HTTP.
|
|
|
|
ns *netsender.Sender
|
|
|
|
|
2019-11-12 08:34:07 +03:00
|
|
|
// input will capture audio or video from which we can read data.
|
|
|
|
input device.AVDevice
|
2019-05-06 08:42:05 +03:00
|
|
|
|
|
|
|
// closeInput holds the cleanup function return from setupInput and is called
|
|
|
|
// in Revid.Stop().
|
|
|
|
closeInput func() error
|
2018-10-04 04:02:41 +03:00
|
|
|
|
2018-10-19 03:50:08 +03:00
|
|
|
// lexTo, encoder and packer handle transcoding the input stream.
|
2019-06-18 10:54:32 +03:00
|
|
|
lexTo func(dest io.Writer, src io.Reader, delay time.Duration) error
|
2019-03-09 07:58:07 +03:00
|
|
|
|
2019-12-27 08:36:30 +03:00
|
|
|
// filters will hold the filter interface that will write to the chosen filter from the lexer.
|
|
|
|
filters []filter.Filter
|
2019-12-20 03:12:51 +03:00
|
|
|
|
|
|
|
// encoders will hold the multiWriteCloser that writes to encoders from the filter.
|
2019-04-18 10:25:48 +03:00
|
|
|
encoders io.WriteCloser
|
2019-04-08 12:32:42 +03:00
|
|
|
|
2019-10-01 17:14:38 +03:00
|
|
|
// running is used to keep track of revid's running state between methods.
|
|
|
|
running bool
|
|
|
|
|
|
|
|
// mu is used to protect isRunning during concurrent use.
|
|
|
|
mu sync.Mutex
|
2019-01-31 07:33:50 +03:00
|
|
|
|
2019-04-18 10:25:48 +03:00
|
|
|
// wg will be used to wait for any processing routines to finish.
|
2019-02-03 14:25:40 +03:00
|
|
|
wg sync.WaitGroup
|
|
|
|
|
2019-04-22 08:44:08 +03:00
|
|
|
// err will channel errors from revid routines to the handle errors routine.
|
2019-01-31 07:33:50 +03:00
|
|
|
err chan error
|
2020-01-20 10:10:45 +03:00
|
|
|
|
|
|
|
// bitrate is used for bitrate calculations.
|
|
|
|
bitrate bitrate.Calculator
|
2020-05-02 08:14:05 +03:00
|
|
|
|
2020-05-02 15:19:39 +03:00
|
|
|
// stop is used to signal stopping when looping an input.
|
2020-05-02 08:14:05 +03:00
|
|
|
stop chan struct{}
|
2018-01-23 06:15:06 +03:00
|
|
|
}
|
|
|
|
|
2018-08-10 07:37:54 +03:00
|
|
|
// 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.
|
2019-11-06 09:57:10 +03:00
|
|
|
func New(c config.Config, ns *netsender.Sender) (*Revid, error) {
|
2019-01-31 07:33:50 +03:00
|
|
|
r := Revid{ns: ns, err: make(chan error)}
|
2019-09-12 10:47:46 +03:00
|
|
|
err := r.setConfig(c)
|
|
|
|
if err != nil {
|
2019-12-04 06:42:20 +03:00
|
|
|
return nil, fmt.Errorf("could not set config, failed with error: %w", err)
|
2019-09-12 10:47:46 +03:00
|
|
|
}
|
2019-01-31 12:12:20 +03:00
|
|
|
go r.handleErrors()
|
|
|
|
return &r, nil
|
|
|
|
}
|
|
|
|
|
2019-04-15 04:18:12 +03:00
|
|
|
// Config returns a copy of revids current config.
|
2019-04-18 12:01:49 +03:00
|
|
|
//
|
2019-04-25 09:14:34 +03:00
|
|
|
// Config is not safe for concurrent use.
|
2019-11-06 09:57:10 +03:00
|
|
|
func (r *Revid) Config() config.Config {
|
|
|
|
return r.cfg
|
2019-04-15 04:18:12 +03:00
|
|
|
}
|
|
|
|
|
2019-10-22 15:34:33 +03:00
|
|
|
// TODO(Saxon): put more thought into error severity and how to handle these.
|
2019-01-31 12:12:20 +03:00
|
|
|
func (r *Revid) handleErrors() {
|
|
|
|
for {
|
|
|
|
err := <-r.err
|
|
|
|
if err != nil {
|
2020-03-27 17:34:02 +03:00
|
|
|
r.cfg.Logger.Log(logger.Error, "async error", "error", err.Error())
|
2019-01-31 07:33:50 +03:00
|
|
|
}
|
2019-01-31 12:12:20 +03:00
|
|
|
}
|
2018-02-10 09:59:56 +03:00
|
|
|
}
|
|
|
|
|
2018-06-27 01:20:05 +03:00
|
|
|
// Bitrate returns the result of the most recent bitrate check.
|
2018-06-17 14:27:50 +03:00
|
|
|
func (r *Revid) Bitrate() int {
|
2020-01-20 10:10:45 +03:00
|
|
|
return r.bitrate.Bitrate()
|
2019-04-15 02:12:56 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
// reset swaps the current config of a Revid with the passed
|
2019-04-15 03:55:35 +03:00
|
|
|
// configuration; checking validity and returning errors if not valid. It then
|
2019-04-18 10:25:48 +03:00
|
|
|
// sets up the data pipeline accordingly to this configuration.
|
2019-11-06 09:57:10 +03:00
|
|
|
func (r *Revid) reset(c config.Config) error {
|
2020-03-27 15:20:51 +03:00
|
|
|
r.cfg.Logger.Log(logger.Debug, "setting config")
|
2019-11-06 09:57:10 +03:00
|
|
|
err := r.setConfig(c)
|
2019-04-15 02:12:56 +03:00
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
2020-03-27 15:20:51 +03:00
|
|
|
r.cfg.Logger.Log(logger.Info, "config set")
|
2019-04-15 02:12:56 +03:00
|
|
|
|
2020-03-27 15:20:51 +03:00
|
|
|
r.cfg.Logger.Log(logger.Debug, "setting up revid pipeline")
|
2020-12-15 11:47:12 +03:00
|
|
|
|
2019-04-15 02:12:56 +03:00
|
|
|
err = r.setupPipeline(
|
2020-08-14 05:02:32 +03:00
|
|
|
func(dst io.WriteCloser, rate float64) (io.WriteCloser, error) {
|
2019-05-16 07:27:10 +03:00
|
|
|
var st int
|
2019-09-24 01:12:26 +03:00
|
|
|
var encOptions []func(*mts.Encoder) error
|
|
|
|
|
2019-11-06 09:57:10 +03:00
|
|
|
switch r.cfg.Input {
|
2020-12-15 11:47:12 +03:00
|
|
|
case config.InputRaspivid,config.InputFile, config.InputV4L,config.InputRTSP:
|
2019-11-06 09:57:10 +03:00
|
|
|
switch r.cfg.InputCodec {
|
2020-01-27 08:01:14 +03:00
|
|
|
case codecutil.H265:
|
2020-12-15 11:47:12 +03:00
|
|
|
if r.cfg.Input != config.InputRTSP {
|
|
|
|
panic("H265 codec valid only for InputRTSP")
|
|
|
|
}
|
2019-10-07 06:48:20 +03:00
|
|
|
st = mts.EncodeH265
|
2020-01-27 08:01:14 +03:00
|
|
|
case codecutil.H264:
|
2019-10-07 06:48:20 +03:00
|
|
|
st = mts.EncodeH264
|
2020-01-27 08:01:14 +03:00
|
|
|
case codecutil.MJPEG:
|
2019-10-07 06:48:20 +03:00
|
|
|
st = mts.EncodeMJPEG
|
2019-12-19 03:45:47 +03:00
|
|
|
encOptions = append(encOptions, mts.TimeBasedPSI(time.Duration(r.cfg.PSITime)*time.Second))
|
2020-01-07 03:15:45 +03:00
|
|
|
r.cfg.CBR = true
|
2019-10-12 13:24:32 +03:00
|
|
|
default:
|
2020-12-15 11:47:12 +03:00
|
|
|
panic(fmt.Sprintf("unknown input codec for Raspivid, File, V4l or RTSP input", r.cfg.InputCodec))
|
2019-10-07 06:48:20 +03:00
|
|
|
}
|
2019-11-06 09:57:10 +03:00
|
|
|
case config.InputAudio:
|
2019-06-03 11:20:48 +03:00
|
|
|
st = mts.EncodeAudio
|
2020-08-12 04:34:45 +03:00
|
|
|
encOptions = append(encOptions, mts.TimeBasedPSI(time.Duration(r.cfg.PSITime)*time.Second))
|
2020-08-14 05:02:32 +03:00
|
|
|
rate = 1 / r.cfg.RecPeriod
|
2019-10-12 13:24:32 +03:00
|
|
|
default:
|
|
|
|
panic("unknown input type")
|
2019-05-16 07:27:10 +03:00
|
|
|
}
|
2020-08-14 05:02:32 +03:00
|
|
|
encOptions = append(encOptions, mts.MediaType(st), mts.Rate(rate))
|
2020-05-06 13:40:55 +03:00
|
|
|
return mts.NewEncoder(dst, &encLog{r.cfg.Logger}, encOptions...)
|
2019-04-15 02:12:56 +03:00
|
|
|
},
|
|
|
|
func(dst io.WriteCloser, fps int) (io.WriteCloser, error) {
|
|
|
|
return flv.NewEncoder(dst, true, true, fps)
|
|
|
|
},
|
|
|
|
ioext.MultiWriteCloser,
|
|
|
|
)
|
2020-03-27 15:20:51 +03:00
|
|
|
r.cfg.Logger.Log(logger.Info, "finished setting pipeline")
|
2019-04-15 02:12:56 +03:00
|
|
|
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
|
|
|
return nil
|
2018-04-24 08:38:30 +03:00
|
|
|
}
|
|
|
|
|
2019-04-15 02:12:56 +03:00
|
|
|
// setConfig takes a config, checks it's validity and then replaces the current
|
|
|
|
// revid config.
|
2019-11-06 09:57:10 +03:00
|
|
|
func (r *Revid) setConfig(config config.Config) error {
|
|
|
|
r.cfg.Logger = config.Logger
|
2020-03-27 15:20:51 +03:00
|
|
|
r.cfg.Logger.Log(logger.Debug, "validating config")
|
2019-08-24 07:32:24 +03:00
|
|
|
err := config.Validate()
|
2018-02-10 09:59:56 +03:00
|
|
|
if err != nil {
|
2018-09-14 05:47:29 +03:00
|
|
|
return errors.New("Config struct is bad: " + err.Error())
|
2018-02-10 09:59:56 +03:00
|
|
|
}
|
2020-03-27 15:20:51 +03:00
|
|
|
r.cfg.Logger.Log(logger.Info, "config validated")
|
2019-11-06 09:57:10 +03:00
|
|
|
r.cfg = config
|
2020-04-10 18:22:02 +03:00
|
|
|
r.cfg.Logger.SetLevel(r.cfg.LogLevel)
|
2019-03-16 07:46:06 +03:00
|
|
|
return nil
|
|
|
|
}
|
2018-02-27 18:10:38 +03:00
|
|
|
|
2019-04-10 05:43:08 +03:00
|
|
|
// setupPipeline constructs the revid dataPipeline. Inputs, encoders and
|
2019-04-10 07:35:53 +03:00
|
|
|
// senders are created and linked based on the current revid config.
|
|
|
|
//
|
|
|
|
// mtsEnc and flvEnc will be called to obtain an mts encoder and flv encoder
|
|
|
|
// respectively. multiWriter will be used to create an ioext.multiWriteCloser
|
|
|
|
// so that encoders can write to multiple senders.
|
2019-06-03 12:05:28 +03:00
|
|
|
func (r *Revid) setupPipeline(mtsEnc func(dst io.WriteCloser, rate float64) (io.WriteCloser, error), flvEnc func(dst io.WriteCloser, rate int) (io.WriteCloser, error), multiWriter func(...io.WriteCloser) io.WriteCloser) error {
|
2019-04-15 02:12:56 +03:00
|
|
|
// encoders will hold the encoders that are required for revid's current
|
|
|
|
// configuration.
|
|
|
|
var encoders []io.WriteCloser
|
2019-03-16 07:46:06 +03:00
|
|
|
|
2019-03-11 19:31:43 +03:00
|
|
|
// mtsSenders will hold the senders the require MPEGTS encoding, and flvSenders
|
|
|
|
// will hold senders that require FLV encoding.
|
2019-04-08 12:32:42 +03:00
|
|
|
var mtsSenders, flvSenders []io.WriteCloser
|
2019-03-09 07:58:07 +03:00
|
|
|
|
2020-04-27 06:49:23 +03:00
|
|
|
// Calculate no. of ring buffer elements based on starting element size
|
|
|
|
// const and config directed max ring buffer size, then create buffer.
|
|
|
|
// This is only used if the selected output uses a ring buffer.
|
|
|
|
nElements := r.cfg.RBCapacity / rbStartingElementSize
|
|
|
|
writeTimeout := time.Duration(r.cfg.RBWriteTimeout) * time.Second
|
|
|
|
|
2019-03-11 19:31:43 +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-04-10 05:52:41 +03:00
|
|
|
var w io.WriteCloser
|
2019-11-06 09:57:10 +03:00
|
|
|
for _, out := range r.cfg.Outputs {
|
2019-03-09 07:58:07 +03:00
|
|
|
switch out {
|
2019-11-06 09:57:10 +03:00
|
|
|
case config.OutputHTTP:
|
2020-03-27 15:20:51 +03:00
|
|
|
r.cfg.Logger.Log(logger.Debug, "using HTTP output")
|
2020-04-27 06:49:23 +03:00
|
|
|
rb := ring.NewBuffer(rbStartingElementSize, int(nElements), writeTimeout)
|
2020-04-27 14:32:20 +03:00
|
|
|
hs := newHTTPSender(r.ns, r.cfg.Logger.Log, r.bitrate.Report)
|
|
|
|
w = newMTSSender(hs, r.cfg.Logger.Log, rb, r.cfg.ClipDuration)
|
2019-04-10 05:52:41 +03:00
|
|
|
mtsSenders = append(mtsSenders, w)
|
2020-04-27 06:49:23 +03:00
|
|
|
|
2019-11-06 09:57:10 +03:00
|
|
|
case config.OutputRTP:
|
2020-03-27 15:20:51 +03:00
|
|
|
r.cfg.Logger.Log(logger.Debug, "using RTP output")
|
2020-01-23 02:37:28 +03:00
|
|
|
w, err := newRtpSender(r.cfg.RTPAddress, r.cfg.Logger.Log, r.cfg.FrameRate, r.bitrate.Report)
|
2018-11-25 16:15:38 +03:00
|
|
|
if err != nil {
|
2020-03-27 17:34:02 +03:00
|
|
|
r.cfg.Logger.Log(logger.Warning, "rtp connect error", "error", err.Error())
|
2018-11-25 16:15:38 +03:00
|
|
|
}
|
2019-04-10 05:52:41 +03:00
|
|
|
mtsSenders = append(mtsSenders, w)
|
2019-11-06 09:57:10 +03:00
|
|
|
case config.OutputFile:
|
2020-03-27 15:20:51 +03:00
|
|
|
r.cfg.Logger.Log(logger.Debug, "using File output")
|
2019-11-06 09:57:10 +03:00
|
|
|
w, err := newFileSender(r.cfg.OutputPath)
|
2018-11-25 16:15:38 +03:00
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
2019-04-10 05:52:41 +03:00
|
|
|
mtsSenders = append(mtsSenders, w)
|
2019-11-06 09:57:10 +03:00
|
|
|
case config.OutputRTMP:
|
2020-03-27 15:20:51 +03:00
|
|
|
r.cfg.Logger.Log(logger.Debug, "using RTMP output")
|
2020-04-27 06:49:23 +03:00
|
|
|
rb := ring.NewBuffer(rbStartingElementSize, int(nElements), writeTimeout)
|
2020-05-19 06:07:34 +03:00
|
|
|
w, err := newRtmpSender(r.cfg.RTMPURL, rtmpConnectionMaxTries, rb, r.cfg.Logger.Log, r.bitrate.Report)
|
2018-11-25 16:15:38 +03:00
|
|
|
if err != nil {
|
2020-03-27 17:34:02 +03:00
|
|
|
r.cfg.Logger.Log(logger.Warning, "rtmp connect error", "error", err.Error())
|
2018-11-25 16:15:38 +03:00
|
|
|
}
|
2019-04-10 05:52:41 +03:00
|
|
|
flvSenders = append(flvSenders, w)
|
2018-11-18 06:26:29 +03:00
|
|
|
}
|
2018-02-10 09:59:56 +03:00
|
|
|
}
|
2018-02-27 18:10:38 +03:00
|
|
|
|
2019-03-11 19:31:43 +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 {
|
2019-04-02 05:51:46 +03:00
|
|
|
mw := multiWriter(mtsSenders...)
|
2020-08-14 05:02:32 +03:00
|
|
|
e, _ := mtsEnc(mw, float64(r.cfg.FrameRate))
|
2019-04-15 02:12:56 +03:00
|
|
|
encoders = append(encoders, e)
|
2019-03-09 07:58:07 +03:00
|
|
|
}
|
|
|
|
|
2019-03-11 19:31:43 +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 {
|
2019-04-02 05:51:46 +03:00
|
|
|
mw := multiWriter(flvSenders...)
|
2019-11-06 09:57:10 +03:00
|
|
|
e, err := flvEnc(mw, int(r.cfg.FrameRate))
|
2019-03-09 07:58:07 +03:00
|
|
|
if err != nil {
|
|
|
|
return err
|
2018-11-18 06:26:29 +03:00
|
|
|
}
|
2019-04-15 02:12:56 +03:00
|
|
|
encoders = append(encoders, e)
|
2018-02-10 09:59:56 +03:00
|
|
|
}
|
2018-02-27 18:10:38 +03:00
|
|
|
|
2019-04-18 10:25:48 +03:00
|
|
|
r.encoders = multiWriter(encoders...)
|
2019-04-15 02:12:56 +03:00
|
|
|
|
2019-12-27 08:36:30 +03:00
|
|
|
l := len(r.cfg.Filters)
|
|
|
|
r.filters = []filter.Filter{filter.NewNoOp(r.encoders)}
|
|
|
|
if l != 0 {
|
2020-03-27 15:20:51 +03:00
|
|
|
r.cfg.Logger.Log(logger.Debug, "setting up filters", "filters", r.cfg.Filters)
|
2019-12-27 08:36:30 +03:00
|
|
|
r.filters = make([]filter.Filter, l)
|
|
|
|
dst := r.encoders
|
|
|
|
|
|
|
|
for i := l - 1; i >= 0; i-- {
|
|
|
|
switch r.cfg.Filters[i] {
|
|
|
|
case config.FilterNoOp:
|
2020-03-27 15:20:51 +03:00
|
|
|
r.cfg.Logger.Log(logger.Debug, "using NoOp filter")
|
2019-12-27 08:36:30 +03:00
|
|
|
r.filters[i] = filter.NewNoOp(dst)
|
|
|
|
case config.FilterMOG:
|
2020-03-27 15:20:51 +03:00
|
|
|
r.cfg.Logger.Log(logger.Debug, "using MOG filter")
|
2020-02-06 02:12:12 +03:00
|
|
|
r.filters[i] = filter.NewMOG(dst, r.cfg)
|
2019-12-27 08:36:30 +03:00
|
|
|
case config.FilterVariableFPS:
|
2020-03-27 15:20:51 +03:00
|
|
|
r.cfg.Logger.Log(logger.Debug, "using Variable FPS MOG filter")
|
2020-02-06 02:12:12 +03:00
|
|
|
r.filters[i] = filter.NewVariableFPS(dst, r.cfg.MinFPS, filter.NewMOG(dst, r.cfg))
|
2019-12-27 08:36:30 +03:00
|
|
|
case config.FilterKNN:
|
2020-03-27 15:20:51 +03:00
|
|
|
r.cfg.Logger.Log(logger.Debug, "using KNN filter")
|
2020-02-06 02:12:12 +03:00
|
|
|
r.filters[i] = filter.NewKNN(dst, r.cfg)
|
2020-02-10 07:57:43 +03:00
|
|
|
case config.FilterDiff:
|
2020-03-27 15:20:51 +03:00
|
|
|
r.cfg.Logger.Log(logger.Debug, "using gocv difference filter")
|
2020-02-10 07:57:43 +03:00
|
|
|
r.filters[i] = filter.NewDiff(dst, r.cfg)
|
2020-01-24 09:31:28 +03:00
|
|
|
case config.FilterBasic:
|
2020-03-27 15:20:51 +03:00
|
|
|
r.cfg.Logger.Log(logger.Debug, "using go difference filter")
|
2020-02-06 02:12:12 +03:00
|
|
|
r.filters[i] = filter.NewBasic(dst, r.cfg)
|
2019-12-27 08:36:30 +03:00
|
|
|
default:
|
|
|
|
panic("Undefined Filter")
|
|
|
|
}
|
|
|
|
dst = r.filters[i]
|
|
|
|
}
|
2020-03-27 15:20:51 +03:00
|
|
|
r.cfg.Logger.Log(logger.Info, "filters set up")
|
2019-12-20 03:12:51 +03:00
|
|
|
}
|
|
|
|
|
2019-11-06 09:57:10 +03:00
|
|
|
switch r.cfg.Input {
|
|
|
|
case config.InputRaspivid:
|
2020-03-27 15:20:51 +03:00
|
|
|
r.cfg.Logger.Log(logger.Debug, "using raspivid input")
|
2019-11-12 08:34:07 +03:00
|
|
|
r.input = raspivid.New(r.cfg.Logger)
|
2020-03-27 15:20:51 +03:00
|
|
|
r.setLexer(r.cfg.InputCodec, false)
|
2019-11-12 08:34:07 +03:00
|
|
|
|
2019-11-06 09:57:10 +03:00
|
|
|
case config.InputV4L:
|
2020-03-27 15:20:51 +03:00
|
|
|
r.cfg.Logger.Log(logger.Debug, "using V4L input")
|
2019-11-12 08:34:07 +03:00
|
|
|
r.input = webcam.New(r.cfg.Logger)
|
2020-03-27 15:20:51 +03:00
|
|
|
r.setLexer(r.cfg.InputCodec, false)
|
2019-11-12 08:34:07 +03:00
|
|
|
|
2019-11-06 09:57:10 +03:00
|
|
|
case config.InputFile:
|
2020-03-27 15:20:51 +03:00
|
|
|
r.cfg.Logger.Log(logger.Debug, "using file input")
|
2019-11-12 08:34:07 +03:00
|
|
|
r.input = file.New()
|
2020-03-27 15:20:51 +03:00
|
|
|
r.setLexer(r.cfg.InputCodec, false)
|
2019-11-12 08:34:07 +03:00
|
|
|
|
2019-11-06 09:57:10 +03:00
|
|
|
case config.InputRTSP:
|
2020-03-27 15:20:51 +03:00
|
|
|
r.cfg.Logger.Log(logger.Debug, "using RTSP input")
|
2019-11-12 08:34:07 +03:00
|
|
|
r.input = geovision.New(r.cfg.Logger)
|
2020-03-27 15:20:51 +03:00
|
|
|
r.setLexer(r.cfg.InputCodec, true)
|
2019-11-12 08:34:07 +03:00
|
|
|
|
2019-11-06 09:57:10 +03:00
|
|
|
case config.InputAudio:
|
2020-03-27 15:20:51 +03:00
|
|
|
r.cfg.Logger.Log(logger.Debug, "using audio input")
|
2019-11-22 05:52:23 +03:00
|
|
|
err := r.setupAudio()
|
2019-11-13 12:26:13 +03:00
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
2019-11-12 08:34:07 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
// Configure the input device. We know that defaults are set, so no need to
|
|
|
|
// return error, but we should log.
|
2020-03-27 15:20:51 +03:00
|
|
|
r.cfg.Logger.Log(logger.Debug, "configuring input device")
|
2019-11-12 08:34:07 +03:00
|
|
|
err := r.input.Set(r.cfg)
|
|
|
|
if err != nil {
|
2020-03-27 17:34:02 +03:00
|
|
|
r.cfg.Logger.Log(logger.Warning, "errors from configuring input device", "errors", err)
|
2018-01-10 04:32:16 +03:00
|
|
|
}
|
2020-03-27 15:20:51 +03:00
|
|
|
r.cfg.Logger.Log(logger.Info, "input device configured")
|
2019-03-09 07:58:07 +03:00
|
|
|
|
2019-03-16 07:46:06 +03:00
|
|
|
return nil
|
|
|
|
}
|
2018-02-27 18:10:38 +03:00
|
|
|
|
2020-03-27 15:20:51 +03:00
|
|
|
// setLexer sets the revid input lexer based on input codec and whether input
|
|
|
|
// is RTSP or not, in which case an RTP/<codec> extractor is used.
|
|
|
|
func (r *Revid) setLexer(c uint8, isRTSP bool) {
|
|
|
|
switch c {
|
|
|
|
case codecutil.H264:
|
|
|
|
r.cfg.Logger.Log(logger.Debug, "using H.264 codec")
|
|
|
|
r.lexTo = h264.Lex
|
|
|
|
if isRTSP {
|
|
|
|
r.lexTo = h264.NewExtractor().Extract
|
|
|
|
}
|
|
|
|
case codecutil.H265:
|
|
|
|
r.cfg.Logger.Log(logger.Debug, "using H.265 codec")
|
2020-03-27 17:15:46 +03:00
|
|
|
r.lexTo = h265.NewExtractor(false).Extract
|
2020-03-27 15:20:51 +03:00
|
|
|
if !isRTSP {
|
|
|
|
panic("byte stream H.265 lexing not implemented")
|
|
|
|
}
|
|
|
|
case codecutil.MJPEG:
|
|
|
|
r.cfg.Logger.Log(logger.Debug, "using MJPEG codec")
|
|
|
|
r.lexTo = mjpeg.Lex
|
|
|
|
if isRTSP {
|
|
|
|
r.lexTo = mjpeg.NewExtractor().Extract
|
|
|
|
}
|
|
|
|
default:
|
|
|
|
panic("unrecognised codec")
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-06-09 05:01:21 +03:00
|
|
|
// Start invokes a Revid to start processing video from a defined input
|
2018-02-27 18:10:38 +03:00
|
|
|
// and packetising (if theres packetization) to a defined output.
|
2019-04-18 12:01:49 +03:00
|
|
|
//
|
2019-10-01 17:14:38 +03:00
|
|
|
// Start is safe for concurrent use.
|
2019-01-13 14:31:04 +03:00
|
|
|
func (r *Revid) Start() error {
|
2019-10-01 17:14:38 +03:00
|
|
|
if r.IsRunning() {
|
2020-03-27 17:34:02 +03:00
|
|
|
r.cfg.Logger.Log(logger.Warning, "start called, but revid already running")
|
2019-03-02 05:19:09 +03:00
|
|
|
return nil
|
2018-02-10 09:59:56 +03:00
|
|
|
}
|
2019-10-01 17:14:38 +03:00
|
|
|
|
|
|
|
r.mu.Lock()
|
|
|
|
defer r.mu.Unlock()
|
|
|
|
|
2020-05-02 08:14:05 +03:00
|
|
|
r.stop = make(chan struct{})
|
|
|
|
|
2020-03-27 17:34:02 +03:00
|
|
|
r.cfg.Logger.Log(logger.Debug, "resetting revid")
|
2019-11-06 09:57:10 +03:00
|
|
|
err := r.reset(r.cfg)
|
2019-09-12 10:38:22 +03:00
|
|
|
if err != nil {
|
|
|
|
r.Stop()
|
|
|
|
return err
|
|
|
|
}
|
2020-03-27 15:20:51 +03:00
|
|
|
r.cfg.Logger.Log(logger.Info, "revid reset")
|
2019-11-12 08:34:07 +03:00
|
|
|
|
2020-08-14 05:50:51 +03:00
|
|
|
// Calculate delay between frames based on FileFPS for video or
|
2020-08-13 09:55:37 +03:00
|
|
|
// between recording periods for audio.
|
2020-01-25 02:45:27 +03:00
|
|
|
d := time.Duration(0)
|
2020-08-12 04:34:45 +03:00
|
|
|
if r.cfg.Input == config.InputAudio {
|
2020-08-14 06:24:07 +03:00
|
|
|
d = time.Duration(r.cfg.RecPeriod * float64(time.Second))
|
2020-08-14 06:04:20 +03:00
|
|
|
} else if r.cfg.FileFPS != 0 {
|
2020-08-14 06:24:07 +03:00
|
|
|
d = time.Duration(1000/r.cfg.FileFPS) * time.Millisecond
|
2020-01-25 02:45:27 +03:00
|
|
|
}
|
2020-03-27 15:20:51 +03:00
|
|
|
|
|
|
|
r.cfg.Logger.Log(logger.Debug, "starting input processing routine")
|
2019-11-12 08:34:07 +03:00
|
|
|
r.wg.Add(1)
|
2020-01-24 12:35:43 +03:00
|
|
|
go r.processFrom(r.input, d)
|
2019-11-12 08:34:07 +03:00
|
|
|
|
2019-10-01 17:14:38 +03:00
|
|
|
r.running = true
|
2019-09-12 10:38:22 +03:00
|
|
|
return nil
|
2018-02-10 09:59:56 +03:00
|
|
|
}
|
|
|
|
|
2019-04-15 02:12:56 +03:00
|
|
|
// Stop closes down the pipeline. This closes encoders and sender output routines,
|
|
|
|
// connections, and/or files.
|
2019-04-18 12:01:49 +03:00
|
|
|
//
|
2019-10-01 17:14:38 +03:00
|
|
|
// Stop is safe for concurrent use.
|
2019-03-02 05:12:36 +03:00
|
|
|
func (r *Revid) Stop() {
|
2019-10-01 17:14:38 +03:00
|
|
|
if !r.IsRunning() {
|
2020-03-27 17:34:02 +03:00
|
|
|
r.cfg.Logger.Log(logger.Warning, "stop called but revid isn't running")
|
2019-03-02 05:12:36 +03:00
|
|
|
return
|
2018-03-17 16:29:42 +03:00
|
|
|
}
|
2018-05-07 05:53:50 +03:00
|
|
|
|
2019-10-01 17:14:38 +03:00
|
|
|
r.mu.Lock()
|
|
|
|
defer r.mu.Unlock()
|
|
|
|
|
2020-05-02 08:14:05 +03:00
|
|
|
close(r.stop)
|
|
|
|
|
2020-03-27 15:20:51 +03:00
|
|
|
r.cfg.Logger.Log(logger.Debug, "stopping input")
|
2019-11-12 08:34:07 +03:00
|
|
|
err := r.input.Stop()
|
|
|
|
if err != nil {
|
2020-03-27 17:34:02 +03:00
|
|
|
r.cfg.Logger.Log(logger.Error, "could not stop input", "error", err.Error())
|
2020-03-27 15:20:51 +03:00
|
|
|
} else {
|
|
|
|
r.cfg.Logger.Log(logger.Info, "input stopped")
|
2019-04-08 12:32:42 +03:00
|
|
|
}
|
2019-05-06 08:42:05 +03:00
|
|
|
|
2020-03-27 15:20:51 +03:00
|
|
|
r.cfg.Logger.Log(logger.Debug, "closing pipeline")
|
2019-11-12 08:34:07 +03:00
|
|
|
err = r.encoders.Close()
|
2019-04-15 02:12:56 +03:00
|
|
|
if err != nil {
|
2020-03-27 17:34:02 +03:00
|
|
|
r.cfg.Logger.Log(logger.Error, "failed to close pipeline", "error", err.Error())
|
2020-03-27 15:20:51 +03:00
|
|
|
} else {
|
|
|
|
r.cfg.Logger.Log(logger.Info, "pipeline closed")
|
2019-04-08 12:32:42 +03:00
|
|
|
}
|
2019-12-23 04:29:17 +03:00
|
|
|
|
2019-12-27 09:18:28 +03:00
|
|
|
for _, filter := range r.filters {
|
|
|
|
err = filter.Close()
|
|
|
|
if err != nil {
|
2020-03-27 17:34:02 +03:00
|
|
|
r.cfg.Logger.Log(logger.Error, "failed to close filters", "error", err.Error())
|
2020-03-27 15:20:51 +03:00
|
|
|
} else {
|
|
|
|
r.cfg.Logger.Log(logger.Info, "filters closed")
|
2019-12-27 09:18:28 +03:00
|
|
|
}
|
2019-12-20 08:07:49 +03:00
|
|
|
}
|
2019-12-27 09:18:28 +03:00
|
|
|
|
2020-03-27 15:20:51 +03:00
|
|
|
r.cfg.Logger.Log(logger.Debug, "waiting for routines to finish")
|
2019-04-14 04:43:17 +03:00
|
|
|
r.wg.Wait()
|
2020-03-27 15:20:51 +03:00
|
|
|
r.cfg.Logger.Log(logger.Info, "routines finished")
|
2019-10-22 15:34:33 +03:00
|
|
|
|
2019-10-01 17:14:38 +03:00
|
|
|
r.running = false
|
2020-01-30 05:50:44 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
// Burst starts revid, waits for time specified, and then stops revid.
|
2020-01-31 07:01:17 +03:00
|
|
|
func (r *Revid) Burst() error {
|
2020-03-27 15:20:51 +03:00
|
|
|
r.cfg.Logger.Log(logger.Debug, "starting revid")
|
2020-01-30 05:50:44 +03:00
|
|
|
err := r.Start()
|
|
|
|
if err != nil {
|
|
|
|
return fmt.Errorf("could not start revid: %w", err)
|
|
|
|
}
|
2020-03-27 15:20:51 +03:00
|
|
|
r.cfg.Logger.Log(logger.Info, "revid started")
|
2020-01-30 05:50:44 +03:00
|
|
|
|
2020-01-31 07:01:17 +03:00
|
|
|
dur := time.Duration(r.cfg.BurstPeriod) * time.Second
|
|
|
|
time.Sleep(dur)
|
|
|
|
|
2020-03-27 15:20:51 +03:00
|
|
|
r.cfg.Logger.Log(logger.Debug, "stopping revid")
|
2020-01-30 05:50:44 +03:00
|
|
|
r.Stop()
|
2020-03-27 15:20:51 +03:00
|
|
|
r.cfg.Logger.Log(logger.Info, "revid stopped")
|
|
|
|
|
2020-01-30 05:50:44 +03:00
|
|
|
return nil
|
2019-10-01 17:14:38 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
func (r *Revid) IsRunning() bool {
|
|
|
|
r.mu.Lock()
|
|
|
|
defer r.mu.Unlock()
|
|
|
|
return r.running
|
2018-02-10 09:59:56 +03:00
|
|
|
}
|
|
|
|
|
2019-04-15 02:12:56 +03:00
|
|
|
// Update takes a map of variables and their values and edits the current config
|
|
|
|
// if the variables are recognised as valid parameters.
|
2019-04-18 12:01:49 +03:00
|
|
|
//
|
2019-10-01 17:14:38 +03:00
|
|
|
// Update is safe for concurrent use.
|
2019-02-03 13:47:44 +03:00
|
|
|
func (r *Revid) Update(vars map[string]string) error {
|
2019-10-01 17:14:38 +03:00
|
|
|
if r.IsRunning() {
|
2020-03-27 15:20:51 +03:00
|
|
|
r.cfg.Logger.Log(logger.Debug, "revid running; stopping for re-config")
|
2019-03-02 05:19:09 +03:00
|
|
|
r.Stop()
|
2020-03-27 15:20:51 +03:00
|
|
|
r.cfg.Logger.Log(logger.Info, "revid was running; stopped for re-config")
|
2019-02-03 13:47:44 +03:00
|
|
|
}
|
2019-04-15 02:12:56 +03:00
|
|
|
|
2019-10-01 17:14:38 +03:00
|
|
|
r.mu.Lock()
|
|
|
|
defer r.mu.Unlock()
|
2019-02-03 13:47:44 +03:00
|
|
|
//look through the vars and update revid where needed
|
2020-03-27 15:20:51 +03:00
|
|
|
r.cfg.Logger.Log(logger.Debug, "checking vars from server", "vars", vars)
|
2020-05-19 09:02:02 +03:00
|
|
|
r.cfg.Update(vars)
|
2020-03-27 15:20:51 +03:00
|
|
|
r.cfg.Logger.Log(logger.Info, "finished reconfig")
|
2020-03-27 17:34:02 +03:00
|
|
|
r.cfg.Logger.Log(logger.Debug, "config changed", "config", r.cfg)
|
2019-09-12 10:38:22 +03:00
|
|
|
return nil
|
2019-02-03 13:47:44 +03:00
|
|
|
}
|
2019-11-12 08:36:04 +03:00
|
|
|
|
|
|
|
// processFrom is run as a routine to read from a input data source, lex and
|
|
|
|
// then send individual access units to revid's encoders.
|
2020-01-24 11:51:18 +03:00
|
|
|
func (r *Revid) processFrom(in device.AVDevice, delay time.Duration) {
|
2020-01-24 12:45:40 +03:00
|
|
|
defer r.wg.Done()
|
|
|
|
|
2020-01-24 13:55:27 +03:00
|
|
|
for l := true; l; l = r.cfg.Loop {
|
|
|
|
err := in.Start()
|
|
|
|
if err != nil {
|
|
|
|
r.err <- fmt.Errorf("could not start input device: %w", err)
|
|
|
|
return
|
|
|
|
}
|
2020-01-24 11:51:18 +03:00
|
|
|
|
2020-01-24 13:55:27 +03:00
|
|
|
// Lex data from input device, in, until finished or an error is encountered.
|
|
|
|
// For a continuous source e.g. a camera or microphone, we should remain
|
|
|
|
// in this call indefinitely unless in.Stop() is called and an io.EOF is forced.
|
2020-03-27 17:34:02 +03:00
|
|
|
r.cfg.Logger.Log(logger.Debug, "lexing")
|
2020-01-24 13:55:27 +03:00
|
|
|
err = r.lexTo(r.filters[0], in, delay)
|
|
|
|
switch err {
|
2020-01-25 02:12:32 +03:00
|
|
|
case nil, io.EOF:
|
2020-03-27 15:20:51 +03:00
|
|
|
r.cfg.Logger.Log(logger.Info, "end of file")
|
2020-01-25 02:12:32 +03:00
|
|
|
case io.ErrUnexpectedEOF:
|
2020-03-27 17:34:02 +03:00
|
|
|
r.cfg.Logger.Log(logger.Info, "unexpected EOF from input")
|
2020-01-24 13:55:27 +03:00
|
|
|
default:
|
|
|
|
r.err <- err
|
|
|
|
}
|
2020-03-27 15:20:51 +03:00
|
|
|
r.cfg.Logger.Log(logger.Info, "finished reading input")
|
2020-01-24 11:51:18 +03:00
|
|
|
|
2020-03-27 15:20:51 +03:00
|
|
|
r.cfg.Logger.Log(logger.Debug, "stopping input")
|
2020-01-24 13:55:27 +03:00
|
|
|
err = in.Stop()
|
|
|
|
if err != nil {
|
|
|
|
r.err <- fmt.Errorf("could not stop input source: %w", err)
|
2020-03-27 15:20:51 +03:00
|
|
|
} else {
|
|
|
|
r.cfg.Logger.Log(logger.Info, "input stopped")
|
2020-01-24 13:55:27 +03:00
|
|
|
}
|
2020-05-02 08:14:05 +03:00
|
|
|
|
|
|
|
// If we're looping and we get a stop signal we return.
|
|
|
|
select {
|
|
|
|
case <-r.stop:
|
|
|
|
return
|
|
|
|
default:
|
|
|
|
}
|
2020-01-24 11:51:18 +03:00
|
|
|
}
|
2019-11-12 08:36:04 +03:00
|
|
|
}
|