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>
|
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"
|
2018-01-09 07:26:34 +03:00
|
|
|
"os/exec"
|
|
|
|
"strconv"
|
2018-09-19 15:32:50 +03:00
|
|
|
"strings"
|
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"
|
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-01-08 15:20:29 +03:00
|
|
|
"bitbucket.org/ausocean/utils/vring"
|
2019-01-13 09:47:35 +03:00
|
|
|
)
|
|
|
|
|
2019-11-06 09:57:10 +03:00
|
|
|
// RTMP connection properties.
|
2019-05-20 13:15:59 +03:00
|
|
|
const (
|
2019-11-06 09:57:10 +03:00
|
|
|
rtmpConnectionMaxTries = 5
|
|
|
|
rtmpConnectionTimeout = 10
|
2019-05-20 13:15:59 +03:00
|
|
|
)
|
|
|
|
|
2019-10-23 05:18:22 +03:00
|
|
|
const pkg = "revid: "
|
2018-01-10 06:57:56 +03:00
|
|
|
|
2018-09-11 10:26:33 +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
|
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
|
|
|
|
|
|
|
// 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
|
|
|
|
|
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
|
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-11-06 09:57:10 +03:00
|
|
|
r.cfg.Logger.SetLevel(c.LogLevel)
|
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 {
|
2019-11-06 09:57:10 +03:00
|
|
|
r.cfg.Logger.Log(logger.Error, pkg+"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.
|
2019-04-15 02:12:56 +03:00
|
|
|
//
|
|
|
|
// TODO: get this working again.
|
2018-06-17 14:27:50 +03:00
|
|
|
func (r *Revid) Bitrate() int {
|
2019-04-15 02:12:56 +03:00
|
|
|
return -1
|
|
|
|
}
|
|
|
|
|
|
|
|
// 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 {
|
|
|
|
err := r.setConfig(c)
|
2019-04-15 02:12:56 +03:00
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
2019-11-06 09:57:10 +03:00
|
|
|
r.cfg.Logger.SetLevel(c.LogLevel)
|
2019-05-05 13:09:56 +03:00
|
|
|
|
2019-04-15 02:12:56 +03:00
|
|
|
err = r.setupPipeline(
|
2019-06-03 12:05:28 +03:00
|
|
|
func(dst io.WriteCloser, fps 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 {
|
|
|
|
case config.InputRaspivid:
|
|
|
|
switch r.cfg.InputCodec {
|
2019-09-24 11:05:17 +03:00
|
|
|
case codecutil.H264:
|
2019-09-24 01:12:26 +03:00
|
|
|
st = mts.EncodeH264
|
2019-09-24 11:05:17 +03:00
|
|
|
case codecutil.MJPEG:
|
2019-09-24 01:12:26 +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:
|
|
|
|
panic("unknown input codec for raspivid input")
|
2019-09-24 01:12:26 +03:00
|
|
|
}
|
2019-11-06 09:57:10 +03:00
|
|
|
case config.InputFile, config.InputV4L:
|
2019-12-04 04:10:12 +03:00
|
|
|
switch r.cfg.InputCodec {
|
|
|
|
case codecutil.H264:
|
|
|
|
st = mts.EncodeH264
|
|
|
|
case codecutil.MJPEG:
|
|
|
|
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-03 09:17:38 +03:00
|
|
|
r.cfg.CBR = true
|
2019-12-04 04:10:12 +03:00
|
|
|
default:
|
|
|
|
panic("unknown input codec for v4l or input file input")
|
|
|
|
}
|
2019-11-06 09:57:10 +03:00
|
|
|
case config.InputRTSP:
|
|
|
|
switch r.cfg.InputCodec {
|
2019-10-07 06:48:20 +03:00
|
|
|
case codecutil.H265:
|
|
|
|
st = mts.EncodeH265
|
|
|
|
case codecutil.H264:
|
|
|
|
st = mts.EncodeH264
|
|
|
|
case codecutil.MJPEG:
|
|
|
|
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:
|
|
|
|
panic("unknown input codec for RTSP input")
|
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
|
2019-10-12 13:24:32 +03:00
|
|
|
default:
|
|
|
|
panic("unknown input type")
|
2019-05-16 07:27:10 +03:00
|
|
|
}
|
2019-09-24 01:12:26 +03:00
|
|
|
|
|
|
|
return mts.NewEncoder(dst, float64(fps), st, 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,
|
|
|
|
)
|
|
|
|
|
|
|
|
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
|
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
|
|
|
}
|
2019-11-06 09:57:10 +03:00
|
|
|
r.cfg = config
|
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
|
|
|
|
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-01-09 06:28:44 +03:00
|
|
|
rb, err := vring.NewBuffer(r.cfg.RBMaxElements, r.cfg.RBCapacity, time.Duration(r.cfg.RBWriteTimeout)*time.Second)
|
2020-01-08 15:20:29 +03:00
|
|
|
if err != nil {
|
|
|
|
return fmt.Errorf("could not initialise MTS ring buffer: %w", err)
|
|
|
|
}
|
2019-08-08 06:50:02 +03:00
|
|
|
w = newMtsSender(
|
2019-11-06 09:57:10 +03:00
|
|
|
newHttpSender(r.ns, r.cfg.Logger.Log),
|
|
|
|
r.cfg.Logger.Log,
|
2020-01-08 15:20:29 +03:00
|
|
|
rb,
|
2019-11-06 09:57:10 +03:00
|
|
|
r.cfg.ClipDuration,
|
2019-08-08 06:50:02 +03:00
|
|
|
)
|
2019-04-10 05:52:41 +03:00
|
|
|
mtsSenders = append(mtsSenders, w)
|
2019-11-06 09:57:10 +03:00
|
|
|
case config.OutputRTP:
|
|
|
|
w, err := newRtpSender(r.cfg.RTPAddress, r.cfg.Logger.Log, r.cfg.FrameRate)
|
2018-11-25 16:15:38 +03:00
|
|
|
if err != nil {
|
2019-11-06 09:57:10 +03:00
|
|
|
r.cfg.Logger.Log(logger.Warning, pkg+"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:
|
|
|
|
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-01-09 06:28:44 +03:00
|
|
|
rb, err := vring.NewBuffer(r.cfg.RBMaxElements, r.cfg.RBCapacity, time.Duration(r.cfg.RBWriteTimeout)*time.Second)
|
2020-01-08 15:20:29 +03:00
|
|
|
if err != nil {
|
|
|
|
return fmt.Errorf("could not initialise RTMP ring buffer: %w", err)
|
|
|
|
}
|
2019-08-08 06:50:02 +03:00
|
|
|
w, err := newRtmpSender(
|
2019-11-06 09:57:10 +03:00
|
|
|
r.cfg.RTMPURL,
|
2019-08-08 06:50:02 +03:00
|
|
|
rtmpConnectionTimeout,
|
|
|
|
rtmpConnectionMaxTries,
|
2020-01-08 15:20:29 +03:00
|
|
|
rb,
|
2019-11-06 09:57:10 +03:00
|
|
|
r.cfg.Logger.Log,
|
2019-08-08 06:50:02 +03:00
|
|
|
)
|
2018-11-25 16:15:38 +03:00
|
|
|
if err != nil {
|
2019-11-06 09:57:10 +03:00
|
|
|
r.cfg.Logger.Log(logger.Warning, pkg+"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...)
|
2019-11-06 09:57:10 +03:00
|
|
|
e, _ := mtsEnc(mw, r.cfg.WriteRate)
|
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 {
|
|
|
|
r.filters = make([]filter.Filter, l)
|
|
|
|
dst := r.encoders
|
|
|
|
|
|
|
|
for i := l - 1; i >= 0; i-- {
|
|
|
|
switch r.cfg.Filters[i] {
|
|
|
|
case config.FilterNoOp:
|
|
|
|
r.filters[i] = filter.NewNoOp(dst)
|
|
|
|
case config.FilterMOG:
|
2020-01-23 04:45:07 +03:00
|
|
|
r.filters[i] = filter.NewMOGFilter(dst, r.cfg.MOGMinArea, r.cfg.MOGThreshold, int(r.cfg.MOGHistory), r.cfg.ShowWindows, r.cfg.MotionInterval)
|
2019-12-27 08:36:30 +03:00
|
|
|
case config.FilterVariableFPS:
|
2020-01-23 04:45:07 +03:00
|
|
|
r.filters[i] = filter.NewVariableFPSFilter(dst, r.cfg.MinFPS, filter.NewMOGFilter(dst, r.cfg.MOGMinArea, r.cfg.MOGThreshold, int(r.cfg.MOGHistory), r.cfg.ShowWindows, r.cfg.MotionInterval))
|
2019-12-27 08:36:30 +03:00
|
|
|
case config.FilterKNN:
|
2020-01-23 05:13:09 +03:00
|
|
|
r.filters[i] = filter.NewKNNFilter(dst, r.cfg.KNNMinArea, r.cfg.KNNThreshold, int(r.cfg.KNNHistory), int(r.cfg.KNNKernel), r.cfg.ShowWindows, r.cfg.MotionInterval)
|
2019-12-27 08:36:30 +03:00
|
|
|
default:
|
|
|
|
panic("Undefined Filter")
|
|
|
|
}
|
|
|
|
dst = r.filters[i]
|
|
|
|
}
|
|
|
|
|
2019-12-20 03:12:51 +03:00
|
|
|
}
|
|
|
|
|
2019-11-06 09:57:10 +03:00
|
|
|
switch r.cfg.Input {
|
|
|
|
case config.InputRaspivid:
|
2019-11-12 08:34:07 +03:00
|
|
|
r.input = raspivid.New(r.cfg.Logger)
|
|
|
|
|
2019-11-06 09:57:10 +03:00
|
|
|
switch r.cfg.InputCodec {
|
2019-09-24 11:05:17 +03:00
|
|
|
case codecutil.H264:
|
2019-09-24 01:12:26 +03:00
|
|
|
r.lexTo = h264.Lex
|
2019-09-24 11:05:17 +03:00
|
|
|
case codecutil.MJPEG:
|
2019-09-24 01:12:26 +03:00
|
|
|
r.lexTo = mjpeg.Lex
|
|
|
|
}
|
2019-11-12 08:34:07 +03:00
|
|
|
|
2019-11-06 09:57:10 +03:00
|
|
|
case config.InputV4L:
|
2019-11-12 08:34:07 +03:00
|
|
|
r.input = webcam.New(r.cfg.Logger)
|
2019-12-04 04:10:12 +03:00
|
|
|
switch r.cfg.InputCodec {
|
|
|
|
case codecutil.H264:
|
|
|
|
r.lexTo = h264.Lex
|
|
|
|
case codecutil.MJPEG:
|
|
|
|
r.lexTo = mjpeg.Lex
|
|
|
|
}
|
2019-11-12 08:34:07 +03:00
|
|
|
|
2019-11-06 09:57:10 +03:00
|
|
|
case config.InputFile:
|
2019-11-12 08:34:07 +03:00
|
|
|
r.input = file.New()
|
2019-12-04 08:47:51 +03:00
|
|
|
switch r.cfg.InputCodec {
|
|
|
|
case codecutil.H264:
|
|
|
|
r.lexTo = h264.Lex
|
|
|
|
case codecutil.MJPEG:
|
|
|
|
r.lexTo = mjpeg.Lex
|
|
|
|
}
|
2019-11-12 08:34:07 +03:00
|
|
|
|
2019-11-06 09:57:10 +03:00
|
|
|
case config.InputRTSP:
|
2019-11-12 08:34:07 +03:00
|
|
|
r.input = geovision.New(r.cfg.Logger)
|
|
|
|
|
2019-11-06 09:57:10 +03:00
|
|
|
switch r.cfg.InputCodec {
|
2019-10-07 06:48:20 +03:00
|
|
|
case codecutil.H264:
|
2019-10-28 01:11:49 +03:00
|
|
|
r.lexTo = h264.NewExtractor().Extract
|
2019-10-07 06:48:20 +03:00
|
|
|
case codecutil.H265:
|
|
|
|
r.lexTo = h265.NewLexer(false).Lex
|
|
|
|
case codecutil.MJPEG:
|
2019-11-22 05:35:11 +03:00
|
|
|
r.lexTo = mjpeg.NewExtractor().Extract
|
2019-10-07 06:48:20 +03:00
|
|
|
}
|
2019-11-12 08:34:07 +03:00
|
|
|
|
2019-11-06 09:57:10 +03:00
|
|
|
case config.InputAudio:
|
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.
|
|
|
|
err := r.input.Set(r.cfg)
|
|
|
|
if err != nil {
|
|
|
|
r.cfg.Logger.Log(logger.Warning, pkg+"errors from configuring input device", "errors", err)
|
2018-01-10 04:32:16 +03:00
|
|
|
}
|
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
|
|
|
|
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() {
|
2019-11-06 09:57:10 +03:00
|
|
|
r.cfg.Logger.Log(logger.Warning, pkg+"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()
|
|
|
|
|
2019-11-06 09:57:10 +03:00
|
|
|
r.cfg.Logger.Log(logger.Info, pkg+"starting Revid")
|
|
|
|
err := r.reset(r.cfg)
|
2019-09-12 10:38:22 +03:00
|
|
|
if err != nil {
|
|
|
|
r.Stop()
|
|
|
|
return err
|
|
|
|
}
|
2019-11-12 08:34:07 +03:00
|
|
|
|
2020-01-24 12:35:43 +03:00
|
|
|
// Calculate delay between frames based on InputFPS.
|
2020-01-25 02:09:42 +03:00
|
|
|
d := time.Duration(1000/r.cfg.FileFPS) * time.Millisecond
|
2020-01-24 12:35:43 +03:00
|
|
|
|
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() {
|
2019-11-06 09:57:10 +03:00
|
|
|
r.cfg.Logger.Log(logger.Warning, pkg+"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()
|
|
|
|
|
2019-11-12 08:34:07 +03:00
|
|
|
err := r.input.Stop()
|
|
|
|
if err != nil {
|
|
|
|
r.cfg.Logger.Log(logger.Error, pkg+"could not stop input", "error", err.Error())
|
2019-04-08 12:32:42 +03:00
|
|
|
}
|
2019-05-06 08:42:05 +03:00
|
|
|
|
2019-12-23 04:31:27 +03:00
|
|
|
r.cfg.Logger.Log(logger.Info, pkg+"closing pid peline")
|
2019-11-12 08:34:07 +03:00
|
|
|
err = r.encoders.Close()
|
2019-04-15 02:12:56 +03:00
|
|
|
if err != nil {
|
2019-11-06 09:57:10 +03:00
|
|
|
r.cfg.Logger.Log(logger.Error, pkg+"failed to close pipeline", "error", err.Error())
|
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 {
|
|
|
|
r.cfg.Logger.Log(logger.Error, pkg+"failed to close pipeline", "error", err.Error())
|
|
|
|
}
|
2019-12-20 08:07:49 +03:00
|
|
|
}
|
2019-12-27 09:18:28 +03:00
|
|
|
|
2019-11-06 09:57:10 +03:00
|
|
|
r.cfg.Logger.Log(logger.Info, pkg+"closed pipeline")
|
2019-04-15 02:12:56 +03:00
|
|
|
|
2018-04-16 07:54:21 +03:00
|
|
|
if r.cmd != nil && r.cmd.Process != nil {
|
2019-11-06 09:57:10 +03:00
|
|
|
r.cfg.Logger.Log(logger.Info, pkg+"killing input proccess")
|
2018-04-16 07:54:21 +03:00
|
|
|
r.cmd.Process.Kill()
|
|
|
|
}
|
2019-11-06 09:57:10 +03:00
|
|
|
r.cfg.Logger.Log(logger.Info, pkg+"waiting for routines to close")
|
2019-10-22 15:34:33 +03:00
|
|
|
|
2019-04-14 04:43:17 +03:00
|
|
|
r.wg.Wait()
|
2019-10-22 15:34:33 +03:00
|
|
|
|
2019-11-06 09:57:10 +03:00
|
|
|
r.cfg.Logger.Log(logger.Info, pkg+"revid stopped")
|
2019-10-01 17:14:38 +03:00
|
|
|
r.running = false
|
|
|
|
}
|
|
|
|
|
|
|
|
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() {
|
2019-03-02 05:19:09 +03:00
|
|
|
r.Stop()
|
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
|
|
|
|
for key, value := range vars {
|
|
|
|
switch key {
|
2019-10-22 08:47:35 +03:00
|
|
|
case "Input":
|
2019-12-05 03:13:28 +03:00
|
|
|
v, ok := map[string]uint8{"raspivid": config.InputRaspivid, "rtsp": config.InputRTSP, "v4l": config.InputV4L, "file": config.InputFile}[strings.ToLower(value)]
|
2019-10-22 08:47:35 +03:00
|
|
|
if !ok {
|
2019-11-06 09:57:10 +03:00
|
|
|
r.cfg.Logger.Log(logger.Warning, pkg+"invalid input var", "value", value)
|
2019-10-22 08:47:35 +03:00
|
|
|
break
|
|
|
|
}
|
2019-11-06 09:57:10 +03:00
|
|
|
r.cfg.Input = v
|
2019-03-15 09:54:29 +03:00
|
|
|
case "Saturation":
|
2019-12-05 02:25:11 +03:00
|
|
|
s, err := strconv.Atoi(value)
|
2019-03-15 09:54:29 +03:00
|
|
|
if err != nil {
|
2019-11-06 09:57:10 +03:00
|
|
|
r.cfg.Logger.Log(logger.Warning, pkg+"invalid saturation param", "value", value)
|
2019-10-26 00:54:53 +03:00
|
|
|
break
|
2019-03-15 09:54:29 +03:00
|
|
|
}
|
2019-11-06 09:57:10 +03:00
|
|
|
r.cfg.Saturation = int(s)
|
2019-03-15 09:54:29 +03:00
|
|
|
case "Brightness":
|
2019-12-05 02:25:11 +03:00
|
|
|
b, err := strconv.Atoi(value)
|
2019-03-15 09:54:29 +03:00
|
|
|
if err != nil {
|
2019-11-06 09:57:10 +03:00
|
|
|
r.cfg.Logger.Log(logger.Warning, pkg+"invalid brightness param", "value", value)
|
2019-10-26 00:54:53 +03:00
|
|
|
break
|
2019-03-15 09:54:29 +03:00
|
|
|
}
|
2019-11-06 09:57:10 +03:00
|
|
|
r.cfg.Brightness = uint(b)
|
2019-03-15 09:54:29 +03:00
|
|
|
case "Exposure":
|
2019-11-06 09:57:10 +03:00
|
|
|
r.cfg.Exposure = value
|
2019-03-17 02:21:09 +03:00
|
|
|
case "AutoWhiteBalance":
|
2019-11-06 09:57:10 +03:00
|
|
|
r.cfg.AutoWhiteBalance = value
|
2019-09-24 01:12:26 +03:00
|
|
|
case "InputCodec":
|
|
|
|
switch value {
|
|
|
|
case "H264":
|
2019-11-06 09:57:10 +03:00
|
|
|
r.cfg.InputCodec = codecutil.H264
|
2019-09-24 01:12:26 +03:00
|
|
|
case "MJPEG":
|
2019-11-06 09:57:10 +03:00
|
|
|
r.cfg.InputCodec = codecutil.MJPEG
|
2019-09-24 01:12:26 +03:00
|
|
|
default:
|
2019-11-06 09:57:10 +03:00
|
|
|
r.cfg.Logger.Log(logger.Warning, pkg+"invalid InputCodec variable value", "value", value)
|
2019-09-24 01:12:26 +03:00
|
|
|
}
|
2019-12-23 09:25:40 +03:00
|
|
|
case "Outputs":
|
2019-03-05 03:20:31 +03:00
|
|
|
outputs := strings.Split(value, ",")
|
2019-11-06 09:57:10 +03:00
|
|
|
r.cfg.Outputs = make([]uint8, len(outputs))
|
2019-03-05 03:20:31 +03:00
|
|
|
|
|
|
|
for i, output := range outputs {
|
|
|
|
switch output {
|
|
|
|
case "File":
|
2019-11-06 09:57:10 +03:00
|
|
|
r.cfg.Outputs[i] = config.OutputFile
|
2019-03-05 03:20:31 +03:00
|
|
|
case "Http":
|
2019-11-06 09:57:10 +03:00
|
|
|
r.cfg.Outputs[i] = config.OutputHTTP
|
2019-03-05 03:20:31 +03:00
|
|
|
case "Rtmp":
|
2019-11-06 09:57:10 +03:00
|
|
|
r.cfg.Outputs[i] = config.OutputRTMP
|
2019-03-05 03:20:31 +03:00
|
|
|
case "Rtp":
|
2019-11-06 09:57:10 +03:00
|
|
|
r.cfg.Outputs[i] = config.OutputRTP
|
2019-03-05 03:20:31 +03:00
|
|
|
default:
|
2019-12-23 09:25:40 +03:00
|
|
|
r.cfg.Logger.Log(logger.Warning, pkg+"invalid outputs param", "value", value)
|
2019-03-05 03:20:31 +03:00
|
|
|
continue
|
|
|
|
}
|
2019-02-03 13:47:44 +03:00
|
|
|
}
|
2019-12-23 09:25:40 +03:00
|
|
|
case "Output":
|
|
|
|
r.cfg.Outputs = make([]uint8, 1)
|
|
|
|
switch value {
|
|
|
|
case "File":
|
|
|
|
r.cfg.Outputs[0] = config.OutputFile
|
|
|
|
case "Http":
|
|
|
|
r.cfg.Outputs[0] = config.OutputHTTP
|
|
|
|
case "Rtmp":
|
|
|
|
r.cfg.Outputs[0] = config.OutputRTMP
|
|
|
|
case "Rtp":
|
|
|
|
r.cfg.Outputs[0] = config.OutputRTP
|
|
|
|
default:
|
|
|
|
r.cfg.Logger.Log(logger.Warning, pkg+"invalid output param", "value", value)
|
|
|
|
continue
|
|
|
|
}
|
2019-02-25 08:59:44 +03:00
|
|
|
|
2019-02-03 13:47:44 +03:00
|
|
|
case "RtmpUrl":
|
2019-11-06 09:57:10 +03:00
|
|
|
r.cfg.RTMPURL = value
|
2019-03-14 06:46:55 +03:00
|
|
|
case "RtpAddress":
|
2019-11-06 09:57:10 +03:00
|
|
|
r.cfg.RTPAddress = value
|
2019-02-03 13:47:44 +03:00
|
|
|
case "Bitrate":
|
2019-12-05 07:20:44 +03:00
|
|
|
v, err := strconv.Atoi(value)
|
2019-02-03 13:47:44 +03:00
|
|
|
if err != nil {
|
2019-11-06 09:57:10 +03:00
|
|
|
r.cfg.Logger.Log(logger.Warning, pkg+"invalid framerate param", "value", value)
|
2019-02-03 13:47:44 +03:00
|
|
|
break
|
|
|
|
}
|
2019-11-06 09:57:10 +03:00
|
|
|
r.cfg.Bitrate = uint(v)
|
2019-02-12 10:52:46 +03:00
|
|
|
case "OutputPath":
|
2019-11-06 09:57:10 +03:00
|
|
|
r.cfg.OutputPath = value
|
2019-02-12 10:52:46 +03:00
|
|
|
case "InputPath":
|
2019-11-06 09:57:10 +03:00
|
|
|
r.cfg.InputPath = value
|
2019-02-03 13:47:44 +03:00
|
|
|
case "Height":
|
2019-12-05 07:20:44 +03:00
|
|
|
h, err := strconv.Atoi(value)
|
2019-02-03 13:47:44 +03:00
|
|
|
if err != nil {
|
2019-11-06 09:57:10 +03:00
|
|
|
r.cfg.Logger.Log(logger.Warning, pkg+"invalid height param", "value", value)
|
2019-02-03 13:47:44 +03:00
|
|
|
break
|
|
|
|
}
|
2019-11-06 09:57:10 +03:00
|
|
|
r.cfg.Height = uint(h)
|
2019-02-03 13:47:44 +03:00
|
|
|
case "Width":
|
2019-12-05 07:20:44 +03:00
|
|
|
w, err := strconv.Atoi(value)
|
2019-02-03 13:47:44 +03:00
|
|
|
if err != nil {
|
2019-11-06 09:57:10 +03:00
|
|
|
r.cfg.Logger.Log(logger.Warning, pkg+"invalid width param", "value", value)
|
2019-02-03 13:47:44 +03:00
|
|
|
break
|
|
|
|
}
|
2019-11-06 09:57:10 +03:00
|
|
|
r.cfg.Width = uint(w)
|
2019-02-03 13:47:44 +03:00
|
|
|
case "FrameRate":
|
2019-12-05 07:20:44 +03:00
|
|
|
v, err := strconv.Atoi(value)
|
2019-02-03 13:47:44 +03:00
|
|
|
if err != nil {
|
2019-11-06 09:57:10 +03:00
|
|
|
r.cfg.Logger.Log(logger.Warning, pkg+"invalid framerate param", "value", value)
|
2019-02-03 13:47:44 +03:00
|
|
|
break
|
|
|
|
}
|
2019-11-06 09:57:10 +03:00
|
|
|
r.cfg.FrameRate = uint(v)
|
2019-03-04 04:52:39 +03:00
|
|
|
case "Rotation":
|
2019-12-05 07:20:44 +03:00
|
|
|
v, err := strconv.Atoi(value)
|
2019-03-04 04:37:28 +03:00
|
|
|
if err != nil || v > 359 {
|
2019-11-06 09:57:10 +03:00
|
|
|
r.cfg.Logger.Log(logger.Warning, pkg+"invalid rotation param", "value", value)
|
2019-03-04 04:37:28 +03:00
|
|
|
break
|
|
|
|
}
|
2019-11-06 09:57:10 +03:00
|
|
|
r.cfg.Rotation = uint(v)
|
2019-02-03 13:47:44 +03:00
|
|
|
case "HttpAddress":
|
2019-11-06 09:57:10 +03:00
|
|
|
r.cfg.HTTPAddress = value
|
2019-02-03 13:47:44 +03:00
|
|
|
case "Quantization":
|
2019-08-24 07:32:24 +03:00
|
|
|
v, err := strconv.Atoi(value)
|
2019-02-03 13:47:44 +03:00
|
|
|
if err != nil {
|
2019-11-06 09:57:10 +03:00
|
|
|
r.cfg.Logger.Log(logger.Warning, pkg+"invalid quantization param", "value", v)
|
2019-02-03 13:47:44 +03:00
|
|
|
break
|
|
|
|
}
|
2019-11-06 09:57:10 +03:00
|
|
|
r.cfg.Quantization = uint(v)
|
2019-08-26 07:13:45 +03:00
|
|
|
case "MinFrames":
|
2019-08-25 10:44:06 +03:00
|
|
|
v, err := strconv.Atoi(value)
|
|
|
|
if err != nil {
|
2019-11-06 09:57:10 +03:00
|
|
|
r.cfg.Logger.Log(logger.Warning, pkg+"invalid MinFrames param", "value", value)
|
2019-08-25 10:44:06 +03:00
|
|
|
break
|
|
|
|
}
|
2019-11-06 09:57:10 +03:00
|
|
|
r.cfg.MinFrames = uint(v)
|
2019-08-25 10:44:06 +03:00
|
|
|
|
|
|
|
case "ClipDuration":
|
|
|
|
v, err := strconv.Atoi(value)
|
2019-02-03 13:47:44 +03:00
|
|
|
if err != nil {
|
2019-11-06 09:57:10 +03:00
|
|
|
r.cfg.Logger.Log(logger.Warning, pkg+"invalid ClipDuration param", "value", value)
|
2019-02-03 13:47:44 +03:00
|
|
|
break
|
|
|
|
}
|
2019-11-06 09:57:10 +03:00
|
|
|
r.cfg.ClipDuration = time.Duration(v) * time.Second
|
2019-03-06 04:21:55 +03:00
|
|
|
|
2019-02-03 13:47:44 +03:00
|
|
|
case "HorizontalFlip":
|
|
|
|
switch strings.ToLower(value) {
|
|
|
|
case "true":
|
2019-12-06 09:06:29 +03:00
|
|
|
r.cfg.HorizontalFlip = true
|
2019-02-03 13:47:44 +03:00
|
|
|
case "false":
|
2019-12-06 09:06:29 +03:00
|
|
|
r.cfg.HorizontalFlip = false
|
2019-02-03 13:47:44 +03:00
|
|
|
default:
|
2019-11-06 09:57:10 +03:00
|
|
|
r.cfg.Logger.Log(logger.Warning, pkg+"invalid HorizontalFlip param", "value", value)
|
2019-02-03 13:47:44 +03:00
|
|
|
}
|
|
|
|
case "VerticalFlip":
|
|
|
|
switch strings.ToLower(value) {
|
|
|
|
case "true":
|
2019-12-06 09:06:29 +03:00
|
|
|
r.cfg.VerticalFlip = true
|
2019-02-03 13:47:44 +03:00
|
|
|
case "false":
|
2019-12-06 09:06:29 +03:00
|
|
|
r.cfg.VerticalFlip = false
|
2019-02-03 13:47:44 +03:00
|
|
|
default:
|
2019-11-06 09:57:10 +03:00
|
|
|
r.cfg.Logger.Log(logger.Warning, pkg+"invalid VerticalFlip param", "value", value)
|
2019-02-03 13:47:44 +03:00
|
|
|
}
|
2019-12-27 08:36:30 +03:00
|
|
|
case "Filters":
|
|
|
|
filters := strings.Split(value, ",")
|
2019-12-23 07:28:35 +03:00
|
|
|
m := map[string]int{"NoOp": config.FilterNoOp, "MOG": config.FilterMOG, "VariableFPS": config.FilterVariableFPS, "KNN": config.FilterKNN}
|
2019-12-27 08:36:30 +03:00
|
|
|
r.cfg.Filters = make([]int, len(filters))
|
|
|
|
for i, filter := range filters {
|
|
|
|
v, ok := m[filter]
|
|
|
|
if !ok {
|
|
|
|
r.cfg.Logger.Log(logger.Warning, pkg+"invalid Filters param", "value", value)
|
|
|
|
}
|
|
|
|
r.cfg.Filters[i] = v
|
2019-12-20 03:12:51 +03:00
|
|
|
}
|
2020-01-22 07:27:35 +03:00
|
|
|
case "MotionInterval":
|
2020-01-02 06:07:06 +03:00
|
|
|
v, err := strconv.Atoi(value)
|
|
|
|
if err != nil || v < 0 {
|
2020-01-22 07:27:35 +03:00
|
|
|
r.cfg.Logger.Log(logger.Warning, pkg+"invalid MotionInterval var", "value", value)
|
2020-01-02 06:07:06 +03:00
|
|
|
break
|
|
|
|
}
|
2020-01-22 07:27:35 +03:00
|
|
|
r.cfg.MotionInterval = v
|
2019-12-19 03:45:47 +03:00
|
|
|
case "PSITime":
|
2019-12-17 02:51:56 +03:00
|
|
|
v, err := strconv.Atoi(value)
|
|
|
|
if err != nil || v < 0 {
|
2019-12-19 03:45:47 +03:00
|
|
|
r.cfg.Logger.Log(logger.Warning, pkg+"invalid PSITime var", "value", value)
|
2019-12-17 02:51:56 +03:00
|
|
|
break
|
|
|
|
}
|
2019-12-19 03:45:47 +03:00
|
|
|
r.cfg.PSITime = v
|
2019-02-03 16:13:51 +03:00
|
|
|
case "BurstPeriod":
|
2019-12-05 07:20:44 +03:00
|
|
|
v, err := strconv.Atoi(value)
|
2019-02-03 16:13:51 +03:00
|
|
|
if err != nil {
|
2019-11-06 09:57:10 +03:00
|
|
|
r.cfg.Logger.Log(logger.Warning, pkg+"invalid BurstPeriod param", "value", value)
|
2019-02-03 16:13:51 +03:00
|
|
|
break
|
|
|
|
}
|
2019-11-06 09:57:10 +03:00
|
|
|
r.cfg.BurstPeriod = uint(v)
|
2019-05-05 13:09:56 +03:00
|
|
|
case "Logging":
|
|
|
|
switch value {
|
|
|
|
case "Debug":
|
2019-11-06 09:57:10 +03:00
|
|
|
r.cfg.LogLevel = logger.Debug
|
2019-05-05 13:09:56 +03:00
|
|
|
case "Info":
|
2019-11-06 09:57:10 +03:00
|
|
|
r.cfg.LogLevel = logger.Info
|
2019-05-05 13:09:56 +03:00
|
|
|
case "Warning":
|
2019-11-06 09:57:10 +03:00
|
|
|
r.cfg.LogLevel = logger.Warning
|
2019-05-05 13:09:56 +03:00
|
|
|
case "Error":
|
2019-11-06 09:57:10 +03:00
|
|
|
r.cfg.LogLevel = logger.Error
|
2019-05-05 13:09:56 +03:00
|
|
|
case "Fatal":
|
2019-11-06 09:57:10 +03:00
|
|
|
r.cfg.LogLevel = logger.Fatal
|
2019-05-05 13:09:56 +03:00
|
|
|
default:
|
2019-11-06 09:57:10 +03:00
|
|
|
r.cfg.Logger.Log(logger.Warning, pkg+"invalid Logging param", "value", value)
|
2019-05-05 13:09:56 +03:00
|
|
|
}
|
2020-01-08 15:20:29 +03:00
|
|
|
case "RTMPRBMaxElements":
|
2019-08-08 06:50:02 +03:00
|
|
|
v, err := strconv.Atoi(value)
|
|
|
|
if err != nil || v < 0 {
|
2020-01-08 15:20:29 +03:00
|
|
|
r.cfg.Logger.Log(logger.Warning, pkg+"invalid RTMPRBMaxElements var", "value", value)
|
2019-08-08 06:50:02 +03:00
|
|
|
break
|
|
|
|
}
|
2020-01-09 06:28:44 +03:00
|
|
|
r.cfg.RBMaxElements = v
|
2020-01-08 15:20:29 +03:00
|
|
|
case "RTMPRBCapacity":
|
2019-08-08 06:50:02 +03:00
|
|
|
v, err := strconv.Atoi(value)
|
|
|
|
if err != nil || v < 0 {
|
2020-01-08 15:20:29 +03:00
|
|
|
r.cfg.Logger.Log(logger.Warning, pkg+"invalid RTMPRBCapacity var", "value", value)
|
2019-08-08 06:50:02 +03:00
|
|
|
break
|
|
|
|
}
|
2020-01-09 06:28:44 +03:00
|
|
|
r.cfg.RBCapacity = v
|
2019-10-12 13:40:48 +03:00
|
|
|
case "RTMPRBWriteTimeout":
|
|
|
|
v, err := strconv.Atoi(value)
|
|
|
|
if err != nil || v <= 0 {
|
2019-11-06 09:57:10 +03:00
|
|
|
r.cfg.Logger.Log(logger.Warning, pkg+"invalid RTMPRBWriteTimeout var", "value", value)
|
2019-10-12 13:40:48 +03:00
|
|
|
break
|
|
|
|
}
|
2020-01-09 06:28:44 +03:00
|
|
|
r.cfg.RBWriteTimeout = v
|
2020-01-09 05:55:31 +03:00
|
|
|
case "MTSRBMaxElements":
|
2019-08-08 06:50:02 +03:00
|
|
|
v, err := strconv.Atoi(value)
|
|
|
|
if err != nil || v < 0 {
|
2020-01-09 05:55:31 +03:00
|
|
|
r.cfg.Logger.Log(logger.Warning, pkg+"invalid MTSRBMaxElements var", "value", value)
|
2019-08-08 06:50:02 +03:00
|
|
|
break
|
|
|
|
}
|
2020-01-09 06:28:44 +03:00
|
|
|
r.cfg.RBMaxElements = v
|
2020-01-08 15:20:29 +03:00
|
|
|
case "MTSRBCapacity":
|
2019-08-08 06:50:02 +03:00
|
|
|
v, err := strconv.Atoi(value)
|
|
|
|
if err != nil || v < 0 {
|
2020-01-08 15:20:29 +03:00
|
|
|
r.cfg.Logger.Log(logger.Warning, pkg+"invalid MTSRBCapacity var", "value", value)
|
2019-08-08 06:50:02 +03:00
|
|
|
break
|
|
|
|
}
|
2020-01-09 06:28:44 +03:00
|
|
|
r.cfg.RBCapacity = v
|
2019-10-12 13:40:48 +03:00
|
|
|
case "MTSRBWriteTimeout":
|
|
|
|
v, err := strconv.Atoi(value)
|
|
|
|
if err != nil || v <= 0 {
|
2019-11-06 09:57:10 +03:00
|
|
|
r.cfg.Logger.Log(logger.Warning, pkg+"invalid MTSRBWriteTimeout var", "value", value)
|
2019-10-12 13:40:48 +03:00
|
|
|
break
|
|
|
|
}
|
2020-01-09 06:28:44 +03:00
|
|
|
r.cfg.RBWriteTimeout = v
|
2019-11-22 06:08:57 +03:00
|
|
|
case "CBR":
|
2019-10-22 07:24:38 +03:00
|
|
|
v, ok := map[string]bool{"true": true, "false": false}[strings.ToLower(value)]
|
|
|
|
if !ok {
|
2019-11-22 06:08:57 +03:00
|
|
|
r.cfg.Logger.Log(logger.Warning, pkg+"invalid CBR var", "value", value)
|
2019-10-22 07:24:38 +03:00
|
|
|
break
|
|
|
|
}
|
2019-11-22 06:08:57 +03:00
|
|
|
r.cfg.CBR = v
|
2020-01-09 07:58:49 +03:00
|
|
|
case "CameraIP":
|
|
|
|
r.cfg.CameraIP = value
|
2019-10-22 07:24:38 +03:00
|
|
|
case "VBRQuality":
|
2019-11-06 09:57:10 +03:00
|
|
|
v, ok := map[string]config.Quality{"standard": config.QualityStandard, "fair": config.QualityFair, "good": config.QualityGood, "great": config.QualityGreat, "excellent": config.QualityExcellent}[strings.ToLower(value)]
|
2019-10-22 07:24:38 +03:00
|
|
|
if !ok {
|
2019-11-06 09:57:10 +03:00
|
|
|
r.cfg.Logger.Log(logger.Warning, pkg+"invalid VBRQuality var", "value", value)
|
2019-10-22 07:24:38 +03:00
|
|
|
break
|
|
|
|
}
|
2019-11-06 09:57:10 +03:00
|
|
|
r.cfg.VBRQuality = v
|
2019-10-22 07:24:38 +03:00
|
|
|
case "VBRBitrate":
|
|
|
|
v, err := strconv.Atoi(value)
|
|
|
|
if err != nil || v <= 0 {
|
2019-11-06 09:57:10 +03:00
|
|
|
r.cfg.Logger.Log(logger.Warning, pkg+"invalid VBRBitrate var", "value", value)
|
2019-10-22 07:24:38 +03:00
|
|
|
break
|
|
|
|
}
|
2019-11-06 09:57:10 +03:00
|
|
|
r.cfg.VBRBitrate = v
|
2019-10-25 04:42:30 +03:00
|
|
|
case "CameraChan":
|
|
|
|
v, err := strconv.Atoi(value)
|
|
|
|
if err != nil || (v != 1 && v != 2) {
|
2019-11-06 09:57:10 +03:00
|
|
|
r.cfg.Logger.Log(logger.Warning, pkg+"invalid CameraChan var", "value", value)
|
2019-10-25 04:42:30 +03:00
|
|
|
break
|
|
|
|
}
|
2019-11-06 09:57:10 +03:00
|
|
|
r.cfg.CameraChan = v
|
2020-01-02 04:15:36 +03:00
|
|
|
case "ShowWindows":
|
|
|
|
switch strings.ToLower(value) {
|
|
|
|
case "true":
|
|
|
|
r.cfg.ShowWindows = true
|
|
|
|
case "false":
|
|
|
|
r.cfg.ShowWindows = false
|
|
|
|
default:
|
|
|
|
r.cfg.Logger.Log(logger.Warning, pkg+"invalid ShowWindows var", "value", value)
|
|
|
|
break
|
|
|
|
}
|
2020-01-08 03:12:34 +03:00
|
|
|
case "MinFPS":
|
|
|
|
v, err := strconv.ParseFloat(value, 64)
|
|
|
|
if err != nil {
|
|
|
|
r.cfg.Logger.Log(logger.Warning, pkg+"invalid MinFPS var", "value", value)
|
|
|
|
break
|
|
|
|
}
|
|
|
|
r.cfg.MinFPS = v
|
|
|
|
case "KNNMinArea":
|
|
|
|
v, err := strconv.ParseFloat(value, 64)
|
|
|
|
if err != nil {
|
|
|
|
r.cfg.Logger.Log(logger.Warning, pkg+"invalid KNNMinArea var", "value", value)
|
|
|
|
break
|
|
|
|
}
|
|
|
|
r.cfg.KNNMinArea = v
|
|
|
|
case "KNNThreshold":
|
|
|
|
v, err := strconv.ParseFloat(value, 64)
|
|
|
|
if err != nil {
|
|
|
|
r.cfg.Logger.Log(logger.Warning, pkg+"invalid KNNThreshold var", "value", value)
|
|
|
|
break
|
|
|
|
}
|
|
|
|
r.cfg.KNNThreshold = v
|
|
|
|
case "KNNKernel":
|
|
|
|
v, err := strconv.Atoi(value)
|
|
|
|
if err != nil {
|
|
|
|
r.cfg.Logger.Log(logger.Warning, pkg+"invalid KNNKernel var", "value", value)
|
|
|
|
break
|
|
|
|
}
|
|
|
|
r.cfg.KNNKernel = uint(v)
|
|
|
|
case "MOGMinArea":
|
|
|
|
v, err := strconv.ParseFloat(value, 64)
|
|
|
|
if err != nil {
|
|
|
|
r.cfg.Logger.Log(logger.Warning, pkg+"invalid MOGMinArea var", "value", value)
|
|
|
|
break
|
|
|
|
}
|
|
|
|
r.cfg.MOGMinArea = v
|
|
|
|
case "MOGThreshold":
|
|
|
|
v, err := strconv.ParseFloat(value, 64)
|
|
|
|
if err != nil {
|
|
|
|
r.cfg.Logger.Log(logger.Warning, pkg+"invalid MOGThreshold var", "value", value)
|
|
|
|
break
|
|
|
|
}
|
|
|
|
r.cfg.MOGThreshold = v
|
|
|
|
case "KNNHistory":
|
|
|
|
v, err := strconv.Atoi(value)
|
|
|
|
if err != nil || v <= 0 {
|
|
|
|
r.cfg.Logger.Log(logger.Warning, pkg+"invalid KNNHistory var", "value", value)
|
|
|
|
break
|
|
|
|
}
|
|
|
|
r.cfg.KNNHistory = uint(v)
|
|
|
|
case "MOGHistory":
|
|
|
|
v, err := strconv.Atoi(value)
|
|
|
|
if err != nil || v <= 0 {
|
|
|
|
r.cfg.Logger.Log(logger.Warning, pkg+"invalid MOGHistory var", "value", value)
|
|
|
|
break
|
|
|
|
}
|
|
|
|
r.cfg.MOGHistory = uint(v)
|
2020-01-24 11:51:18 +03:00
|
|
|
case "mode":
|
|
|
|
r.cfg.Loop = false
|
|
|
|
if value == "Loop" {
|
|
|
|
r.cfg.Loop = true
|
|
|
|
}
|
2019-02-03 13:47:44 +03:00
|
|
|
}
|
|
|
|
}
|
2019-11-06 09:57:10 +03:00
|
|
|
r.cfg.Logger.Log(logger.Info, pkg+"revid config changed", "config", fmt.Sprintf("%+v", 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.
|
|
|
|
r.cfg.Logger.Log(logger.Info, pkg+"lexing")
|
|
|
|
err = r.lexTo(r.filters[0], in, delay)
|
|
|
|
switch err {
|
2020-01-25 02:12:32 +03:00
|
|
|
case nil, io.EOF:
|
|
|
|
case io.ErrUnexpectedEOF:
|
|
|
|
r.cfg.Logger.Log(logger.Info, pkg+"unexpected EOF from input")
|
2020-01-24 13:55:27 +03:00
|
|
|
default:
|
|
|
|
r.err <- err
|
|
|
|
}
|
2020-01-24 11:51:18 +03:00
|
|
|
|
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-01-24 11:51:18 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
r.cfg.Logger.Log(logger.Info, pkg+"finished lexing")
|
2019-11-12 08:36:04 +03:00
|
|
|
}
|