mirror of
https://github.com/aler9/gortsplib
synced 2025-10-05 15:16:51 +08:00
headers: implement Range
This commit is contained in:
aler9
362
pkg/headers/range.go
Normal file
362
pkg/headers/range.go
Normal file
@@ -0,0 +1,362 @@
|
||||
package headers
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"strconv"
|
||||
"strings"
|
||||
"time"
|
||||
|
||||
"github.com/aler9/gortsplib/pkg/base"
|
||||
)
|
||||
|
||||
func leadingZero(v uint) string {
|
||||
ret := ""
|
||||
if v < 10 {
|
||||
ret += "0"
|
||||
}
|
||||
ret += strconv.FormatUint(uint64(v), 10)
|
||||
return ret
|
||||
}
|
||||
|
||||
// RangeSMPTETime is a time expressed in SMPTE unit.
|
||||
type RangeSMPTETime struct {
|
||||
Time time.Duration
|
||||
Frame uint
|
||||
Subframe uint
|
||||
}
|
||||
|
||||
func (t *RangeSMPTETime) read(s string) error {
|
||||
parts := strings.Split(s, ":")
|
||||
if len(parts) != 3 && len(parts) != 4 {
|
||||
return fmt.Errorf("invalid SMPTE time (%v)", s)
|
||||
}
|
||||
|
||||
tmp, err := strconv.ParseUint(parts[0], 10, 64)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
hours := tmp
|
||||
|
||||
tmp, err = strconv.ParseUint(parts[1], 10, 64)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
mins := tmp
|
||||
|
||||
tmp, err = strconv.ParseUint(parts[2], 10, 64)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
seconds := tmp
|
||||
|
||||
t.Time = time.Duration(seconds+mins*60+hours*3600) * time.Second
|
||||
|
||||
if len(parts) == 4 {
|
||||
parts := strings.Split(parts[3], ".")
|
||||
if len(parts) == 2 {
|
||||
tmp, err := strconv.ParseUint(parts[0], 10, 64)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
t.Frame = uint(tmp)
|
||||
|
||||
tmp, err = strconv.ParseUint(parts[1], 10, 64)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
t.Subframe = uint(tmp)
|
||||
|
||||
} else {
|
||||
tmp, err := strconv.ParseUint(parts[0], 10, 64)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
t.Frame = uint(tmp)
|
||||
}
|
||||
}
|
||||
|
||||
return nil
|
||||
}
|
||||
|
||||
func (t RangeSMPTETime) write() string {
|
||||
d := uint64(t.Time.Seconds())
|
||||
hours := d / 3600
|
||||
d %= 3600
|
||||
mins := d / 60
|
||||
secs := d % 60
|
||||
|
||||
ret := strconv.FormatUint(hours, 10) + ":" + leadingZero(uint(mins)) + ":" + leadingZero(uint(secs))
|
||||
|
||||
if t.Frame > 0 || t.Subframe > 0 {
|
||||
ret += ":" + leadingZero(t.Frame)
|
||||
|
||||
if t.Subframe > 0 {
|
||||
ret += "." + leadingZero(t.Subframe)
|
||||
}
|
||||
}
|
||||
|
||||
return ret
|
||||
}
|
||||
|
||||
// RangeSMPTE is a range expressed in SMPTE unit.
|
||||
type RangeSMPTE struct {
|
||||
Start RangeSMPTETime
|
||||
End *RangeSMPTETime
|
||||
}
|
||||
|
||||
func (r *RangeSMPTE) read(start string, end string) error {
|
||||
err := r.Start.read(start)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
if end != "" {
|
||||
var v RangeSMPTETime
|
||||
err := v.read(end)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
r.End = &v
|
||||
}
|
||||
|
||||
return nil
|
||||
}
|
||||
|
||||
func (r RangeSMPTE) write() string {
|
||||
ret := "smpte=" + r.Start.write() + "-"
|
||||
if r.End != nil {
|
||||
ret += r.End.write()
|
||||
}
|
||||
return ret
|
||||
}
|
||||
|
||||
// RangeNPTTime is a time expressed in NPT unit.
|
||||
type RangeNPTTime time.Duration
|
||||
|
||||
func (t *RangeNPTTime) read(s string) error {
|
||||
parts := strings.Split(s, ":")
|
||||
if len(parts) > 3 {
|
||||
return fmt.Errorf("invalid NPT time (%v)", s)
|
||||
}
|
||||
|
||||
var hours uint64
|
||||
if len(parts) == 3 {
|
||||
tmp, err := strconv.ParseUint(parts[0], 10, 64)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
hours = tmp
|
||||
parts = parts[1:]
|
||||
}
|
||||
|
||||
var mins uint64
|
||||
if len(parts) >= 2 {
|
||||
tmp, err := strconv.ParseUint(parts[0], 10, 64)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
mins = tmp
|
||||
parts = parts[1:]
|
||||
}
|
||||
|
||||
tmp, err := strconv.ParseFloat(parts[0], 64)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
seconds := tmp
|
||||
|
||||
*t = RangeNPTTime(time.Duration(seconds*float64(time.Second)) +
|
||||
time.Duration(mins*60+hours*3600)*time.Second)
|
||||
|
||||
return nil
|
||||
}
|
||||
|
||||
func (t RangeNPTTime) write() string {
|
||||
return strconv.FormatFloat(time.Duration(t).Seconds(), 'f', -1, 64)
|
||||
}
|
||||
|
||||
// RangeNPT is a range expressed in NPT unit.
|
||||
type RangeNPT struct {
|
||||
Start RangeNPTTime
|
||||
End *RangeNPTTime
|
||||
}
|
||||
|
||||
func (r *RangeNPT) read(start string, end string) error {
|
||||
err := r.Start.read(start)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
if end != "" {
|
||||
var v RangeNPTTime
|
||||
err := v.read(end)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
r.End = &v
|
||||
}
|
||||
|
||||
return nil
|
||||
}
|
||||
|
||||
func (r RangeNPT) write() string {
|
||||
ret := "npt=" + r.Start.write() + "-"
|
||||
if r.End != nil {
|
||||
ret += r.End.write()
|
||||
}
|
||||
return ret
|
||||
}
|
||||
|
||||
// RangeUTCTime is a time expressed in UTC unit.
|
||||
type RangeUTCTime time.Time
|
||||
|
||||
func (t *RangeUTCTime) read(s string) error {
|
||||
tmp, err := time.Parse("20060102T150405Z", s)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
*t = RangeUTCTime(tmp)
|
||||
return nil
|
||||
}
|
||||
|
||||
func (t RangeUTCTime) write() string {
|
||||
return time.Time(t).Format("20060102T150405Z")
|
||||
}
|
||||
|
||||
// RangeUTC is a range expressed in UTC unit.
|
||||
type RangeUTC struct {
|
||||
Start RangeUTCTime
|
||||
End *RangeUTCTime
|
||||
}
|
||||
|
||||
func (r *RangeUTC) read(start string, end string) error {
|
||||
err := r.Start.read(start)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
if end != "" {
|
||||
var v RangeUTCTime
|
||||
err := v.read(end)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
r.End = &v
|
||||
}
|
||||
|
||||
return nil
|
||||
}
|
||||
|
||||
func (r RangeUTC) write() string {
|
||||
ret := "clock=" + r.Start.write() + "-"
|
||||
if r.End != nil {
|
||||
ret += r.End.write()
|
||||
}
|
||||
return ret
|
||||
}
|
||||
|
||||
// RangeValue can be
|
||||
// - RangeSMPTE
|
||||
// - RangeNPT
|
||||
// - RangeUTC
|
||||
type RangeValue interface {
|
||||
read(string, string) error
|
||||
write() string
|
||||
}
|
||||
|
||||
func rangeValueRead(s RangeValue, v string) error {
|
||||
parts := strings.Split(v, "-")
|
||||
if len(parts) != 2 {
|
||||
return fmt.Errorf("invalid value (%v)", v)
|
||||
}
|
||||
|
||||
return s.read(parts[0], parts[1])
|
||||
}
|
||||
|
||||
// Range is a Range header.
|
||||
type Range struct {
|
||||
// range expressed in a certain unit.
|
||||
Value RangeValue
|
||||
|
||||
// time at which the operation is to be made effective.
|
||||
Time *RangeUTCTime
|
||||
}
|
||||
|
||||
// Read decodes a Range header.
|
||||
func (h *Range) Read(v base.HeaderValue) error {
|
||||
if len(v) == 0 {
|
||||
return fmt.Errorf("value not provided")
|
||||
}
|
||||
|
||||
if len(v) > 1 {
|
||||
return fmt.Errorf("value provided multiple times (%v)", v)
|
||||
}
|
||||
|
||||
v0 := v[0]
|
||||
|
||||
kvs, err := keyValParse(v0, ';')
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
specFound := false
|
||||
|
||||
for k, v := range kvs {
|
||||
switch k {
|
||||
case "smpte":
|
||||
s := &RangeSMPTE{}
|
||||
err := rangeValueRead(s, v)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
specFound = true
|
||||
h.Value = s
|
||||
|
||||
case "npt":
|
||||
s := &RangeNPT{}
|
||||
err := rangeValueRead(s, v)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
specFound = true
|
||||
h.Value = s
|
||||
|
||||
case "clock":
|
||||
s := &RangeUTC{}
|
||||
err := rangeValueRead(s, v)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
specFound = true
|
||||
h.Value = s
|
||||
|
||||
case "time":
|
||||
t := &RangeUTCTime{}
|
||||
err := t.read(v)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
h.Time = t
|
||||
}
|
||||
}
|
||||
|
||||
if !specFound {
|
||||
return fmt.Errorf("value not found (%v)", v[0])
|
||||
}
|
||||
|
||||
return nil
|
||||
}
|
||||
|
||||
// Write encodes a Range header.
|
||||
func (h Range) Write() base.HeaderValue {
|
||||
v := h.Value.write()
|
||||
if h.Time != nil {
|
||||
v += ";time=" + h.Time.write()
|
||||
}
|
||||
return base.HeaderValue{v}
|
||||
}
|
||||
272
pkg/headers/range_test.go
Normal file
272
pkg/headers/range_test.go
Normal file
@@ -0,0 +1,272 @@
|
||||
package headers
|
||||
|
||||
import (
|
||||
"testing"
|
||||
"time"
|
||||
|
||||
"github.com/stretchr/testify/require"
|
||||
|
||||
"github.com/aler9/gortsplib/pkg/base"
|
||||
)
|
||||
|
||||
var casesRange = []struct {
|
||||
name string
|
||||
vin base.HeaderValue
|
||||
vout base.HeaderValue
|
||||
h Range
|
||||
}{
|
||||
{
|
||||
"smpte",
|
||||
base.HeaderValue{`smpte=10:07:00-10:07:33:05.01`},
|
||||
base.HeaderValue{`smpte=10:07:00-10:07:33:05.01`},
|
||||
Range{
|
||||
Value: &RangeSMPTE{
|
||||
Start: RangeSMPTETime{
|
||||
Time: time.Duration(7*60+10*3600) * time.Second,
|
||||
},
|
||||
End: &RangeSMPTETime{
|
||||
Time: time.Duration(33+7*60+10*3600) * time.Second,
|
||||
Frame: 5,
|
||||
Subframe: 1,
|
||||
},
|
||||
},
|
||||
},
|
||||
},
|
||||
{
|
||||
"smpte open ended",
|
||||
base.HeaderValue{`smpte=0:10:00-`},
|
||||
base.HeaderValue{`smpte=0:10:00-`},
|
||||
Range{
|
||||
Value: &RangeSMPTE{
|
||||
Start: RangeSMPTETime{
|
||||
Time: time.Duration(10*60) * time.Second,
|
||||
},
|
||||
},
|
||||
},
|
||||
},
|
||||
{
|
||||
"smpte with frame",
|
||||
base.HeaderValue{`smpte=0:10:00:01-`},
|
||||
base.HeaderValue{`smpte=0:10:00:01-`},
|
||||
Range{
|
||||
Value: &RangeSMPTE{
|
||||
Start: RangeSMPTETime{
|
||||
Time: time.Duration(10*60) * time.Second,
|
||||
Frame: 1,
|
||||
},
|
||||
},
|
||||
},
|
||||
},
|
||||
{
|
||||
"npt",
|
||||
base.HeaderValue{`npt=123.45-125`},
|
||||
base.HeaderValue{`npt=123.45-125`},
|
||||
Range{
|
||||
Value: &RangeNPT{
|
||||
Start: RangeNPTTime(123.45 * float64(time.Second)),
|
||||
End: func() *RangeNPTTime {
|
||||
v := RangeNPTTime(125 * time.Second)
|
||||
return &v
|
||||
}(),
|
||||
},
|
||||
},
|
||||
},
|
||||
{
|
||||
"npt open ended",
|
||||
base.HeaderValue{`npt=12:05:35.3-`},
|
||||
base.HeaderValue{`npt=43535.3-`},
|
||||
Range{
|
||||
Value: &RangeNPT{
|
||||
Start: RangeNPTTime(float64(12*3600+5*60+35.3) * float64(time.Second)),
|
||||
},
|
||||
},
|
||||
},
|
||||
{
|
||||
"clock",
|
||||
base.HeaderValue{`clock=19961108T142300Z-19961108T143520Z`},
|
||||
base.HeaderValue{`clock=19961108T142300Z-19961108T143520Z`},
|
||||
Range{
|
||||
Value: &RangeUTC{
|
||||
Start: RangeUTCTime(time.Date(1996, 11, 8, 14, 23, 0, 0, time.UTC)),
|
||||
End: func() *RangeUTCTime {
|
||||
v := RangeUTCTime(time.Date(1996, 11, 8, 14, 35, 20, 0, time.UTC))
|
||||
return &v
|
||||
}(),
|
||||
},
|
||||
},
|
||||
},
|
||||
{
|
||||
"clock open ended",
|
||||
base.HeaderValue{`clock=19960213T143205Z-`},
|
||||
base.HeaderValue{`clock=19960213T143205Z-`},
|
||||
Range{
|
||||
Value: &RangeUTC{
|
||||
Start: RangeUTCTime(time.Date(1996, 2, 13, 14, 32, 5, 0, time.UTC)),
|
||||
},
|
||||
},
|
||||
},
|
||||
{
|
||||
"time",
|
||||
base.HeaderValue{`clock=19960213T143205Z-;time=19970123T143720Z`},
|
||||
base.HeaderValue{`clock=19960213T143205Z-;time=19970123T143720Z`},
|
||||
Range{
|
||||
Value: &RangeUTC{
|
||||
Start: RangeUTCTime(time.Date(1996, 2, 13, 14, 32, 5, 0, time.UTC)),
|
||||
},
|
||||
Time: func() *RangeUTCTime {
|
||||
v := RangeUTCTime(time.Date(1997, 1, 23, 14, 37, 20, 0, time.UTC))
|
||||
return &v
|
||||
}(),
|
||||
},
|
||||
},
|
||||
}
|
||||
|
||||
func TestRangeRead(t *testing.T) {
|
||||
for _, ca := range casesRange {
|
||||
t.Run(ca.name, func(t *testing.T) {
|
||||
var h Range
|
||||
err := h.Read(ca.vin)
|
||||
require.NoError(t, err)
|
||||
require.Equal(t, ca.h, h)
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func TestRangeWrite(t *testing.T) {
|
||||
for _, ca := range casesRange {
|
||||
t.Run(ca.name, func(t *testing.T) {
|
||||
req := ca.h.Write()
|
||||
require.Equal(t, ca.vout, req)
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func TestRangeReadErrors(t *testing.T) {
|
||||
for _, ca := range []struct {
|
||||
name string
|
||||
hv base.HeaderValue
|
||||
err string
|
||||
}{
|
||||
{
|
||||
"empty",
|
||||
base.HeaderValue{},
|
||||
"value not provided",
|
||||
},
|
||||
{
|
||||
"2 values",
|
||||
base.HeaderValue{"a", "b"},
|
||||
"value provided multiple times ([a b])",
|
||||
},
|
||||
{
|
||||
"invalid keys",
|
||||
base.HeaderValue{`key1="k`},
|
||||
"apexes not closed (key1=\"k)",
|
||||
},
|
||||
{
|
||||
"value not found",
|
||||
base.HeaderValue{``},
|
||||
"value not found ()",
|
||||
},
|
||||
{
|
||||
"smpte without values",
|
||||
base.HeaderValue{`smpte=`},
|
||||
"invalid value ()",
|
||||
},
|
||||
{
|
||||
"smtpe end invalid",
|
||||
base.HeaderValue{`smpte=00:00:01-123`},
|
||||
"invalid SMPTE time (123)",
|
||||
},
|
||||
{
|
||||
"smpte invalid 1",
|
||||
base.HeaderValue{`smpte=123-`},
|
||||
"invalid SMPTE time (123)",
|
||||
},
|
||||
{
|
||||
"smpte invalid 2",
|
||||
base.HeaderValue{`smpte=aa:00:00-`},
|
||||
"strconv.ParseUint: parsing \"aa\": invalid syntax",
|
||||
},
|
||||
{
|
||||
"smpte invalid 3",
|
||||
base.HeaderValue{`smpte=00:aa:00-`},
|
||||
"strconv.ParseUint: parsing \"aa\": invalid syntax",
|
||||
},
|
||||
{
|
||||
"smpte invalid 4",
|
||||
base.HeaderValue{`smpte=00:00:aa-`},
|
||||
"strconv.ParseUint: parsing \"aa\": invalid syntax",
|
||||
},
|
||||
{
|
||||
"smpte invalid 5",
|
||||
base.HeaderValue{`smpte=00:00:00:aa-`},
|
||||
"strconv.ParseUint: parsing \"aa\": invalid syntax",
|
||||
},
|
||||
{
|
||||
"smpte invalid 6",
|
||||
base.HeaderValue{`smpte=00:00:00:aa.00-`},
|
||||
"strconv.ParseUint: parsing \"aa\": invalid syntax",
|
||||
},
|
||||
{
|
||||
"smpte invalid 7",
|
||||
base.HeaderValue{`smpte=00:00:00:00.aa-`},
|
||||
"strconv.ParseUint: parsing \"aa\": invalid syntax",
|
||||
},
|
||||
{
|
||||
"npt without values",
|
||||
base.HeaderValue{`npt=`},
|
||||
"invalid value ()",
|
||||
},
|
||||
{
|
||||
"npt end invalid",
|
||||
base.HeaderValue{`npt=00:00:00-aa`},
|
||||
"strconv.ParseFloat: parsing \"aa\": invalid syntax",
|
||||
},
|
||||
{
|
||||
"npt invalid 1",
|
||||
base.HeaderValue{`npt=00:00:00:00-`},
|
||||
"invalid NPT time (00:00:00:00)",
|
||||
},
|
||||
{
|
||||
"npt invalid 2",
|
||||
base.HeaderValue{`npt=aa-`},
|
||||
"strconv.ParseFloat: parsing \"aa\": invalid syntax",
|
||||
},
|
||||
{
|
||||
"npt invalid 3",
|
||||
base.HeaderValue{`npt=aa:00-`},
|
||||
"strconv.ParseUint: parsing \"aa\": invalid syntax",
|
||||
},
|
||||
{
|
||||
"npt invalid 4",
|
||||
base.HeaderValue{`npt=aa:00:00-`},
|
||||
"strconv.ParseUint: parsing \"aa\": invalid syntax",
|
||||
},
|
||||
{
|
||||
"clock without values",
|
||||
base.HeaderValue{`clock=`},
|
||||
"invalid value ()",
|
||||
},
|
||||
{
|
||||
"clock end invalid",
|
||||
base.HeaderValue{`clock=20060102T150405Z-aa`},
|
||||
"parsing time \"aa\" as \"20060102T150405Z\": cannot parse \"aa\" as \"2006\"",
|
||||
},
|
||||
{
|
||||
"clock invalid 1",
|
||||
base.HeaderValue{`clock=aa-`},
|
||||
"parsing time \"aa\" as \"20060102T150405Z\": cannot parse \"aa\" as \"2006\"",
|
||||
},
|
||||
{
|
||||
"time invalid",
|
||||
base.HeaderValue{`time=aa`},
|
||||
"parsing time \"aa\" as \"20060102T150405Z\": cannot parse \"aa\" as \"2006\"",
|
||||
},
|
||||
} {
|
||||
t.Run(ca.name, func(t *testing.T) {
|
||||
var h Range
|
||||
err := h.Read(ca.hv)
|
||||
require.Equal(t, ca.err, err.Error())
|
||||
})
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user