2018-01-09 07:26:34 +03:00
|
|
|
/*
|
|
|
|
NAME
|
2018-06-09 08:28:33 +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 (
|
|
|
|
"bufio"
|
2018-01-31 04:00:03 +03:00
|
|
|
"errors"
|
2018-01-09 07:26:34 +03:00
|
|
|
"fmt"
|
2018-01-16 08:06:51 +03:00
|
|
|
"io"
|
2018-01-09 07:26:34 +03:00
|
|
|
"os"
|
|
|
|
"os/exec"
|
2018-05-06 11:38:45 +03:00
|
|
|
"path/filepath"
|
2018-01-09 07:26:34 +03:00
|
|
|
"strconv"
|
2018-04-16 07:54:21 +03:00
|
|
|
"time"
|
2018-02-14 10:02:57 +03:00
|
|
|
|
2018-03-13 08:32:52 +03:00
|
|
|
"bitbucket.org/ausocean/av/generator"
|
2018-03-14 04:18:03 +03:00
|
|
|
"bitbucket.org/ausocean/av/parser"
|
2018-03-13 11:29:18 +03:00
|
|
|
"bitbucket.org/ausocean/av/rtmp"
|
2018-06-07 09:15:14 +03:00
|
|
|
"bitbucket.org/ausocean/utils/ring"
|
2018-05-07 14:46:40 +03:00
|
|
|
)
|
2018-01-09 07:26:34 +03:00
|
|
|
|
2018-01-31 02:51:53 +03:00
|
|
|
// Misc constants
|
2018-01-09 07:26:34 +03:00
|
|
|
const (
|
2018-06-08 06:18:11 +03:00
|
|
|
clipDuration = 1 * time.Second
|
|
|
|
mp2tPacketSize = 188 // MPEG-TS packet size
|
|
|
|
mp2tMaxPackets = int(clipDuration * 2016 / time.Second) // # first multiple of 7 and 8 greater than 2000
|
2018-05-06 11:38:45 +03:00
|
|
|
ringBufferSize = 500
|
|
|
|
ringBufferElementSize = 150000
|
2018-05-30 14:24:30 +03:00
|
|
|
writeTimeout = 10 * time.Millisecond
|
|
|
|
readTimeout = 10 * time.Millisecond
|
2018-06-08 06:18:11 +03:00
|
|
|
httpTimeout = 5 * time.Second
|
2018-05-06 11:38:45 +03:00
|
|
|
packetsPerFrame = 7
|
2018-06-08 06:18:11 +03:00
|
|
|
bitrateTime = 1 * time.Minute
|
2018-05-06 11:38:45 +03:00
|
|
|
mjpegParserInChanLen = 100000
|
|
|
|
ffmpegPath = "/usr/local/bin/ffmpeg"
|
|
|
|
rtmpConnectionTimout = 10
|
|
|
|
outputChanSize = 1000
|
|
|
|
cameraRetryPeriod = 5 * time.Second
|
|
|
|
sendFailedDelay = 5
|
2018-04-24 08:38:30 +03:00
|
|
|
maxSendFailedErrorCount = 500
|
2018-05-06 11:38:45 +03:00
|
|
|
clipSizeThreshold = 11
|
|
|
|
rtmpConnectionMaxTries = 5
|
|
|
|
raspividNoOfTries = 3
|
2018-06-08 06:18:11 +03:00
|
|
|
sendingWaitTime = 5 * time.Millisecond
|
2018-01-10 06:57:56 +03:00
|
|
|
)
|
|
|
|
|
2018-01-24 07:12:22 +03:00
|
|
|
// Log Types
|
2018-01-24 04:40:03 +03:00
|
|
|
const (
|
2018-01-24 07:12:22 +03:00
|
|
|
Error = "Error"
|
2018-01-24 04:40:03 +03:00
|
|
|
Warning = "Warning"
|
2018-01-24 07:12:22 +03:00
|
|
|
Info = "Info"
|
|
|
|
Debug = "Debug"
|
2018-05-07 14:46:40 +03:00
|
|
|
Detail = "Detail"
|
2018-01-24 04:40:03 +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-05-06 11:38:45 +03:00
|
|
|
ffmpegPath string
|
|
|
|
tempDir string
|
2018-05-30 14:24:30 +03:00
|
|
|
ringBuffer *ring.Buffer
|
2018-05-06 11:38:45 +03:00
|
|
|
config Config
|
|
|
|
isRunning bool
|
|
|
|
inputFile *os.File
|
|
|
|
generator generator.Generator
|
|
|
|
parser parser.Parser
|
|
|
|
cmd *exec.Cmd
|
|
|
|
inputReader *bufio.Reader
|
|
|
|
ffmpegStdin io.WriteCloser
|
|
|
|
outputChan chan []byte
|
|
|
|
setupInput func() error
|
|
|
|
getFrame func() []byte
|
2018-06-09 07:38:48 +03:00
|
|
|
destination loadSender
|
2018-05-29 08:56:36 +03:00
|
|
|
rtmpInst rtmp.Session
|
2018-04-24 08:38:30 +03:00
|
|
|
currentBitrate int64
|
2018-01-23 06:15:06 +03:00
|
|
|
}
|
|
|
|
|
2018-06-09 05:01:21 +03:00
|
|
|
// NewRevid returns a pointer to a new Revid with the desired
|
2018-01-31 02:51:53 +03:00
|
|
|
// configuration, and/or an error if construction of the new instant was not
|
|
|
|
// successful.
|
2018-06-09 05:01:21 +03:00
|
|
|
func New(c Config) (*Revid, error) {
|
|
|
|
var r Revid
|
|
|
|
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
|
|
|
}
|
2018-06-09 05:01:21 +03:00
|
|
|
r.ringBuffer = ring.NewBuffer(ringBufferSize, ringBufferElementSize, writeTimeout)
|
2018-03-13 07:33:31 +03:00
|
|
|
r.outputChan = make(chan []byte, outputChanSize)
|
2018-06-09 05:01:21 +03:00
|
|
|
return &r, nil
|
2018-02-10 09:59:56 +03:00
|
|
|
}
|
|
|
|
|
2018-04-24 08:38:30 +03:00
|
|
|
// Returns the currently saved bitrate from the most recent bitrate check
|
|
|
|
// check bitrate output delay in consts for this period
|
2018-06-09 05:01:21 +03:00
|
|
|
func (r *Revid) GetBitrate() int64 {
|
2018-04-24 08:38:30 +03:00
|
|
|
return r.currentBitrate
|
|
|
|
}
|
|
|
|
|
2018-02-10 09:59:56 +03:00
|
|
|
// GetConfigRef returns a pointer to the revidInst's Config struct object
|
2018-06-09 05:01:21 +03:00
|
|
|
func (r *Revid) GetConfigRef() *Config {
|
2018-02-10 09:59:56 +03:00
|
|
|
return &r.config
|
|
|
|
}
|
|
|
|
|
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 {
|
|
|
|
return errors.New("Config struct is bad!: " + err.Error())
|
|
|
|
}
|
2018-02-12 10:58:29 +03:00
|
|
|
r.config = config
|
2018-02-27 18:10:38 +03:00
|
|
|
|
2018-06-09 07:38:48 +03:00
|
|
|
if r.destination != nil {
|
|
|
|
err = r.destination.close()
|
|
|
|
if err != nil {
|
|
|
|
r.Log(Error, err.Error())
|
|
|
|
}
|
|
|
|
}
|
2018-01-23 06:15:06 +03:00
|
|
|
switch r.config.Output {
|
2018-01-31 05:23:18 +03:00
|
|
|
case File:
|
2018-06-09 07:38:48 +03:00
|
|
|
s, err := newFileSender(config.OutputFileName)
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
r.destination = s
|
2018-04-16 08:25:28 +03:00
|
|
|
case FfmpegRtmp:
|
2018-06-09 07:38:48 +03:00
|
|
|
s, err := newFfmpegSender(config.RtmpUrl, r.config.FrameRate)
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
r.destination = s
|
2018-04-16 08:25:28 +03:00
|
|
|
case NativeRtmp:
|
2018-06-09 07:38:48 +03:00
|
|
|
s, err := newRtmpSender(config.RtmpUrl, rtmpConnectionTimout, rtmpConnectionMaxTries, r.Log)
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
r.destination = s
|
2018-02-12 10:58:29 +03:00
|
|
|
case Http:
|
2018-06-09 07:38:48 +03:00
|
|
|
r.destination = newHttpSender(config.RtmpUrl, httpTimeout, r.Log)
|
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-02-12 10:58:29 +03:00
|
|
|
r.setupInput = r.setupInputForRaspivid
|
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
|
|
|
}
|
2018-01-30 09:24:39 +03:00
|
|
|
switch r.config.InputCodec {
|
2018-01-31 05:23:18 +03:00
|
|
|
case H264:
|
|
|
|
r.Log(Info, "Using H264 parser!")
|
2018-01-30 09:24:39 +03:00
|
|
|
r.parser = parser.NewH264Parser()
|
2018-01-31 05:23:18 +03:00
|
|
|
case Mjpeg:
|
2018-02-10 09:59:56 +03:00
|
|
|
r.Log(Info, "Using MJPEG parser!")
|
2018-01-30 09:24:39 +03:00
|
|
|
r.parser = parser.NewMJPEGParser(mjpegParserInChanLen)
|
|
|
|
}
|
2018-02-27 18:10:38 +03:00
|
|
|
|
|
|
|
switch r.config.Packetization {
|
|
|
|
case None:
|
|
|
|
// no packetisation - Revid output chan grabs raw data straight from parser
|
2018-02-09 09:23:06 +03:00
|
|
|
r.parser.SetOutputChan(r.outputChan)
|
2018-02-12 10:58:29 +03:00
|
|
|
r.getFrame = r.getFrameNoPacketization
|
2018-06-09 08:28:33 +03:00
|
|
|
return nil
|
2018-02-27 18:10:38 +03:00
|
|
|
case Mpegts:
|
|
|
|
r.Log(Info, "Using MPEGTS packetisation!")
|
|
|
|
frameRateAsInt, _ := strconv.Atoi(r.config.FrameRate)
|
|
|
|
r.generator = generator.NewTsGenerator(uint(frameRateAsInt))
|
|
|
|
case Flv:
|
|
|
|
r.Log(Info, "Using FLV packetisation!")
|
|
|
|
frameRateAsInt, _ := strconv.Atoi(r.config.FrameRate)
|
|
|
|
r.generator = generator.NewFlvGenerator(true, true, uint(frameRateAsInt))
|
2018-01-30 09:24:39 +03:00
|
|
|
}
|
2018-02-27 18:10:38 +03:00
|
|
|
// We have packetization of some sort, so we want to send data to Generator
|
|
|
|
// to perform packetization
|
|
|
|
r.getFrame = r.getFramePacketization
|
|
|
|
r.parser.SetOutputChan(r.generator.GetInputChan())
|
|
|
|
|
2018-02-10 09:59:56 +03:00
|
|
|
return nil
|
2018-01-10 04:32:16 +03:00
|
|
|
}
|
|
|
|
|
2018-06-09 05:01:21 +03:00
|
|
|
// ChangeConfig changes the current configuration of the Revid instance.
|
|
|
|
func (r *Revid) ChangeConfig(c Config) error {
|
2018-06-07 14:50:57 +03:00
|
|
|
// FIXME(kortschak): This is reimplemented in cmd/revid-cli/main.go.
|
|
|
|
// The implementation in the command is used and this is not.
|
|
|
|
// Decide on one or the other.
|
|
|
|
|
2018-03-17 16:29:42 +03:00
|
|
|
r.Stop()
|
2018-06-09 05:01:21 +03:00
|
|
|
r, err := New(c)
|
2018-03-17 16:29:42 +03:00
|
|
|
if err != nil {
|
2018-06-09 05:01:21 +03:00
|
|
|
return err
|
2018-03-17 16:29:42 +03:00
|
|
|
}
|
|
|
|
r.Start()
|
2018-06-09 08:28:33 +03:00
|
|
|
return nil
|
2018-03-17 16:29:42 +03:00
|
|
|
}
|
|
|
|
|
2018-02-10 09:59:56 +03:00
|
|
|
// Log takes a logtype and message and tries to send this information to the
|
2018-04-16 08:12:16 +03:00
|
|
|
// logger provided in the revid config - if there is one, otherwise the message
|
2018-02-10 09:59:56 +03:00
|
|
|
// is sent to stdout
|
2018-06-09 05:01:21 +03:00
|
|
|
func (r *Revid) Log(logType, m string) {
|
2018-06-09 08:28:33 +03:00
|
|
|
if r.config.Verbosity != Yes {
|
|
|
|
return
|
2018-02-10 09:59:56 +03:00
|
|
|
}
|
2018-06-09 08:28:33 +03:00
|
|
|
if r.config.Logger != nil {
|
|
|
|
r.config.Logger.Log("revid", logType, m)
|
|
|
|
return
|
|
|
|
}
|
|
|
|
fmt.Println(logType + ": " + m)
|
2018-01-24 07:12:22 +03:00
|
|
|
}
|
|
|
|
|
2018-04-16 08:12:16 +03:00
|
|
|
// IsRunning returns true if the revid is currently running and false otherwise
|
2018-06-09 05:01:21 +03:00
|
|
|
func (r *Revid) IsRunning() bool {
|
2018-02-10 09:59:56 +03:00
|
|
|
return r.isRunning
|
|
|
|
}
|
|
|
|
|
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.
|
2018-06-09 05:01:21 +03:00
|
|
|
func (r *Revid) Start() {
|
2018-02-10 09:59:56 +03:00
|
|
|
if r.isRunning {
|
2018-06-09 05:01:21 +03:00
|
|
|
r.Log(Warning, "Revid.Start() called but revid already running!")
|
2018-02-10 09:59:56 +03:00
|
|
|
return
|
|
|
|
}
|
|
|
|
r.Log(Info, "Starting Revid!")
|
2018-05-06 11:12:02 +03:00
|
|
|
r.Log(Debug, "Setting up output!")
|
2018-05-06 11:03:44 +03:00
|
|
|
r.isRunning = true
|
2018-05-06 11:12:02 +03:00
|
|
|
r.Log(Info, "Starting output routine!")
|
2018-05-06 11:03:44 +03:00
|
|
|
go r.outputClips()
|
2018-05-06 11:12:02 +03:00
|
|
|
r.Log(Info, "Starting clip packing routine!")
|
|
|
|
go r.packClips()
|
|
|
|
r.Log(Info, "Starting packetisation generator!")
|
2018-05-06 10:54:36 +03:00
|
|
|
r.generator.Start()
|
2018-05-06 11:12:02 +03:00
|
|
|
r.Log(Info, "Starting parser!")
|
|
|
|
r.parser.Start()
|
2018-05-07 16:09:58 +03:00
|
|
|
r.Log(Info, "Setting up input and receiving content!")
|
2018-05-06 11:03:44 +03:00
|
|
|
go r.setupInput()
|
2018-02-10 09:59:56 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
// Stop halts any processing of video data from a camera or file
|
2018-06-09 05:01:21 +03:00
|
|
|
func (r *Revid) Stop() {
|
2018-03-17 16:29:42 +03:00
|
|
|
if !r.isRunning {
|
2018-06-09 05:01:21 +03:00
|
|
|
r.Log(Warning, "Revid.Stop() called but revid not running!")
|
2018-03-17 16:29:42 +03:00
|
|
|
return
|
|
|
|
}
|
2018-05-07 05:53:50 +03:00
|
|
|
|
2018-04-16 07:54:21 +03:00
|
|
|
r.Log(Info, "Stopping revid!")
|
|
|
|
r.isRunning = false
|
2018-05-06 10:18:17 +03:00
|
|
|
|
2018-05-06 11:12:02 +03:00
|
|
|
r.Log(Info, "Stopping generator!")
|
2018-05-06 10:18:17 +03:00
|
|
|
if r.generator != nil {
|
|
|
|
r.generator.Stop()
|
|
|
|
}
|
|
|
|
|
2018-05-06 11:12:02 +03:00
|
|
|
r.Log(Info, "Stopping parser!")
|
2018-05-06 10:18:17 +03:00
|
|
|
if r.parser != nil {
|
|
|
|
r.parser.Stop()
|
|
|
|
}
|
2018-05-06 11:12:02 +03:00
|
|
|
|
|
|
|
r.Log(Info, "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()
|
|
|
|
}
|
2018-02-10 09:59:56 +03:00
|
|
|
}
|
|
|
|
|
2018-02-27 18:10:38 +03:00
|
|
|
// getFrameNoPacketization gets a frame directly from the revid output chan
|
|
|
|
// as we don't need to go through the generator with no packetization settings
|
2018-06-09 05:01:21 +03:00
|
|
|
func (r *Revid) getFrameNoPacketization() []byte {
|
2018-02-12 10:58:29 +03:00
|
|
|
return <-r.outputChan
|
2018-02-10 09:59:56 +03:00
|
|
|
}
|
|
|
|
|
2018-02-27 18:10:38 +03:00
|
|
|
// getFramePacketization gets a frame from the generators output chan - the
|
|
|
|
// the generator being an mpegts or flv generator depending on the config
|
2018-06-09 05:01:21 +03:00
|
|
|
func (r *Revid) getFramePacketization() []byte {
|
2018-06-09 08:28:33 +03:00
|
|
|
return <-r.generator.GetOutputChan()
|
2018-02-10 09:59:56 +03:00
|
|
|
}
|
|
|
|
|
2018-02-27 18:10:38 +03:00
|
|
|
// packClips takes data segments; whether that be tsPackets or mjpeg frames and
|
|
|
|
// packs them into clips consisting of the amount frames specified in the config
|
2018-06-09 05:01:21 +03:00
|
|
|
func (r *Revid) packClips() {
|
2018-02-10 09:59:56 +03:00
|
|
|
clipSize := 0
|
|
|
|
packetCount := 0
|
2018-05-06 10:46:38 +03:00
|
|
|
for r.isRunning {
|
2018-05-30 14:24:30 +03:00
|
|
|
select {
|
|
|
|
// TODO: This is temporary, need to work out how to make this work
|
|
|
|
// for cases when there is not packetisation.
|
|
|
|
case frame := <-r.generator.GetOutputChan():
|
|
|
|
lenOfFrame := len(frame)
|
|
|
|
if lenOfFrame > ringBufferElementSize {
|
|
|
|
r.Log(Warning, fmt.Sprintf("Frame was too big: %v bytes, getting another one!", lenOfFrame))
|
|
|
|
frame = r.getFrame()
|
|
|
|
lenOfFrame = len(frame)
|
|
|
|
}
|
|
|
|
_, err := r.ringBuffer.Write(frame)
|
|
|
|
if err != nil {
|
2018-05-24 05:28:49 +03:00
|
|
|
r.Log(Error, err.Error())
|
2018-05-31 01:17:14 +03:00
|
|
|
if err == ring.ErrDropped {
|
2018-05-30 14:24:30 +03:00
|
|
|
r.Log(Warning, fmt.Sprintf("dropped %d byte frame", len(frame)))
|
|
|
|
}
|
2018-05-24 05:28:49 +03:00
|
|
|
}
|
2018-05-30 14:24:30 +03:00
|
|
|
packetCount++
|
|
|
|
clipSize += lenOfFrame
|
|
|
|
fpcAsInt, err := strconv.Atoi(r.config.FramesPerClip)
|
|
|
|
if err != nil {
|
|
|
|
r.Log(Error, "Frames per clip not quite right! Defaulting to 1!")
|
|
|
|
r.config.FramesPerClip = "1"
|
2018-04-24 07:17:05 +03:00
|
|
|
}
|
2018-05-30 14:24:30 +03:00
|
|
|
if packetCount >= fpcAsInt {
|
|
|
|
r.ringBuffer.Flush()
|
|
|
|
clipSize = 0
|
|
|
|
packetCount = 0
|
|
|
|
continue
|
2018-02-10 09:59:56 +03:00
|
|
|
}
|
2018-05-30 14:24:30 +03:00
|
|
|
default:
|
|
|
|
time.Sleep(time.Duration(5) * time.Millisecond)
|
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() {
|
2018-02-10 09:59:56 +03:00
|
|
|
now := time.Now()
|
|
|
|
prevTime := now
|
|
|
|
bytes := 0
|
2018-03-14 01:13:36 +03:00
|
|
|
delay := 0
|
2018-02-10 09:59:56 +03:00
|
|
|
for r.isRunning {
|
|
|
|
// Here we slow things down as much as we can to decrease cpu usage
|
|
|
|
switch {
|
2018-05-30 14:24:30 +03:00
|
|
|
case r.ringBuffer.Len() < 2:
|
2018-03-13 12:29:15 +03:00
|
|
|
delay++
|
2018-02-10 09:59:56 +03:00
|
|
|
time.Sleep(time.Duration(delay) * time.Millisecond)
|
2018-03-13 13:49:24 +03:00
|
|
|
case delay > 0:
|
|
|
|
delay--
|
2018-02-10 09:59:56 +03:00
|
|
|
}
|
|
|
|
// If the ringbuffer has something we can read and send off
|
2018-06-04 04:59:35 +03:00
|
|
|
chunk, err := r.ringBuffer.Next(readTimeout)
|
2018-05-30 14:24:30 +03:00
|
|
|
if err != nil || !r.isRunning {
|
|
|
|
if err == io.EOF {
|
|
|
|
break
|
2018-05-07 14:46:40 +03:00
|
|
|
}
|
2018-05-30 14:24:30 +03:00
|
|
|
continue
|
|
|
|
}
|
2018-05-03 07:58:14 +03:00
|
|
|
|
2018-06-04 04:59:35 +03:00
|
|
|
bytes += chunk.Len()
|
2018-05-30 14:24:30 +03:00
|
|
|
r.Log(Detail, "About to send")
|
2018-06-09 07:38:48 +03:00
|
|
|
err = r.destination.load(chunk)
|
|
|
|
if err != nil {
|
|
|
|
r.Log(Error, "failed to load clip")
|
|
|
|
}
|
|
|
|
err = r.destination.send()
|
2018-05-30 14:24:30 +03:00
|
|
|
if err == nil {
|
2018-06-09 07:38:48 +03:00
|
|
|
r.Log(Detail, "sent clip")
|
2018-05-30 14:24:30 +03:00
|
|
|
}
|
2018-05-06 16:33:44 +03:00
|
|
|
|
2018-06-04 04:59:35 +03:00
|
|
|
if r.isRunning && err != nil && chunk.Len() > 11 {
|
2018-05-30 14:24:30 +03:00
|
|
|
r.Log(Debug, "Send failed! Trying again")
|
|
|
|
// Try and send again
|
2018-06-09 07:38:48 +03:00
|
|
|
err = r.destination.send()
|
|
|
|
r.Log(Error, err.Error())
|
2018-05-30 14:24:30 +03:00
|
|
|
|
|
|
|
// if there's still an error we try and reconnect, unless we're stopping
|
|
|
|
for r.isRunning && err != nil {
|
|
|
|
r.Log(Debug, "Send failed a again! Trying to reconnect...")
|
|
|
|
time.Sleep(time.Duration(sendFailedDelay) * time.Millisecond)
|
2018-02-10 09:59:56 +03:00
|
|
|
r.Log(Error, err.Error())
|
2018-05-30 14:24:30 +03:00
|
|
|
|
2018-06-09 07:38:48 +03:00
|
|
|
if rs, ok := r.destination.(restarter); ok {
|
|
|
|
r.Log(Debug, fmt.Sprintf("restarting %T session", rs))
|
|
|
|
err = rs.restart()
|
|
|
|
if err != nil {
|
|
|
|
// TODO(kortschak): Make this "Fatal" when that exists.
|
|
|
|
r.Log(Error, "failed to restart rtmp session")
|
|
|
|
r.isRunning = false
|
|
|
|
return
|
|
|
|
}
|
|
|
|
r.Log(Info, "restarted rtmp session")
|
2018-05-30 14:24:30 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
r.Log(Debug, "Trying to send again with new connection...")
|
2018-06-09 07:38:48 +03:00
|
|
|
err = r.destination.send()
|
|
|
|
r.Log(Error, err.Error())
|
2018-02-10 09:59:56 +03:00
|
|
|
}
|
2018-05-30 14:24:30 +03:00
|
|
|
}
|
|
|
|
|
2018-06-09 07:38:48 +03:00
|
|
|
r.destination.release()
|
|
|
|
|
2018-05-30 14:24:30 +03:00
|
|
|
r.Log(Detail, "Done reading that clip from ringbuffer...")
|
|
|
|
|
|
|
|
// Log some information regarding bitrate and ring buffer size if it's time
|
|
|
|
now = time.Now()
|
|
|
|
deltaTime := now.Sub(prevTime)
|
2018-06-08 06:18:11 +03:00
|
|
|
if deltaTime > bitrateTime {
|
2018-05-30 14:24:30 +03:00
|
|
|
r.currentBitrate = int64(float64(bytes*8) / float64(deltaTime/1e9))
|
|
|
|
r.Log(Debug, fmt.Sprintf("Bitrate: %v bits/s\n", r.currentBitrate))
|
|
|
|
r.Log(Debug, fmt.Sprintf("Ring buffer size: %v\n", r.ringBuffer.Len()))
|
|
|
|
prevTime = now
|
|
|
|
bytes = 0
|
2018-02-10 09:59:56 +03:00
|
|
|
}
|
|
|
|
}
|
2018-03-14 12:24:11 +03:00
|
|
|
r.Log(Info, "Not outputting clips anymore!")
|
2018-06-09 07:38:48 +03:00
|
|
|
err := r.destination.close()
|
2018-02-10 09:59:56 +03:00
|
|
|
if err != nil {
|
2018-06-09 07:38:48 +03:00
|
|
|
r.Log(Error, "failed to close destination")
|
2018-02-10 09:59:56 +03:00
|
|
|
}
|
2018-01-23 08:13:13 +03:00
|
|
|
}
|
|
|
|
|
2018-02-27 18:10:38 +03:00
|
|
|
// setupInputForRaspivid sets up things for input from raspivid i.e. starts
|
|
|
|
// a raspivid process and pipes it's data output.
|
2018-06-09 05:01:21 +03:00
|
|
|
func (r *Revid) setupInputForRaspivid() error {
|
2018-02-10 09:59:56 +03:00
|
|
|
r.Log(Info, "Starting raspivid!")
|
|
|
|
switch r.config.InputCodec {
|
|
|
|
case H264:
|
2018-05-06 11:38:45 +03:00
|
|
|
arguments := []string{"-cd", "H264",
|
2018-05-03 15:36:17 +03:00
|
|
|
"-o", "-",
|
|
|
|
"-n",
|
|
|
|
"-t", r.config.Timeout,
|
2018-05-05 07:31:45 +03:00
|
|
|
"-b", r.config.Bitrate,
|
2018-05-03 15:36:17 +03:00
|
|
|
"-w", r.config.Width,
|
|
|
|
"-h", r.config.Height,
|
|
|
|
"-fps", r.config.FrameRate,
|
|
|
|
"-ih",
|
|
|
|
"-g", r.config.IntraRefreshPeriod,
|
2018-05-05 07:15:07 +03:00
|
|
|
}
|
|
|
|
|
2018-05-06 11:38:45 +03:00
|
|
|
if r.config.QuantizationMode == QuantizationOn {
|
|
|
|
arguments = append(arguments, "-qp")
|
|
|
|
arguments = append(arguments, r.config.Quantization)
|
2018-05-05 07:15:07 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
if r.config.HorizontalFlip == Yes {
|
2018-05-05 07:18:38 +03:00
|
|
|
arguments = append(arguments, "-hf")
|
2018-05-05 07:15:07 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
if r.config.VerticalFlip == Yes {
|
2018-05-05 07:18:38 +03:00
|
|
|
arguments = append(arguments, "-vf")
|
2018-05-05 07:15:07 +03:00
|
|
|
}
|
2018-05-05 07:21:58 +03:00
|
|
|
name := "raspivid"
|
|
|
|
r.cmd = &exec.Cmd{
|
|
|
|
Path: name,
|
2018-05-05 07:23:01 +03:00
|
|
|
Args: append([]string{name}, arguments...),
|
2018-05-05 07:15:07 +03:00
|
|
|
}
|
2018-05-05 07:27:49 +03:00
|
|
|
r.Log(Info, fmt.Sprintf("Startin raspivid with args: %v", r.cmd.Args))
|
2018-05-05 07:15:07 +03:00
|
|
|
if filepath.Base(name) == name {
|
2018-05-05 07:21:58 +03:00
|
|
|
if lp, err := exec.LookPath(name); err != nil {
|
|
|
|
r.Log(Error, err.Error())
|
2018-05-05 07:23:01 +03:00
|
|
|
return err
|
2018-05-05 07:15:07 +03:00
|
|
|
} else {
|
2018-05-05 07:18:38 +03:00
|
|
|
r.cmd.Path = lp
|
2018-05-05 07:15:07 +03:00
|
|
|
}
|
|
|
|
}
|
2018-05-03 15:36:17 +03:00
|
|
|
|
2018-02-10 09:59:56 +03:00
|
|
|
case Mjpeg:
|
|
|
|
r.cmd = exec.Command("raspivid",
|
|
|
|
"-cd", "MJPEG",
|
|
|
|
"-o", "-",
|
|
|
|
"-n",
|
|
|
|
"-t", r.config.Timeout,
|
|
|
|
"-fps", r.config.FrameRate,
|
2018-02-09 09:23:06 +03:00
|
|
|
)
|
|
|
|
}
|
2018-03-14 13:07:07 +03:00
|
|
|
stdout, _ := r.cmd.StdoutPipe()
|
2018-05-07 07:51:11 +03:00
|
|
|
go r.cmd.Run()
|
2018-05-05 07:15:07 +03:00
|
|
|
r.inputReader = bufio.NewReader(stdout)
|
2018-02-10 09:59:56 +03:00
|
|
|
go r.readCamera()
|
2018-02-12 10:58:29 +03:00
|
|
|
return nil
|
2018-02-10 09:59:56 +03:00
|
|
|
}
|
|
|
|
|
2018-02-27 18:10:38 +03:00
|
|
|
// setupInputForFile sets things up for getting input from a file
|
2018-06-09 05:01:21 +03:00
|
|
|
func (r *Revid) setupInputForFile() error {
|
2018-03-14 04:18:03 +03:00
|
|
|
fps, _ := strconv.Atoi(r.config.FrameRate)
|
|
|
|
r.parser.SetDelay(uint(float64(1000) / float64(fps)))
|
2018-02-14 10:02:57 +03:00
|
|
|
r.readFile()
|
2018-02-12 10:58:29 +03:00
|
|
|
return nil
|
2018-01-30 09:24:39 +03:00
|
|
|
}
|
|
|
|
|
2018-06-09 05:01:21 +03:00
|
|
|
// readCamera reads data from the defined camera while the Revid is running.
|
2018-02-27 18:10:38 +03:00
|
|
|
// TODO: use ringbuffer here instead of allocating mem every time!
|
2018-06-09 05:01:21 +03:00
|
|
|
func (r *Revid) readCamera() {
|
2018-01-30 09:24:39 +03:00
|
|
|
r.Log(Info, "Reading camera data!")
|
|
|
|
for r.isRunning {
|
|
|
|
data := make([]byte, 1)
|
|
|
|
_, err := io.ReadFull(r.inputReader, data)
|
|
|
|
switch {
|
2018-02-27 18:10:38 +03:00
|
|
|
// We know this means we're getting nothing from the cam
|
2018-05-06 11:38:45 +03:00
|
|
|
case (err != nil && err.Error() == "EOF" && r.isRunning) || (err != nil && r.isRunning):
|
2018-01-30 09:24:39 +03:00
|
|
|
r.Log(Error, "No data from camera!")
|
2018-04-16 08:29:49 +03:00
|
|
|
time.Sleep(cameraRetryPeriod)
|
2018-01-30 09:24:39 +03:00
|
|
|
default:
|
2018-01-31 04:00:03 +03:00
|
|
|
r.parser.GetInputChan() <- data[0]
|
2018-01-11 09:49:33 +03:00
|
|
|
}
|
|
|
|
}
|
2018-02-27 18:10:38 +03:00
|
|
|
r.Log(Info, "Not trying to read from camera anymore!")
|
2018-01-16 08:06:51 +03:00
|
|
|
}
|
|
|
|
|
2018-06-09 05:01:21 +03:00
|
|
|
// readFile reads data from the defined file while the Revid is running.
|
|
|
|
func (r *Revid) readFile() error {
|
2018-02-15 10:02:04 +03:00
|
|
|
var err error
|
|
|
|
r.inputFile, err = os.Open(r.config.InputFileName)
|
|
|
|
if err != nil {
|
|
|
|
r.Log(Error, err.Error())
|
|
|
|
r.Stop()
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
stats, err := r.inputFile.Stat()
|
|
|
|
if err != nil {
|
|
|
|
r.Log(Error, "Could not get input file stats!")
|
|
|
|
r.Stop()
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
data := make([]byte, stats.Size())
|
|
|
|
_, err = r.inputFile.Read(data)
|
|
|
|
if err != nil {
|
|
|
|
r.Log(Error, err.Error())
|
|
|
|
r.Stop()
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
for i := range data {
|
|
|
|
r.parser.GetInputChan() <- data[i]
|
2018-02-09 09:23:06 +03:00
|
|
|
}
|
2018-02-15 10:02:04 +03:00
|
|
|
r.inputFile.Close()
|
2018-02-12 10:58:29 +03:00
|
|
|
return nil
|
2018-02-09 09:23:06 +03:00
|
|
|
}
|