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
|
|
|
|
|
|
|
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>
|
2018-01-09 07:26:34 +03:00
|
|
|
|
|
|
|
LICENSE
|
2018-06-08 03:02:13 +03:00
|
|
|
revid is Copyright (C) 2017-2018 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
|
|
|
|
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.
|
2018-01-09 07:26:34 +03:00
|
|
|
*/
|
|
|
|
|
|
|
|
// 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"
|
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"
|
|
|
|
"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
|
|
|
|
2018-08-20 01:19:02 +03:00
|
|
|
"bitbucket.org/ausocean/av/stream"
|
|
|
|
"bitbucket.org/ausocean/av/stream/flv"
|
2018-08-23 08:36:32 +03:00
|
|
|
"bitbucket.org/ausocean/av/stream/lex"
|
2018-08-20 01:19:02 +03:00
|
|
|
"bitbucket.org/ausocean/av/stream/mts"
|
2018-06-26 09:23:55 +03:00
|
|
|
"bitbucket.org/ausocean/iot/pi/netsender"
|
2019-01-02 08:09:47 +03:00
|
|
|
"bitbucket.org/ausocean/utils/logger"
|
2018-06-27 01:20:05 +03:00
|
|
|
"bitbucket.org/ausocean/utils/ring"
|
2018-05-07 14:46:40 +03:00
|
|
|
)
|
2018-01-09 07:26:34 +03:00
|
|
|
|
2019-01-13 09:47:35 +03:00
|
|
|
// Ring buffer sizes and read/write timeouts.
|
2018-01-09 07:26:34 +03:00
|
|
|
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
|
|
|
)
|
|
|
|
|
2019-01-16 09:12:37 +03:00
|
|
|
// RTMP connection properties.
|
2018-01-09 07:26:34 +03:00
|
|
|
const (
|
2019-01-13 09:40:17 +03:00
|
|
|
rtmpConnectionMaxTries = 5
|
2019-01-13 09:47:35 +03:00
|
|
|
rtmpConnectionTimeout = 10
|
|
|
|
)
|
|
|
|
|
2019-01-16 10:16:17 +03:00
|
|
|
// 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
|
|
|
|
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.
|
|
|
|
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
|
|
|
|
|
2018-10-19 03:50:08 +03:00
|
|
|
// 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
|
|
|
|
|
2018-10-19 03:50:08 +03:00
|
|
|
// buffer handles passing frames from the transcoder
|
2018-10-04 04:02:41 +03:00
|
|
|
// 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
|
2018-10-04 04:02:41 +03:00
|
|
|
|
|
|
|
// bitrate hold the last send bitrate calculation result.
|
|
|
|
bitrate int
|
|
|
|
|
2019-02-01 02:37:00 +03:00
|
|
|
mu sync.Mutex
|
2018-10-04 04:02:41 +03:00
|
|
|
isRunning bool
|
2019-01-31 07:33:50 +03:00
|
|
|
|
2019-02-03 14:25:40 +03:00
|
|
|
wg sync.WaitGroup
|
|
|
|
|
2019-01-31 07:33:50 +03:00
|
|
|
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
|
2018-10-19 03:50:08 +03:00
|
|
|
|
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
|
2019-02-16 16:22:40 +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.
|
2018-06-26 09:23:55 +03:00
|
|
|
func New(c Config, ns *netsender.Sender) (*Revid, error) {
|
2019-01-31 07:33:50 +03:00
|
|
|
r := Revid{ns: ns, err: make(chan error)}
|
2018-06-09 05:01:21 +03:00
|
|
|
err := r.reset(c)
|
2018-01-31 05:23:18 +03:00
|
|
|
if err != nil {
|
2018-06-09 05:01:21 +03:00
|
|
|
return nil, err
|
2018-01-31 05:23:18 +03:00
|
|
|
}
|
2019-01-31 12:12:20 +03:00
|
|
|
go r.handleErrors()
|
|
|
|
return &r, nil
|
|
|
|
}
|
|
|
|
|
2019-02-01 02:37:00 +03:00
|
|
|
// TODO(Saxon): put more thought into error severity.
|
2019-01-31 12:12:20 +03:00
|
|
|
func (r *Revid) handleErrors() {
|
|
|
|
for {
|
|
|
|
err := <-r.err
|
|
|
|
if err != nil {
|
|
|
|
r.config.Logger.Log(logger.Error, pkg+"async error", "error", err.Error())
|
2019-03-02 05:19:09 +03:00
|
|
|
r.Stop()
|
2019-01-31 12:12:20 +03:00
|
|
|
err = r.Start()
|
|
|
|
if err != nil {
|
2019-03-02 05:20:43 +03:00
|
|
|
r.config.Logger.Log(logger.Error, pkg+"failed to restart revid", "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 {
|
|
|
|
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
|
2018-02-10 09:59:56 +03:00
|
|
|
// configuration; checking validity and returning errors if not valid.
|
2018-06-09 05:01:21 +03:00
|
|
|
func (r *Revid) reset(config Config) error {
|
2018-02-10 09:59:56 +03:00
|
|
|
r.config.Logger = config.Logger
|
2018-02-10 10:08:14 +03:00
|
|
|
err := config.Validate(r)
|
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
|
|
|
}
|
2018-02-12 10:58:29 +03:00
|
|
|
r.config = config
|
2018-02-27 18:10:38 +03:00
|
|
|
|
2019-03-09 07:58:07 +03:00
|
|
|
r.buffer = (*buffer)(ring.NewBuffer(ringBufferSize, ringBufferElementSize, writeTimeout))
|
2018-11-25 09:54:52 +03:00
|
|
|
|
2019-03-13 10:44:00 +03:00
|
|
|
r.encoder = make([]stream.Encoder, 0)
|
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.
|
|
|
|
var mtsSenders, flvSenders []loadSender
|
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-03-12 05:29:10 +03:00
|
|
|
var sender loadSender
|
2019-03-09 07:58:07 +03:00
|
|
|
for _, out := range r.config.Outputs {
|
|
|
|
switch out {
|
|
|
|
case Http:
|
2019-03-12 13:23:27 +03:00
|
|
|
retry := false
|
|
|
|
if len(r.config.Outputs) == 1 {
|
|
|
|
retry = true
|
|
|
|
}
|
|
|
|
sender = newMtsSender(newMinimalHttpSender(r.ns, r.config.Logger.Log), retry, nil)
|
2019-03-09 07:58:07 +03:00
|
|
|
case Rtp:
|
2019-03-12 05:29:10 +03:00
|
|
|
sender, err = newRtpSender(r.config.RtpAddress, r.config.Logger.Log, r.config.FrameRate)
|
2019-03-09 07:58:07 +03:00
|
|
|
case File:
|
2019-03-12 05:29:10 +03:00
|
|
|
sender, err = newFileSender(r.config.OutputPath)
|
2019-03-09 07:58:07 +03:00
|
|
|
case Rtmp:
|
2019-03-13 10:44:00 +03:00
|
|
|
sender, _ = newRtmpSender(r.config.RtmpUrl, rtmpConnectionTimeout, rtmpConnectionMaxTries, false, r.config.Logger.Log)
|
2019-03-12 05:29:10 +03:00
|
|
|
flvSenders = append(flvSenders, sender)
|
|
|
|
continue
|
|
|
|
}
|
|
|
|
if err != nil {
|
|
|
|
return err
|
2019-03-09 07:58:07 +03:00
|
|
|
}
|
2019-03-12 05:29:10 +03:00
|
|
|
mtsSenders = append(mtsSenders, sender)
|
2019-03-09 07:58:07 +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-03-14 01:00:26 +03:00
|
|
|
ms := newMultiSender(mtsSenders, r.IsRunning)
|
2019-03-12 08:09:51 +03:00
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
2019-03-11 19:31:43 +03:00
|
|
|
e := mts.NewEncoder(ms, float64(r.config.FrameRate))
|
|
|
|
r.encoder = append(r.encoder, 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-03-14 01:00:26 +03:00
|
|
|
ms := newMultiSender(flvSenders, r.IsRunning)
|
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
|
2018-11-18 06:26:29 +03:00
|
|
|
}
|
2019-03-11 19:35:36 +03:00
|
|
|
r.encoder = append(r.encoder, e)
|
2018-02-10 09:59:56 +03:00
|
|
|
}
|
2018-02-27 18:10:38 +03:00
|
|
|
|
2018-02-10 09:59:56 +03:00
|
|
|
switch r.config.Input {
|
|
|
|
case Raspivid:
|
2018-06-24 15:01:09 +03:00
|
|
|
r.setupInput = r.startRaspivid
|
2019-01-17 08:34:04 +03:00
|
|
|
case V4L:
|
|
|
|
r.setupInput = r.startV4L
|
2018-02-10 09:59:56 +03:00
|
|
|
case File:
|
2018-02-12 10:58:29 +03:00
|
|
|
r.setupInput = r.setupInputForFile
|
2018-01-10 04:32:16 +03:00
|
|
|
}
|
2019-03-09 07:58:07 +03:00
|
|
|
|
2018-01-30 09:24:39 +03:00
|
|
|
switch r.config.InputCodec {
|
2018-01-31 05:23:18 +03:00
|
|
|
case H264:
|
2019-01-02 08:09:47 +03:00
|
|
|
r.config.Logger.Log(logger.Info, pkg+"using H264 lexer")
|
2018-08-23 08:36:32 +03:00
|
|
|
r.lexTo = lex.H264
|
2018-01-31 05:23:18 +03:00
|
|
|
case Mjpeg:
|
2019-01-02 08:09:47 +03:00
|
|
|
r.config.Logger.Log(logger.Info, pkg+"using MJPEG lexer")
|
2018-08-23 08:36:32 +03:00
|
|
|
r.lexTo = lex.MJPEG
|
2018-01-30 09:24:39 +03:00
|
|
|
}
|
2018-02-27 18:10:38 +03:00
|
|
|
|
2018-02-10 09:59:56 +03:00
|
|
|
return nil
|
2018-01-10 04:32:16 +03:00
|
|
|
}
|
|
|
|
|
2019-02-01 02:37:00 +03:00
|
|
|
// IsRunning returns true if revid is running.
|
2018-06-09 05:01:21 +03:00
|
|
|
func (r *Revid) IsRunning() bool {
|
2019-02-01 02:17:31 +03:00
|
|
|
r.mu.Lock()
|
|
|
|
ret := r.isRunning
|
|
|
|
r.mu.Unlock()
|
|
|
|
return ret
|
2018-02-10 09:59:56 +03:00
|
|
|
}
|
|
|
|
|
2019-02-03 13:47:44 +03:00
|
|
|
func (r *Revid) Config() Config {
|
|
|
|
r.mu.Lock()
|
2019-02-04 11:44:02 +03:00
|
|
|
cfg := r.config
|
2019-02-03 13:47:44 +03:00
|
|
|
r.mu.Unlock()
|
2019-02-04 11:44:02 +03:00
|
|
|
return cfg
|
2019-02-03 13:47:44 +03:00
|
|
|
}
|
|
|
|
|
2019-02-03 14:25:40 +03:00
|
|
|
// setIsRunning sets r.isRunning using b.
|
2019-02-01 02:37:00 +03:00
|
|
|
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
|
2018-02-27 18:10:38 +03:00
|
|
|
// and packetising (if theres packetization) to a defined output.
|
2019-01-13 14:31:04 +03:00
|
|
|
func (r *Revid) Start() error {
|
2019-02-01 02:17:31 +03:00
|
|
|
if r.IsRunning() {
|
2019-03-02 05:19:09 +03:00
|
|
|
r.config.Logger.Log(logger.Warning, pkg+"start called, but revid already running")
|
|
|
|
return nil
|
2018-02-10 09:59:56 +03:00
|
|
|
}
|
2019-01-02 08:09:47 +03:00
|
|
|
r.config.Logger.Log(logger.Info, pkg+"starting Revid")
|
2019-02-03 14:25:40 +03:00
|
|
|
// TODO: this doesn't need to be here
|
2019-01-02 08:09:47 +03:00
|
|
|
r.config.Logger.Log(logger.Debug, pkg+"setting up output")
|
2019-02-01 02:17:31 +03:00
|
|
|
r.setIsRunning(true)
|
2019-01-02 08:09:47 +03:00
|
|
|
r.config.Logger.Log(logger.Info, pkg+"starting output routine")
|
2019-02-03 14:25:40 +03:00
|
|
|
r.wg.Add(1)
|
2018-05-06 11:03:44 +03:00
|
|
|
go r.outputClips()
|
2019-01-02 08:09:47 +03:00
|
|
|
r.config.Logger.Log(logger.Info, pkg+"setting up input and receiving content")
|
2019-01-31 07:45:38 +03:00
|
|
|
err := r.setupInput()
|
2019-03-03 06:16:02 +03:00
|
|
|
if err != nil {
|
|
|
|
r.Stop()
|
|
|
|
}
|
2019-01-31 07:45:38 +03:00
|
|
|
return err
|
2018-02-10 09:59:56 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
// Stop halts any processing of video data from a camera or file
|
2019-03-02 05:12:36 +03:00
|
|
|
func (r *Revid) Stop() {
|
2019-02-01 02:17:31 +03:00
|
|
|
if !r.IsRunning() {
|
2019-03-02 05:12:36 +03:00
|
|
|
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
|
|
|
|
2019-01-02 08:09:47 +03:00
|
|
|
r.config.Logger.Log(logger.Info, pkg+"stopping revid")
|
2019-02-01 02:17:31 +03:00
|
|
|
r.setIsRunning(false)
|
2018-05-06 10:18:17 +03:00
|
|
|
|
2019-01-02 08:09:47 +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()
|
|
|
|
}
|
2019-02-03 14:25:40 +03:00
|
|
|
r.wg.Wait()
|
2018-02-10 09:59:56 +03:00
|
|
|
}
|
|
|
|
|
2019-02-03 13:47:44 +03:00
|
|
|
func (r *Revid) Update(vars map[string]string) error {
|
|
|
|
if r.IsRunning() {
|
2019-03-02 05:19:09 +03:00
|
|
|
r.Stop()
|
2019-02-03 13:47:44 +03:00
|
|
|
}
|
|
|
|
//look through the vars and update revid where needed
|
|
|
|
for key, value := range vars {
|
|
|
|
switch key {
|
|
|
|
case "Output":
|
2019-03-05 03:20:31 +03:00
|
|
|
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
|
|
|
|
}
|
2019-02-03 13:47:44 +03:00
|
|
|
}
|
2019-02-25 08:59:44 +03:00
|
|
|
|
2019-02-03 13:47:44 +03:00
|
|
|
case "RtmpUrl":
|
2019-02-03 14:25:40 +03:00
|
|
|
r.config.RtmpUrl = value
|
2019-03-05 09:08:32 +03:00
|
|
|
case "RtpAddr":
|
|
|
|
r.config.RtpAddress = value
|
2019-02-03 13:47:44 +03:00
|
|
|
case "Bitrate":
|
2019-02-03 16:07:38 +03:00
|
|
|
v, err := strconv.ParseUint(value, 10, 0)
|
2019-02-03 13:47:44 +03:00
|
|
|
if err != nil {
|
2019-02-03 16:07:38 +03:00
|
|
|
r.config.Logger.Log(logger.Warning, pkg+"invalid framerate param", "value", value)
|
2019-02-03 13:47:44 +03:00
|
|
|
break
|
|
|
|
}
|
2019-02-03 16:07:38 +03:00
|
|
|
r.config.Bitrate = uint(v)
|
2019-02-12 10:52:46 +03:00
|
|
|
case "OutputPath":
|
|
|
|
r.config.OutputPath = value
|
|
|
|
case "InputPath":
|
|
|
|
r.config.InputPath = value
|
2019-02-03 13:47:44 +03:00
|
|
|
case "Height":
|
|
|
|
h, err := strconv.ParseUint(value, 10, 0)
|
|
|
|
if err != nil {
|
2019-02-03 16:07:38 +03:00
|
|
|
r.config.Logger.Log(logger.Warning, pkg+"invalid height param", "value", value)
|
2019-02-03 13:47:44 +03:00
|
|
|
break
|
|
|
|
}
|
2019-02-03 14:25:40 +03:00
|
|
|
r.config.Height = uint(h)
|
2019-02-03 13:47:44 +03:00
|
|
|
case "Width":
|
|
|
|
w, err := strconv.ParseUint(value, 10, 0)
|
|
|
|
if err != nil {
|
2019-02-03 16:07:38 +03:00
|
|
|
r.config.Logger.Log(logger.Warning, pkg+"invalid width param", "value", value)
|
2019-02-03 13:47:44 +03:00
|
|
|
break
|
|
|
|
}
|
2019-02-03 14:25:40 +03:00
|
|
|
r.config.Width = uint(w)
|
2019-02-03 13:47:44 +03:00
|
|
|
case "FrameRate":
|
2019-02-03 16:07:38 +03:00
|
|
|
v, err := strconv.ParseUint(value, 10, 0)
|
2019-02-03 13:47:44 +03:00
|
|
|
if err != nil {
|
2019-02-03 16:07:38 +03:00
|
|
|
r.config.Logger.Log(logger.Warning, pkg+"invalid framerate param", "value", value)
|
2019-02-03 13:47:44 +03:00
|
|
|
break
|
|
|
|
}
|
2019-02-03 16:07:38 +03:00
|
|
|
r.config.FrameRate = uint(v)
|
2019-03-04 04:52:39 +03:00
|
|
|
case "Rotation":
|
2019-03-04 04:37:28 +03:00
|
|
|
v, err := strconv.ParseUint(value, 10, 0)
|
|
|
|
if err != nil || v > 359 {
|
2019-03-04 04:41:34 +03:00
|
|
|
r.config.Logger.Log(logger.Warning, pkg+"invalid rotation param", "value", value)
|
2019-03-04 04:37:28 +03:00
|
|
|
break
|
|
|
|
}
|
2019-03-04 04:41:34 +03:00
|
|
|
r.config.Rotation = uint(v)
|
2019-02-03 13:47:44 +03:00
|
|
|
case "HttpAddress":
|
2019-02-03 14:25:40 +03:00
|
|
|
r.config.HttpAddress = value
|
2019-02-03 13:47:44 +03:00
|
|
|
case "Quantization":
|
|
|
|
q, err := strconv.ParseUint(value, 10, 0)
|
|
|
|
if err != nil {
|
2019-02-03 16:07:38 +03:00
|
|
|
r.config.Logger.Log(logger.Warning, pkg+"invalid quantization param", "value", value)
|
2019-02-03 13:47:44 +03:00
|
|
|
break
|
|
|
|
}
|
2019-02-03 14:25:40 +03:00
|
|
|
r.config.Quantization = uint(q)
|
2019-02-03 13:47:44 +03:00
|
|
|
case "IntraRefreshPeriod":
|
|
|
|
p, err := strconv.ParseUint(value, 10, 0)
|
|
|
|
if err != nil {
|
2019-02-03 16:07:38 +03:00
|
|
|
r.config.Logger.Log(logger.Warning, pkg+"invalid intrarefreshperiod param", "value", value)
|
2019-02-03 13:47:44 +03:00
|
|
|
break
|
|
|
|
}
|
2019-02-03 14:25:40 +03:00
|
|
|
r.config.IntraRefreshPeriod = uint(p)
|
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-02-03 14:25:40 +03:00
|
|
|
r.config.FlipHorizontal = true
|
2019-02-03 13:47:44 +03:00
|
|
|
case "false":
|
2019-02-03 14:25:40 +03:00
|
|
|
r.config.FlipHorizontal = false
|
2019-02-03 13:47:44 +03:00
|
|
|
default:
|
2019-02-03 16:07:38 +03:00
|
|
|
r.config.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-02-03 14:25:40 +03:00
|
|
|
r.config.FlipVertical = true
|
2019-02-03 13:47:44 +03:00
|
|
|
case "false":
|
2019-02-03 14:25:40 +03:00
|
|
|
r.config.FlipVertical = false
|
2019-02-03 13:47:44 +03:00
|
|
|
default:
|
2019-02-03 16:07:38 +03:00
|
|
|
r.config.Logger.Log(logger.Warning, pkg+"invalid VerticalFlip param", "value", value)
|
2019-02-03 13:47:44 +03:00
|
|
|
}
|
2019-02-03 16:13:51 +03:00
|
|
|
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-03 13:47:44 +03:00
|
|
|
}
|
|
|
|
}
|
2019-02-25 11:09:01 +03:00
|
|
|
r.config.Logger.Log(logger.Info, pkg+"revid config changed", "config", fmt.Sprintf("%+v", r.config))
|
2019-02-25 08:17:43 +03:00
|
|
|
return r.reset(r.config)
|
2019-02-03 13:47:44 +03:00
|
|
|
}
|
|
|
|
|
2018-02-10 09:59:56 +03:00
|
|
|
// 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() {
|
2019-02-05 03:20:21 +03:00
|
|
|
defer r.wg.Done()
|
2018-10-19 13:41:02 +03:00
|
|
|
lastTime := time.Now()
|
|
|
|
var count int
|
|
|
|
loop:
|
2019-02-01 02:17:31 +03:00
|
|
|
for r.IsRunning() {
|
2018-10-19 03:50:08 +03:00
|
|
|
// 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)
|
2018-10-19 13:41:02 +03:00
|
|
|
switch err {
|
|
|
|
case nil:
|
|
|
|
// Do nothing.
|
|
|
|
case ring.ErrTimeout:
|
2019-02-25 10:14:30 +03:00
|
|
|
r.config.Logger.Log(logger.Debug, pkg+"ring buffer read timeout")
|
2018-05-30 14:24:30 +03:00
|
|
|
continue
|
2018-10-19 13:41:02 +03:00
|
|
|
default:
|
2019-01-02 08:09:47 +03:00
|
|
|
r.config.Logger.Log(logger.Error, pkg+"unexpected error", "error", err.Error())
|
2018-10-19 13:41:02 +03:00
|
|
|
fallthrough
|
|
|
|
case io.EOF:
|
|
|
|
break loop
|
2018-05-30 14:24:30 +03:00
|
|
|
}
|
2018-05-03 07:58:14 +03:00
|
|
|
|
2019-03-09 07:58:07 +03:00
|
|
|
// Loop over encoders and hand bytes over to each one.
|
2019-03-13 04:55:57 +03:00
|
|
|
for _, e := range r.encoder {
|
|
|
|
_, err := chunk.WriteTo(e)
|
2018-11-22 02:51:25 +03:00
|
|
|
if err != nil {
|
2019-03-10 05:04:45 +03:00
|
|
|
r.err <- err
|
2018-11-22 02:51:25 +03:00
|
|
|
}
|
2018-11-25 15:40:38 +03:00
|
|
|
}
|
2018-05-30 14:24:30 +03:00
|
|
|
|
2019-03-10 05:04:45 +03:00
|
|
|
// Release the chunk back to the ring buffer.
|
2019-03-09 07:58:07 +03:00
|
|
|
chunk.Close()
|
2018-05-30 14:24:30 +03:00
|
|
|
|
2019-03-09 07:58:07 +03:00
|
|
|
// FIXME(saxon): this doesn't work anymore.
|
2018-10-19 13:41:02 +03:00
|
|
|
now := time.Now()
|
|
|
|
deltaTime := now.Sub(lastTime)
|
2018-06-08 06:18:11 +03:00
|
|
|
if deltaTime > bitrateTime {
|
2018-06-17 14:27:50 +03:00
|
|
|
// FIXME(kortschak): For subsecond deltaTime, this will give infinite bitrate.
|
2018-10-19 13:41:02 +03:00
|
|
|
r.bitrate = int(float64(count*8) / float64(deltaTime/time.Second))
|
2019-01-02 08:09:47 +03:00
|
|
|
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())
|
2018-10-19 13:41:02 +03:00
|
|
|
lastTime = now
|
|
|
|
count = 0
|
2018-02-10 09:59:56 +03:00
|
|
|
}
|
|
|
|
}
|
2019-01-02 08:09:47 +03:00
|
|
|
r.config.Logger.Log(logger.Info, pkg+"not outputting clips anymore")
|
2018-01-23 08:13:13 +03:00
|
|
|
}
|
|
|
|
|
2018-06-24 15:01:09 +03:00
|
|
|
// startRaspivid sets up things for input from raspivid i.e. starts
|
2018-02-27 18:10:38 +03:00
|
|
|
// a raspivid process and pipes it's data output.
|
2018-06-24 15:01:09 +03:00
|
|
|
func (r *Revid) startRaspivid() error {
|
2019-01-02 08:09:47 +03:00
|
|
|
r.config.Logger.Log(logger.Info, pkg+"starting raspivid")
|
2018-10-03 15:39:51 +03:00
|
|
|
|
2018-10-05 01:26:26 +03:00
|
|
|
const disabled = "0"
|
|
|
|
args := []string{
|
|
|
|
"--output", "-",
|
|
|
|
"--nopreview",
|
|
|
|
"--timeout", disabled,
|
2018-12-10 02:09:20 +03:00
|
|
|
"--width", fmt.Sprint(r.config.Width),
|
|
|
|
"--height", fmt.Sprint(r.config.Height),
|
|
|
|
"--bitrate", fmt.Sprint(r.config.Bitrate),
|
|
|
|
"--framerate", fmt.Sprint(r.config.FrameRate),
|
2019-03-04 04:41:34 +03:00
|
|
|
"--rotation", fmt.Sprint(r.config.Rotation),
|
2018-10-05 01:26:26 +03:00
|
|
|
}
|
2019-03-04 04:37:28 +03:00
|
|
|
|
2018-12-05 12:24:52 +03:00
|
|
|
if r.config.FlipVertical {
|
2018-10-05 01:26:26 +03:00
|
|
|
args = append(args, "--vflip")
|
|
|
|
}
|
2019-03-06 04:38:13 +03:00
|
|
|
if r.config.FlipHorizontal {
|
|
|
|
args = append(args, "--hflip")
|
2019-03-06 04:21:55 +03:00
|
|
|
}
|
|
|
|
|
2018-02-10 09:59:56 +03:00
|
|
|
switch r.config.InputCodec {
|
2018-10-03 15:39:51 +03:00
|
|
|
default:
|
|
|
|
return fmt.Errorf("revid: invalid input codec: %v", r.config.InputCodec)
|
2018-02-10 09:59:56 +03:00
|
|
|
case H264:
|
2018-10-05 01:26:26 +03:00
|
|
|
args = append(args,
|
|
|
|
"--codec", "H264",
|
|
|
|
"--inline",
|
2018-12-10 02:09:20 +03:00
|
|
|
"--intra", fmt.Sprint(r.config.IntraRefreshPeriod),
|
2018-10-05 01:26:26 +03:00
|
|
|
)
|
2018-12-10 02:09:20 +03:00
|
|
|
if r.config.Quantize {
|
|
|
|
args = append(args, "-qp", fmt.Sprint(r.config.Quantization))
|
2018-05-05 07:15:07 +03:00
|
|
|
}
|
2018-02-10 09:59:56 +03:00
|
|
|
case Mjpeg:
|
2018-10-05 01:26:26 +03:00
|
|
|
args = append(args, "--codec", "MJPEG")
|
2018-02-09 09:23:06 +03:00
|
|
|
}
|
2019-01-02 08:09:47 +03:00
|
|
|
r.config.Logger.Log(logger.Info, pkg+"raspivid args", "raspividArgs", strings.Join(args, " "))
|
2018-10-03 15:39:51 +03:00
|
|
|
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 {
|
2019-01-02 08:09:47 +03:00
|
|
|
r.config.Logger.Log(logger.Fatal, pkg+"cannot start raspivid", "error", err.Error())
|
2018-06-24 15:01:09 +03:00
|
|
|
}
|
2018-09-24 13:26:05 +03:00
|
|
|
|
2019-02-03 14:25:40 +03:00
|
|
|
r.wg.Add(1)
|
2019-02-01 02:38:49 +03:00
|
|
|
go r.processFrom(stdout, 0)
|
2019-01-31 07:33:50 +03:00
|
|
|
return nil
|
2018-02-10 09:59:56 +03:00
|
|
|
}
|
|
|
|
|
2019-01-17 08:34:04 +03:00
|
|
|
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")
|
2019-02-12 10:52:46 +03:00
|
|
|
if r.config.InputPath == "" {
|
2019-01-17 08:34:04 +03:00
|
|
|
r.config.Logger.Log(logger.Info, pkg+"using default video device", "device", defaultVideo)
|
2019-02-12 10:52:46 +03:00
|
|
|
r.config.InputPath = defaultVideo
|
2019-01-17 08:34:04 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
args := []string{
|
2019-02-12 10:52:46 +03:00
|
|
|
"-i", r.config.InputPath,
|
2019-01-17 08:34:04 +03:00
|
|
|
"-f", "h264",
|
|
|
|
"-r", fmt.Sprint(r.config.FrameRate),
|
|
|
|
}
|
2019-03-04 04:37:28 +03:00
|
|
|
|
2019-01-17 08:34:04 +03:00
|
|
|
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...)
|
2018-12-28 03:14:53 +03:00
|
|
|
|
|
|
|
stdout, err := r.cmd.StdoutPipe()
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
2019-01-03 02:41:42 +03:00
|
|
|
|
2018-12-28 03:14:53 +03:00
|
|
|
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())
|
2018-12-28 03:14:53 +03:00
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
2019-02-03 14:25:40 +03:00
|
|
|
r.wg.Add(1)
|
2019-02-01 02:17:31 +03:00
|
|
|
go r.processFrom(stdout, time.Duration(0))
|
2019-01-31 07:33:50 +03:00
|
|
|
return nil
|
2018-12-28 03:14:53 +03:00
|
|
|
}
|
|
|
|
|
2018-06-24 15:01:09 +03:00
|
|
|
// setupInputForFile sets things up for getting input from a file
|
|
|
|
func (r *Revid) setupInputForFile() error {
|
2019-02-12 10:52:46 +03:00
|
|
|
f, err := os.Open(r.config.InputPath)
|
2018-02-15 10:02:04 +03:00
|
|
|
if err != nil {
|
2019-01-14 09:07:18 +03:00
|
|
|
r.config.Logger.Log(logger.Error, err.Error())
|
2018-02-15 10:02:04 +03:00
|
|
|
r.Stop()
|
|
|
|
return err
|
|
|
|
}
|
2018-06-24 15:01:09 +03:00
|
|
|
defer f.Close()
|
2018-11-24 04:44:44 +03:00
|
|
|
|
2018-06-28 11:54:23 +03:00
|
|
|
// TODO(kortschak): Maybe we want a context.Context-aware parser that we can stop.
|
2019-02-03 14:25:40 +03:00
|
|
|
r.wg.Add(1)
|
2019-02-01 02:17:31 +03:00
|
|
|
go r.processFrom(f, time.Second/time.Duration(r.config.FrameRate))
|
2019-01-31 07:33:50 +03:00
|
|
|
return nil
|
2018-02-09 09:23:06 +03:00
|
|
|
}
|
2019-01-31 12:12:20 +03:00
|
|
|
|
2019-02-01 02:17:31 +03:00
|
|
|
func (r *Revid) processFrom(read io.Reader, delay time.Duration) {
|
2019-01-31 12:12:20 +03:00
|
|
|
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)
|
2019-01-31 12:12:20 +03:00
|
|
|
r.config.Logger.Log(logger.Info, pkg+"finished reading input data")
|
2019-02-03 14:25:40 +03:00
|
|
|
r.wg.Done()
|
2019-01-31 12:12:20 +03:00
|
|
|
}
|