Implement to unmarshal PT duration

mpd/duration.go

@@ -4,6 +4,9 @@ package mpd
 
 import (
 	"encoding/xml"
+	"errors"
+	"strconv"
+	"strings"
 	"time"
 )
 
@@ -13,6 +16,15 @@ func (d Duration) MarshalXMLAttr(name xml.Name) (xml.Attr, error) {
 	return xml.Attr{name, d.String()}, nil
 }
 
+func (d *Duration) UnmarshalXMLAttr(attr xml.Attr) error {
+	dur, err := parseDuration(attr.Value)
+	if err != nil {
+		return err
+	}
+	*d = Duration(dur)
+	return nil
+}
+
 // String renders a Duration in XML Duration Data Type format
 func (d *Duration) String() string {
 	// Largest time is 2540400h10m10.000000000s
@@ -126,3 +138,80 @@ func fmtInt(buf []byte, v uint64) int {
 	}
 	return w
 }
+
+func parseDuration(str string) (time.Duration, error) {
+	if len(str) < 3 {
+		return 0, errors.New("input duration too short")
+	}
+
+	var minus bool
+	offset := 0
+	if str[offset] == '-' {
+		minus = true
+		offset++
+	}
+
+	if str[offset] != 'P' {
+		return 0, errors.New("input duration does not have a valid prefix")
+	}
+	offset++
+
+	var dateStr, timeStr string
+	if i := strings.IndexByte(str[offset:], 'T'); i != -1 {
+		dateStr = str[offset : offset+i]
+		timeStr = str[offset+i+1:]
+	} else {
+		dateStr = str[offset:]
+	}
+
+	var sum float64
+	if len(dateStr) > 0 {
+		if i := strings.IndexByte(dateStr, 'Y'); i != -1 {
+			return 0, errors.New("input duration contains Years notation")
+		}
+
+		if i := strings.IndexByte(dateStr, 'M'); i != -1 {
+			return 0, errors.New("input duration contains Months notation")
+		}
+
+		if i := strings.IndexByte(dateStr, 'D'); i != -1 {
+			days, err := strconv.Atoi(dateStr[0:i])
+			if err != nil {
+				return 0, err
+			}
+			sum += float64(days) * 86400
+		}
+	}
+
+	if len(timeStr) > 0 {
+		var pos int
+		if i := strings.IndexByte(timeStr[pos:], 'H'); i != -1 {
+			hours, err := strconv.ParseInt(timeStr[pos:pos+i], 10, 64)
+			if err != nil {
+				return 0, err
+			}
+			sum += float64(hours) * 3600
+			pos += i + 1
+		}
+		if i := strings.IndexByte(timeStr[pos:], 'M'); i != -1 {
+			minutes, err := strconv.ParseInt(timeStr[pos:pos+i], 10, 64)
+			if err != nil {
+				return 0, err
+			}
+			sum += float64(minutes) * 60
+			pos += i + 1
+		}
+		if i := strings.IndexByte(timeStr[pos:], 'S'); i != -1 {
+			seconds, err := strconv.ParseFloat(timeStr[pos:pos+i], 64)
+			if err != nil {
+				return 0, err
+			}
+			sum += seconds
+		}
+	}
+
+	if minus {
+		sum = -sum
+	}
+	return time.Duration(sum * float64(time.Second)), nil
+}

mpd/duration_test.go

@@ -20,3 +20,23 @@ func TestDuration(t *testing.T) {
 		assert.Equal(t, ex, dur.String())
 	}
 }
+
+func TestParseDuration(t *testing.T) {
+	in := map[string]float64{
+		"PT0S":         0,
+		"PT1M":         60,
+		"PT2H":         7200,
+		"PT6M16S":      376,
+		"PT1.97S":      1.97,
+		"PT1H2M3.456S": 3723.456,
+		"P1DT2H":       (26 * time.Hour).Seconds(),
+		"PT20M":        (20 * time.Minute).Seconds(),
+		"-P60D":        -(60 * 24 * time.Hour).Seconds(),
+		"PT1M30.5S":    (time.Minute + 30*time.Second + 500*time.Millisecond).Seconds(),
+	}
+	for ins, ex := range in {
+		act, err := parseDuration(ins)
+		assert.NoError(t, err, ins)
+		assert.Equal(t, ex, act.Seconds(), ins)
+	}
+}