63 lines
2.2 KiB
Go
63 lines
2.2 KiB
Go
package api
|
|
|
|
import (
|
|
"bytes"
|
|
"compress/gzip"
|
|
"encoding/base64"
|
|
"encoding/binary"
|
|
"fmt"
|
|
"math"
|
|
)
|
|
|
|
// Lossless transport: IEEE-754 bit deltas and exact integer deltas. Never round
|
|
// media times or change hardware frame IDs to reduce the response size.
|
|
func compactAnnotationTimeline(value map[string]any) (map[string]any, error) {
|
|
l, ok := value["boundariesSeconds"].([]float64)
|
|
if !ok {
|
|
return nil, fmt.Errorf("invalid timeline")
|
|
}
|
|
r := value["rightBoundariesSeconds"].([]float64)
|
|
t := value["boundaryTimestampUs"].([]int64)
|
|
li := value["leftFrameIndices"].([]int)
|
|
ri := value["rightFrameIndices"].([]int)
|
|
n := len(l)
|
|
if n < 2 || len(r) != n || len(t) != n || len(li) != n || len(ri) != n {
|
|
return nil, fmt.Errorf("invalid timeline lengths")
|
|
}
|
|
data := make([]byte, 0, n*16)
|
|
if li[n-1] <= 0 || ri[n-1] <= 0 {
|
|
return nil, fmt.Errorf("invalid timeline terminal frame")
|
|
}
|
|
var stamp, left, right uint64
|
|
for i := range l {
|
|
lb, rb := math.Float64bits(l[i]), math.Float64bits(r[i])
|
|
if t[i] < 0 || uint64(t[i]) < stamp || li[i] < int(left) || ri[i] < int(right) {
|
|
return nil, fmt.Errorf("invalid timeline order")
|
|
}
|
|
data = binary.AppendUvarint(data, uint64(t[i])-stamp)
|
|
data = binary.AppendUvarint(data, uint64(li[i])-left)
|
|
data = binary.AppendUvarint(data, uint64(ri[i])-right)
|
|
// The predictor is only compression: transmit every differing bit too.
|
|
lp := float64(li[i]) * l[n-1] / float64(li[n-1])
|
|
rp := float64(ri[i]) * r[n-1] / float64(ri[n-1])
|
|
data = binary.AppendUvarint(data, lb^math.Float64bits(lp))
|
|
data = binary.AppendUvarint(data, rb^math.Float64bits(rp))
|
|
stamp, left, right = uint64(t[i]), uint64(li[i]), uint64(ri[i])
|
|
}
|
|
var packed bytes.Buffer
|
|
z := gzip.NewWriter(&packed)
|
|
if _, e := z.Write(data); e != nil {
|
|
return nil, e
|
|
}
|
|
if e := z.Close(); e != nil {
|
|
return nil, e
|
|
}
|
|
out := cloneTimeline(value)
|
|
for _, key := range []string{"boundariesSeconds", "rightBoundariesSeconds", "boundaryTimestampUs", "leftFrameIndices", "rightFrameIndices"} {
|
|
delete(out, key)
|
|
}
|
|
out["encoding"], out["pointCount"], out["data"] = "frame-grid-gzip-v1", n, base64.StdEncoding.EncodeToString(packed.Bytes())
|
|
out["predictor"] = []float64{l[n-1], float64(li[n-1]), r[n-1], float64(ri[n-1])}
|
|
return out, nil
|
|
}
|