2018-04-19 10:03:12 +03:00
|
|
|
/*
|
|
|
|
NAME
|
2018-06-27 01:20:05 +03:00
|
|
|
revid-cli - command line interface for Revid.
|
2018-04-19 10:03:12 +03:00
|
|
|
|
|
|
|
DESCRIPTION
|
|
|
|
See Readme.md
|
|
|
|
|
|
|
|
AUTHORS
|
2018-06-20 08:08:34 +03:00
|
|
|
Saxon A. Nelson-Milton <saxon@ausocean.org>
|
|
|
|
Jack Richardson <jack@ausocean.org>
|
2018-04-19 10:03:12 +03:00
|
|
|
|
|
|
|
LICENSE
|
2018-06-27 01:20:05 +03:00
|
|
|
revid-cli is Copyright (C) 2017-2018 the Australian Ocean Lab (AusOcean)
|
2018-04-19 10:03:12 +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
|
2018-06-20 08:08:34 +03:00
|
|
|
for more details.
|
2018-04-19 10:03:12 +03:00
|
|
|
|
|
|
|
You should have received a copy of the GNU General Public License
|
2018-06-20 08:08:34 +03:00
|
|
|
along with revid in gpl.txt. If not, see http://www.gnu.org/licenses.
|
2018-04-19 10:03:12 +03:00
|
|
|
*/
|
2018-04-15 13:42:06 +03:00
|
|
|
package main
|
|
|
|
|
|
|
|
import (
|
|
|
|
"flag"
|
2018-05-06 11:38:45 +03:00
|
|
|
"fmt"
|
2018-06-09 03:46:04 +03:00
|
|
|
"os"
|
2018-04-19 09:42:07 +03:00
|
|
|
"strconv"
|
2018-04-19 11:19:36 +03:00
|
|
|
"time"
|
2018-06-25 04:56:08 +03:00
|
|
|
"unicode"
|
2018-04-19 08:58:16 +03:00
|
|
|
|
2018-04-19 11:19:36 +03:00
|
|
|
"bitbucket.org/ausocean/av/revid"
|
2018-05-03 06:51:28 +03:00
|
|
|
"bitbucket.org/ausocean/iot/pi/netsender"
|
2018-05-24 06:35:29 +03:00
|
|
|
"bitbucket.org/ausocean/utils/smartlogger"
|
2018-04-15 13:42:06 +03:00
|
|
|
)
|
|
|
|
|
2018-06-08 15:44:23 +03:00
|
|
|
const (
|
|
|
|
// progName is the program name for logging purposes.
|
|
|
|
progName = "revid-cli"
|
|
|
|
|
|
|
|
// Logging is set to INFO level.
|
|
|
|
loggerVerbosity = 3
|
|
|
|
)
|
|
|
|
|
2018-04-19 11:11:18 +03:00
|
|
|
// Indexes for configFlags
|
2018-04-15 13:42:06 +03:00
|
|
|
const (
|
2018-06-07 14:50:57 +03:00
|
|
|
inputPtr = iota
|
|
|
|
inputCodecPtr
|
|
|
|
outputPtr
|
|
|
|
rtmpMethodPtr
|
|
|
|
packetizationPtr
|
|
|
|
quantizationModePtr
|
|
|
|
verbosityPtr
|
|
|
|
framesPerClipPtr
|
|
|
|
rtmpUrlPtr
|
|
|
|
bitratePtr
|
|
|
|
outputFileNamePtr
|
|
|
|
inputFileNamePtr
|
|
|
|
heightPtr
|
|
|
|
widthPtr
|
|
|
|
frameRatePtr
|
|
|
|
httpAddressPtr
|
|
|
|
quantizationPtr
|
|
|
|
timeoutPtr
|
|
|
|
intraRefreshPeriodPtr
|
|
|
|
verticalFlipPtr
|
|
|
|
horizontalFlipPtr
|
|
|
|
|
|
|
|
noOfConfigFlags
|
2018-04-15 13:42:06 +03:00
|
|
|
)
|
|
|
|
|
2018-04-19 09:42:07 +03:00
|
|
|
// Other misc consts
|
|
|
|
const (
|
2018-06-08 15:22:11 +03:00
|
|
|
netSendRetryTime = 5 * time.Second
|
|
|
|
defaultRunDuration = 24 * time.Hour
|
|
|
|
revidStopTime = 5 * time.Second
|
2018-04-19 09:42:07 +03:00
|
|
|
)
|
|
|
|
|
|
|
|
// Globals
|
|
|
|
var (
|
2018-06-26 09:23:55 +03:00
|
|
|
rv *revid.Revid
|
|
|
|
config revid.Config
|
2018-04-19 08:58:16 +03:00
|
|
|
)
|
|
|
|
|
2018-04-15 13:42:06 +03:00
|
|
|
func main() {
|
2018-06-07 14:50:57 +03:00
|
|
|
flagNames := [noOfConfigFlags]struct{ name, description string }{
|
2018-05-06 11:38:45 +03:00
|
|
|
{"Input", "The input type"},
|
|
|
|
{"InputCodec", "The codec of the input"},
|
|
|
|
{"Output", "The output type"},
|
|
|
|
{"RtmpMethod", "The method used to send over rtmp (ffmpeg or librtmp)"},
|
|
|
|
{"Packetization", "The method of data packetisation"},
|
|
|
|
{"QuantizationMode", "The level of quantization"},
|
|
|
|
{"Verbosity", "Verbosity on or off"},
|
|
|
|
{"FramesPerClip", "Number of frames per clip sent"},
|
|
|
|
{"RtmpUrl", "Url of rtmp endpoint"},
|
|
|
|
{"Bitrate", "Bitrate of recorded video"},
|
|
|
|
{"OutputFileName", "The directory of the output file"},
|
|
|
|
{"InputFileName", "The directory of the input file"},
|
|
|
|
{"Height", "Height in pixels"},
|
|
|
|
{"Width", "Width in pixels"},
|
|
|
|
{"FrameRate", "Frame rate of captured video"},
|
|
|
|
{"HttpAddress", "Destination address of http posts"},
|
|
|
|
{"Quantization", "Desired quantization value"},
|
|
|
|
{"Timeout", "Http timeout in seconds"},
|
|
|
|
{"IntraRefreshPeriod", "The IntraRefreshPeriod i.e. how many keyframes we send"},
|
|
|
|
{"VerticalFlip", "Flip video vertically"},
|
2018-05-05 06:47:07 +03:00
|
|
|
{"HorizontalFlip", "Flip video horizontally"},
|
2018-04-15 13:42:06 +03:00
|
|
|
}
|
|
|
|
|
2018-04-19 11:11:18 +03:00
|
|
|
// Create the configFlags based on the flagNames array
|
2018-05-06 11:38:45 +03:00
|
|
|
configFlags := make([](*string), noOfConfigFlags)
|
2018-06-07 14:50:57 +03:00
|
|
|
for i, f := range &flagNames {
|
|
|
|
configFlags[i] = flag.String(f.name, "", f.description)
|
2018-04-15 13:42:06 +03:00
|
|
|
}
|
|
|
|
|
2018-04-19 10:03:12 +03:00
|
|
|
// Do we want a netsender session
|
2018-06-09 03:46:04 +03:00
|
|
|
useNetsender := flag.Bool("NetSender", false, "Are we checking vars through netsender?")
|
2018-04-19 10:03:12 +03:00
|
|
|
// User might also want to define how long revid runs for
|
2018-06-08 15:22:11 +03:00
|
|
|
runDurationPtr := flag.Duration("runDuration", defaultRunDuration, "How long do you want revid to run for?")
|
2018-04-19 09:42:07 +03:00
|
|
|
|
2018-04-15 13:42:06 +03:00
|
|
|
flag.Parse()
|
|
|
|
|
2018-04-19 11:14:38 +03:00
|
|
|
switch *configFlags[inputPtr] {
|
2018-04-15 13:42:06 +03:00
|
|
|
case "Raspivid":
|
2018-04-19 11:16:26 +03:00
|
|
|
config.Input = revid.Raspivid
|
2018-04-15 13:42:06 +03:00
|
|
|
case "File":
|
2018-04-19 11:16:26 +03:00
|
|
|
config.Input = revid.File
|
2018-04-19 12:37:25 +03:00
|
|
|
case "":
|
|
|
|
default:
|
|
|
|
fmt.Println("Bad input argument!")
|
2018-04-15 13:42:06 +03:00
|
|
|
}
|
|
|
|
|
2018-04-19 11:14:38 +03:00
|
|
|
switch *configFlags[inputCodecPtr] {
|
2018-04-15 13:42:06 +03:00
|
|
|
case "H264Codec":
|
2018-04-19 11:16:26 +03:00
|
|
|
config.InputCodec = revid.H264Codec
|
2018-04-19 12:37:25 +03:00
|
|
|
case "":
|
|
|
|
default:
|
|
|
|
fmt.Println("Bad input codec argument!")
|
2018-04-15 13:42:06 +03:00
|
|
|
}
|
|
|
|
|
2018-04-19 11:14:38 +03:00
|
|
|
switch *configFlags[outputPtr] {
|
2018-04-15 13:42:06 +03:00
|
|
|
case "File":
|
2018-04-19 11:16:26 +03:00
|
|
|
config.Output = revid.File
|
2018-04-15 13:42:06 +03:00
|
|
|
case "Http":
|
2018-04-19 11:16:26 +03:00
|
|
|
config.Output = revid.Http
|
2018-06-25 04:23:26 +03:00
|
|
|
case "Rtmp":
|
|
|
|
config.Output = revid.Rtmp
|
2018-04-19 12:39:48 +03:00
|
|
|
case "FfmpegRtmp":
|
|
|
|
config.Output = revid.FfmpegRtmp
|
2018-04-19 12:37:25 +03:00
|
|
|
case "":
|
|
|
|
default:
|
|
|
|
fmt.Println("Bad output argument!")
|
2018-04-15 13:42:06 +03:00
|
|
|
}
|
|
|
|
|
2018-04-19 11:14:38 +03:00
|
|
|
switch *configFlags[rtmpMethodPtr] {
|
2018-04-15 13:42:06 +03:00
|
|
|
case "Ffmpeg":
|
2018-04-19 11:16:26 +03:00
|
|
|
config.RtmpMethod = revid.Ffmpeg
|
2018-04-15 13:42:06 +03:00
|
|
|
case "LibRtmp":
|
2018-04-19 11:16:26 +03:00
|
|
|
config.RtmpMethod = revid.LibRtmp
|
2018-04-19 12:37:25 +03:00
|
|
|
case "":
|
|
|
|
default:
|
|
|
|
fmt.Println("Bad rtmp method argument!")
|
2018-04-15 13:42:06 +03:00
|
|
|
}
|
|
|
|
|
2018-04-19 11:24:44 +03:00
|
|
|
switch *configFlags[packetizationPtr] {
|
2018-04-15 13:42:06 +03:00
|
|
|
case "None":
|
2018-04-19 11:19:36 +03:00
|
|
|
config.Packetization = revid.None
|
2018-06-30 15:20:55 +03:00
|
|
|
case "Mpegts":
|
|
|
|
config.Packetization = revid.Mpegts
|
2018-04-15 13:42:06 +03:00
|
|
|
case "Flv":
|
2018-04-19 11:19:36 +03:00
|
|
|
config.Packetization = revid.Flv
|
2018-04-19 12:37:25 +03:00
|
|
|
case "":
|
|
|
|
default:
|
|
|
|
fmt.Println("Bad packetization argument!")
|
2018-04-15 13:42:06 +03:00
|
|
|
}
|
|
|
|
|
2018-04-19 11:19:36 +03:00
|
|
|
switch *configFlags[quantizationModePtr] {
|
2018-04-15 13:42:06 +03:00
|
|
|
case "QuantizationOn":
|
2018-04-19 11:24:44 +03:00
|
|
|
config.QuantizationMode = revid.QuantizationOn
|
2018-04-15 13:42:06 +03:00
|
|
|
case "QuantizationOff":
|
2018-04-19 11:24:44 +03:00
|
|
|
config.QuantizationMode = revid.QuantizationOff
|
2018-04-19 12:37:25 +03:00
|
|
|
case "":
|
|
|
|
default:
|
|
|
|
fmt.Println("Bad quantization mode argument!")
|
2018-04-15 13:42:06 +03:00
|
|
|
}
|
|
|
|
|
2018-04-19 11:14:38 +03:00
|
|
|
switch *configFlags[verbosityPtr] {
|
2018-04-15 13:42:06 +03:00
|
|
|
case "No":
|
2018-04-19 11:16:26 +03:00
|
|
|
config.Verbosity = revid.No
|
2018-04-15 13:42:06 +03:00
|
|
|
case "Yes":
|
2018-04-19 11:16:26 +03:00
|
|
|
config.Verbosity = revid.Yes
|
2018-04-19 12:37:25 +03:00
|
|
|
case "":
|
|
|
|
default:
|
|
|
|
fmt.Println("Bad verbosity argument!")
|
2018-04-15 13:42:06 +03:00
|
|
|
}
|
|
|
|
|
2018-05-03 15:36:17 +03:00
|
|
|
switch *configFlags[horizontalFlipPtr] {
|
2018-05-03 11:32:36 +03:00
|
|
|
case "No":
|
2018-05-05 06:45:45 +03:00
|
|
|
config.HorizontalFlip = revid.No
|
2018-05-03 11:32:36 +03:00
|
|
|
case "Yes":
|
2018-05-05 06:45:45 +03:00
|
|
|
config.HorizontalFlip = revid.Yes
|
2018-05-03 11:32:36 +03:00
|
|
|
case "":
|
2018-05-06 10:18:17 +03:00
|
|
|
config.HorizontalFlip = revid.No
|
2018-05-03 11:32:36 +03:00
|
|
|
default:
|
2018-05-03 15:36:17 +03:00
|
|
|
fmt.Println("Bad horizontal flip option!")
|
|
|
|
}
|
|
|
|
|
|
|
|
switch *configFlags[verticalFlipPtr] {
|
|
|
|
case "No":
|
2018-05-05 06:45:45 +03:00
|
|
|
config.VerticalFlip = revid.No
|
2018-05-03 15:36:17 +03:00
|
|
|
case "Yes":
|
|
|
|
config.VerticalFlip = revid.Yes
|
|
|
|
case "":
|
2018-05-06 10:18:17 +03:00
|
|
|
config.VerticalFlip = revid.No
|
2018-05-03 15:36:17 +03:00
|
|
|
default:
|
|
|
|
fmt.Println("Bad vertical flip option!")
|
2018-05-03 11:32:36 +03:00
|
|
|
}
|
|
|
|
|
2018-06-20 08:08:34 +03:00
|
|
|
fpc, err := strconv.Atoi(*configFlags[framesPerClipPtr])
|
|
|
|
if err == nil && fpc > 0 {
|
|
|
|
config.FramesPerClip = fpc
|
|
|
|
}
|
2018-05-06 11:38:45 +03:00
|
|
|
config.RtmpUrl = *configFlags[rtmpUrlPtr]
|
|
|
|
config.Bitrate = *configFlags[bitratePtr]
|
|
|
|
config.OutputFileName = *configFlags[outputFileNamePtr]
|
|
|
|
config.InputFileName = *configFlags[inputFileNamePtr]
|
|
|
|
config.Height = *configFlags[heightPtr]
|
|
|
|
config.Width = *configFlags[widthPtr]
|
|
|
|
config.FrameRate = *configFlags[frameRatePtr]
|
|
|
|
config.HttpAddress = *configFlags[httpAddressPtr]
|
|
|
|
config.Quantization = *configFlags[quantizationPtr]
|
|
|
|
config.Timeout = *configFlags[timeoutPtr]
|
|
|
|
config.IntraRefreshPeriod = *configFlags[intraRefreshPeriodPtr]
|
2018-04-19 09:42:07 +03:00
|
|
|
|
2018-06-26 09:23:55 +03:00
|
|
|
if !*useNetsender {
|
|
|
|
// instantiate our own logger
|
2018-05-30 06:15:37 +03:00
|
|
|
config.Logger = smartlogger.New(loggerVerbosity, smartlogger.File, "/var/log/netsender/")
|
2018-06-26 09:23:55 +03:00
|
|
|
// run revid for the specified duration
|
|
|
|
startRevid(nil)
|
|
|
|
time.Sleep(*runDurationPtr)
|
|
|
|
stopRevid()
|
|
|
|
return
|
2018-04-20 05:20:33 +03:00
|
|
|
}
|
2018-04-20 09:53:51 +03:00
|
|
|
|
2018-06-26 09:23:55 +03:00
|
|
|
err = run()
|
|
|
|
if err != nil {
|
|
|
|
config.Logger.Log(progName, "Error", err.Error()) // TODO(kortschak): Make this "Fatal" when that exists.
|
|
|
|
os.Exit(1)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// initialize then run the main NetSender client
|
|
|
|
func run() error {
|
|
|
|
// initialize NetSender and use NetSender's logger
|
|
|
|
config.Logger = netsender.Logger()
|
|
|
|
config.Logger.Log(progName, "Info", "Running in NetSender mode")
|
|
|
|
|
|
|
|
var ns netsender.Sender
|
|
|
|
err := ns.Init(nil, nil, nil)
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
vars, _ := ns.Vars()
|
2018-06-28 08:04:05 +03:00
|
|
|
vs := ns.VarSum()
|
2018-06-26 09:23:55 +03:00
|
|
|
paused := false
|
|
|
|
if vars["mode"] == "Paused" {
|
|
|
|
paused = true
|
2018-06-22 13:39:03 +03:00
|
|
|
}
|
2018-06-28 09:31:15 +03:00
|
|
|
if !paused {
|
|
|
|
err = updateRevid(&ns, vars, false)
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-06-26 09:23:55 +03:00
|
|
|
for {
|
|
|
|
if err := send(&ns); err != nil {
|
2018-06-15 10:59:59 +03:00
|
|
|
config.Logger.Log(progName, "Warning", err.Error())
|
2018-06-08 15:22:11 +03:00
|
|
|
time.Sleep(netSendRetryTime)
|
2018-05-07 04:16:44 +03:00
|
|
|
continue
|
|
|
|
}
|
2018-06-01 14:20:56 +03:00
|
|
|
|
2018-06-17 15:08:37 +03:00
|
|
|
if vs != ns.VarSum() {
|
2018-06-07 14:50:57 +03:00
|
|
|
// vars changed
|
2018-06-14 10:07:57 +03:00
|
|
|
vars, err := ns.Vars()
|
2018-06-01 14:20:56 +03:00
|
|
|
if err != nil {
|
2018-06-15 10:59:59 +03:00
|
|
|
config.Logger.Log(progName, "Warning", err.Error())
|
2018-06-08 15:22:11 +03:00
|
|
|
time.Sleep(netSendRetryTime)
|
2018-06-01 14:20:56 +03:00
|
|
|
continue
|
|
|
|
}
|
2018-06-17 15:08:37 +03:00
|
|
|
vs = ns.VarSum()
|
2018-05-07 04:16:44 +03:00
|
|
|
if vars["mode"] == "Paused" {
|
|
|
|
if !paused {
|
2018-06-01 14:20:56 +03:00
|
|
|
config.Logger.Log(progName, "Info", "Pausing revid")
|
2018-05-07 04:16:44 +03:00
|
|
|
stopRevid()
|
|
|
|
paused = true
|
|
|
|
}
|
|
|
|
} else {
|
2018-06-26 09:23:55 +03:00
|
|
|
err = updateRevid(&ns, vars, !paused)
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
2018-05-07 04:16:44 +03:00
|
|
|
if paused {
|
|
|
|
paused = false
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2018-06-25 03:40:37 +03:00
|
|
|
sleepTime, _ := strconv.Atoi(ns.Param("mp"))
|
2018-04-19 08:58:16 +03:00
|
|
|
time.Sleep(time.Duration(sleepTime) * time.Second)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-06-26 09:23:55 +03:00
|
|
|
// send implements our main NetSender client and handles NetReceiver configuration
|
2018-06-15 10:59:59 +03:00
|
|
|
// (as distinct from httpSender which just sends video data).
|
2018-06-26 09:23:55 +03:00
|
|
|
func send(ns *netsender.Sender) error {
|
2018-06-14 10:07:57 +03:00
|
|
|
// populate input values, if any
|
2018-06-25 03:40:37 +03:00
|
|
|
inputs := netsender.MakePins(ns.Param("ip"), "X")
|
2018-06-28 09:43:06 +03:00
|
|
|
if rv != nil {
|
|
|
|
for i, pin := range inputs {
|
|
|
|
if pin.Name == "X23" {
|
|
|
|
inputs[i].Value = rv.Bitrate()
|
|
|
|
}
|
2018-06-14 10:07:57 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-06-16 12:34:32 +03:00
|
|
|
_, reconfig, err := ns.Send(netsender.RequestPoll, inputs)
|
2018-06-08 15:45:14 +03:00
|
|
|
if err != nil {
|
2018-06-01 14:20:56 +03:00
|
|
|
return err
|
2018-06-08 15:45:14 +03:00
|
|
|
}
|
|
|
|
if reconfig {
|
|
|
|
return ns.Config()
|
2018-04-19 09:42:07 +03:00
|
|
|
}
|
2018-06-01 14:20:56 +03:00
|
|
|
return nil
|
2018-05-07 04:16:44 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
// wrappers for stopping and starting revid
|
2018-06-26 09:23:55 +03:00
|
|
|
func startRevid(ns *netsender.Sender) (err error) {
|
|
|
|
rv, err = revid.New(config, ns)
|
|
|
|
if err != nil {
|
|
|
|
return err
|
2018-06-08 15:56:20 +03:00
|
|
|
}
|
2018-06-26 09:23:55 +03:00
|
|
|
rv.Start()
|
|
|
|
return nil
|
2018-06-08 15:56:20 +03:00
|
|
|
}
|
|
|
|
|
2018-05-07 04:16:44 +03:00
|
|
|
func stopRevid() {
|
2018-06-26 09:23:55 +03:00
|
|
|
rv.Stop()
|
2018-06-07 14:50:57 +03:00
|
|
|
|
|
|
|
// FIXME(kortschak): Is this waiting on completion of work?
|
|
|
|
// Use a wait group and Wait method if it is.
|
2018-06-08 15:22:11 +03:00
|
|
|
time.Sleep(revidStopTime)
|
2018-05-07 04:16:44 +03:00
|
|
|
}
|
|
|
|
|
2018-06-26 09:23:55 +03:00
|
|
|
func updateRevid(ns *netsender.Sender, vars map[string]string, stop bool) error {
|
2018-05-07 04:16:44 +03:00
|
|
|
if stop {
|
|
|
|
stopRevid()
|
|
|
|
}
|
2018-04-20 11:23:59 +03:00
|
|
|
|
2018-06-01 14:20:56 +03:00
|
|
|
//look through the vars and update revid where needed
|
2018-04-19 08:58:16 +03:00
|
|
|
for key, value := range vars {
|
|
|
|
switch key {
|
2018-06-25 04:39:56 +03:00
|
|
|
case "Output":
|
|
|
|
switch value {
|
|
|
|
case "File":
|
|
|
|
config.Output = revid.File
|
|
|
|
case "Http":
|
|
|
|
config.Output = revid.Http
|
|
|
|
case "Rtmp":
|
|
|
|
config.Output = revid.Rtmp
|
|
|
|
case "FfmpegRtmp":
|
|
|
|
config.Output = revid.FfmpegRtmp
|
|
|
|
default:
|
2018-06-26 09:23:55 +03:00
|
|
|
rv.Log(revid.Warning, "Invalid Output param: "+value)
|
2018-06-25 04:39:56 +03:00
|
|
|
continue
|
|
|
|
}
|
2018-05-06 11:38:45 +03:00
|
|
|
case "FramesPerClip":
|
2018-06-20 08:08:34 +03:00
|
|
|
fpc, err := strconv.Atoi(value)
|
|
|
|
if fpc > 0 && err == nil {
|
|
|
|
config.FramesPerClip = fpc
|
2018-06-25 04:39:56 +03:00
|
|
|
} else {
|
2018-06-26 09:23:55 +03:00
|
|
|
rv.Log(revid.Warning, "Invalid FramesPerClip param: "+value)
|
2018-05-06 11:38:45 +03:00
|
|
|
}
|
|
|
|
case "RtmpUrl":
|
|
|
|
config.RtmpUrl = value
|
|
|
|
case "Bitrate":
|
|
|
|
asInt, err := strconv.Atoi(value)
|
|
|
|
if asInt > 0 && err == nil {
|
|
|
|
config.Bitrate = value
|
2018-06-25 04:39:56 +03:00
|
|
|
} else {
|
2018-06-26 09:23:55 +03:00
|
|
|
rv.Log(revid.Warning, "Invalid Bitrate param: "+value)
|
2018-05-06 11:38:45 +03:00
|
|
|
}
|
|
|
|
case "OutputFileName":
|
|
|
|
config.OutputFileName = value
|
|
|
|
case "InputFileName":
|
|
|
|
config.InputFileName = value
|
|
|
|
case "Height":
|
|
|
|
asInt, err := strconv.Atoi(value)
|
|
|
|
if asInt > 0 && err == nil {
|
|
|
|
config.Height = value
|
2018-06-25 04:39:56 +03:00
|
|
|
} else {
|
2018-06-26 09:23:55 +03:00
|
|
|
rv.Log(revid.Warning, "Invalid Height param: "+value)
|
2018-05-06 11:38:45 +03:00
|
|
|
}
|
|
|
|
case "Width":
|
|
|
|
asInt, err := strconv.Atoi(value)
|
|
|
|
if asInt > 0 && err == nil {
|
|
|
|
config.Width = value
|
2018-06-25 04:39:56 +03:00
|
|
|
} else {
|
2018-06-26 09:23:55 +03:00
|
|
|
rv.Log(revid.Warning, "Invalid Width param: "+value)
|
2018-05-06 11:38:45 +03:00
|
|
|
}
|
|
|
|
case "FrameRate":
|
|
|
|
asInt, err := strconv.Atoi(value)
|
|
|
|
if asInt > 0 && err == nil {
|
|
|
|
config.FrameRate = value
|
2018-06-25 04:39:56 +03:00
|
|
|
} else {
|
2018-06-26 09:23:55 +03:00
|
|
|
rv.Log(revid.Warning, "Invalid FrameRate param: "+value)
|
2018-05-06 11:38:45 +03:00
|
|
|
}
|
|
|
|
case "HttpAddress":
|
|
|
|
config.HttpAddress = value
|
|
|
|
case "Quantization":
|
|
|
|
asInt, err := strconv.Atoi(value)
|
|
|
|
if asInt > 0 && err == nil {
|
|
|
|
config.Quantization = value
|
2018-06-25 04:39:56 +03:00
|
|
|
} else {
|
2018-06-26 09:23:55 +03:00
|
|
|
rv.Log(revid.Warning, "Invalid Quantization param: "+value)
|
2018-05-06 11:38:45 +03:00
|
|
|
}
|
|
|
|
case "Timeout":
|
|
|
|
asInt, err := strconv.Atoi(value)
|
|
|
|
if asInt > 0 && err == nil {
|
|
|
|
config.Timeout = value
|
|
|
|
}
|
|
|
|
case "IntraRefreshPeriod":
|
|
|
|
asInt, err := strconv.Atoi(value)
|
|
|
|
if asInt > 0 && err == nil {
|
|
|
|
config.IntraRefreshPeriod = value
|
|
|
|
}
|
|
|
|
case "HorizontalFlip":
|
|
|
|
switch value {
|
|
|
|
case "Yes":
|
|
|
|
config.HorizontalFlip = revid.Yes
|
|
|
|
case "No":
|
|
|
|
config.HorizontalFlip = revid.No
|
2018-06-25 04:39:56 +03:00
|
|
|
default:
|
2018-06-26 09:23:55 +03:00
|
|
|
rv.Log(revid.Warning, "Invalid HorizontalFlip param: "+value)
|
2018-05-06 11:38:45 +03:00
|
|
|
}
|
|
|
|
case "VerticalFlip":
|
|
|
|
switch value {
|
|
|
|
case "Yes":
|
|
|
|
config.VerticalFlip = revid.Yes
|
|
|
|
case "No":
|
|
|
|
config.VerticalFlip = revid.No
|
2018-06-25 04:39:56 +03:00
|
|
|
default:
|
2018-06-26 09:23:55 +03:00
|
|
|
rv.Log(revid.Warning, "Invalid VerticalFlip param: "+value)
|
2018-05-06 11:38:45 +03:00
|
|
|
}
|
2018-06-25 04:39:56 +03:00
|
|
|
default:
|
2018-06-25 04:56:08 +03:00
|
|
|
if unicode.IsUpper(rune(key[0])) {
|
2018-06-26 09:23:55 +03:00
|
|
|
rv.Log(revid.Warning, "Unexpected param: "+key)
|
2018-06-25 04:56:08 +03:00
|
|
|
} // else system params are lower case
|
2018-04-19 08:58:16 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-06-26 09:23:55 +03:00
|
|
|
return startRevid(ns)
|
2018-04-19 08:58:16 +03:00
|
|
|
}
|