Allow to import report history for a process

restream/app/progress.go

@@ -1,5 +1,13 @@
 package app
 
+import "github.com/datarhei/core/v16/ffmpeg/parse"
+
+type ProgressIOFramerate struct {
+	Min     float64
+	Max     float64
+	Average float64
+}
+
 type ProgressIO struct {
 	ID      string
 	Address string
@@ -13,11 +21,7 @@ type ProgressIO struct {
 	Coder     string
 	Frame     uint64 // counter
 	Keyframe  uint64 // counter
-	Framerate struct {
-		Min     float64
-		Max     float64
-		Average float64
-	}
+	Framerate ProgressIOFramerate
 	FPS       float64 // rate, frames per second
 	Packet    uint64  // counter
 	PPS       float64 // rate, packets per second
@@ -40,6 +44,67 @@ type ProgressIO struct {
 	AVstream *AVstream
 }
 
+func (p *ProgressIO) UnmarshalParser(pp *parse.ProgressIO) {
+	p.Address = pp.Address
+	p.Index = pp.Index
+	p.Stream = pp.Stream
+	p.Format = pp.Format
+	p.Type = pp.Type
+	p.Codec = pp.Codec
+	p.Coder = pp.Coder
+	p.Frame = pp.Frame
+	p.Keyframe = pp.Keyframe
+	p.Framerate = pp.Framerate
+	p.FPS = pp.FPS
+	p.Packet = pp.Packet
+	p.PPS = pp.PPS
+	p.Size = pp.Size
+	p.Bitrate = pp.Bitrate
+	p.Extradata = pp.Extradata
+	p.Pixfmt = pp.Pixfmt
+	p.Quantizer = pp.Quantizer
+	p.Width = pp.Width
+	p.Height = pp.Height
+	p.Sampling = pp.Sampling
+	p.Layout = pp.Layout
+	p.Channels = pp.Channels
+	p.AVstream.UnmarshalParser(pp.AVstream)
+}
+
+func (p *ProgressIO) MarshalParser() parse.ProgressIO {
+	pp := parse.ProgressIO{
+		Address:   p.Address,
+		Index:     p.Index,
+		Stream:    p.Stream,
+		Format:    p.Format,
+		Type:      p.Type,
+		Codec:     p.Codec,
+		Coder:     p.Coder,
+		Frame:     p.Frame,
+		Keyframe:  p.Keyframe,
+		Framerate: p.Framerate,
+		FPS:       p.FPS,
+		Packet:    p.Packet,
+		PPS:       p.PPS,
+		Size:      p.Size,
+		Bitrate:   p.Bitrate,
+		Extradata: p.Extradata,
+		Pixfmt:    p.Pixfmt,
+		Quantizer: p.Quantizer,
+		Width:     p.Width,
+		Height:    p.Height,
+		Sampling:  p.Sampling,
+		Layout:    p.Layout,
+		Channels:  p.Channels,
+	}
+
+	if p.AVstream != nil {
+		pp.AVstream = p.AVstream.MarshalParser()
+	}
+
+	return pp
+}
+
 type Progress struct {
 	Started   bool
 	Input     []ProgressIO
@@ -58,6 +123,69 @@ type Progress struct {
 	Dup       uint64  // counter
 }
 
+func (p *Progress) UnmarshalParser(pp *parse.Progress) {
+	p.Started = pp.Started
+	p.Frame = pp.Frame
+	p.Packet = pp.Packet
+	p.FPS = pp.FPS
+	p.PPS = pp.PPS
+	p.Quantizer = pp.Quantizer
+	p.Size = pp.Size
+	p.Time = pp.Time
+	p.Bitrate = pp.Bitrate
+	p.Speed = pp.Speed
+	p.Drop = pp.Drop
+	p.Dup = pp.Dup
+
+	p.Input = make([]ProgressIO, len(pp.Input))
+
+	for i, pinput := range pp.Input {
+		p.Input[i].UnmarshalParser(&pinput)
+	}
+
+	p.Output = make([]ProgressIO, len(pp.Output))
+
+	for i, poutput := range pp.Output {
+		p.Output[i].UnmarshalParser(&poutput)
+	}
+
+	p.Mapping.UnmarshalParser(&pp.Mapping)
+}
+
+func (p *Progress) MarshalParser() parse.Progress {
+	pp := parse.Progress{
+		Started:   p.Started,
+		Input:     []parse.ProgressIO{},
+		Output:    []parse.ProgressIO{},
+		Mapping:   p.Mapping.MarshalParser(),
+		Frame:     p.Frame,
+		Packet:    p.Packet,
+		FPS:       p.FPS,
+		PPS:       p.PPS,
+		Quantizer: p.Quantizer,
+		Size:      p.Size,
+		Time:      p.Time,
+		Bitrate:   p.Bitrate,
+		Speed:     p.Speed,
+		Drop:      p.Drop,
+		Dup:       p.Dup,
+	}
+
+	pp.Input = make([]parse.ProgressIO, len(p.Input))
+
+	for i, pinput := range p.Input {
+		pp.Input[i] = pinput.MarshalParser()
+	}
+
+	pp.Output = make([]parse.ProgressIO, len(p.Output))
+
+	for i, poutput := range p.Output {
+		pp.Output[i] = poutput.MarshalParser()
+	}
+
+	return pp
+}
+
 type GraphElement struct {
 	Index     int
 	Name      string
@@ -75,6 +203,44 @@ type GraphElement struct {
 	Height    uint64
 }
 
+func (g *GraphElement) UnmarshalParser(p *parse.GraphElement) {
+	g.Index = p.Index
+	g.Name = p.Name
+	g.Filter = p.Filter
+	g.DstName = p.DstName
+	g.DstFilter = p.DstFilter
+	g.Inpad = p.Inpad
+	g.Outpad = p.Outpad
+	g.Timebase = p.Timebase
+	g.Type = p.Type
+	g.Format = p.Format
+	g.Sampling = p.Sampling
+	g.Layout = p.Layout
+	g.Width = p.Width
+	g.Height = p.Height
+}
+
+func (g *GraphElement) MarshalParser() parse.GraphElement {
+	p := parse.GraphElement{
+		Index:     g.Index,
+		Name:      g.Name,
+		Filter:    g.Filter,
+		DstName:   g.DstName,
+		DstFilter: g.DstFilter,
+		Inpad:     g.Inpad,
+		Outpad:    g.Outpad,
+		Timebase:  g.Timebase,
+		Type:      g.Type,
+		Format:    g.Format,
+		Sampling:  g.Sampling,
+		Layout:    g.Layout,
+		Width:     g.Width,
+		Height:    g.Height,
+	}
+
+	return p
+}
+
 type GraphMapping struct {
 	Input  int    // Index of input stream, negative if output element
 	Output int    // Index of output stream, negative if input element
@@ -83,7 +249,58 @@ type GraphMapping struct {
 	Copy   bool   // Whether it's a streamcopy i.e. there's no graph
 }
 
+func (g *GraphMapping) UnmarshalParser(p *parse.GraphMapping) {
+	g.Input = p.Input
+	g.Output = p.Output
+	g.Index = p.Index
+	g.Name = p.Name
+	g.Copy = p.Copy
+}
+
+func (g *GraphMapping) MarshalParser() parse.GraphMapping {
+	p := parse.GraphMapping{
+		Input:  g.Input,
+		Output: g.Output,
+		Index:  g.Index,
+		Name:   g.Name,
+		Copy:   g.Copy,
+	}
+
+	return p
+}
+
 type StreamMapping struct {
 	Graphs  []GraphElement
 	Mapping []GraphMapping
 }
+
+func (s *StreamMapping) UnmarshalParser(p *parse.StreamMapping) {
+	s.Graphs = make([]GraphElement, len(p.Graphs))
+
+	for i, graph := range p.Graphs {
+		s.Graphs[i].UnmarshalParser(&graph)
+	}
+
+	s.Mapping = make([]GraphMapping, len(p.Mapping))
+
+	for i, mapping := range p.Mapping {
+		s.Mapping[i].UnmarshalParser(&mapping)
+	}
+}
+
+func (s *StreamMapping) MarshalParser() parse.StreamMapping {
+	p := parse.StreamMapping{
+		Graphs:  make([]parse.GraphElement, len(s.Graphs)),
+		Mapping: make([]parse.GraphMapping, len(s.Mapping)),
+	}
+
+	for i, graph := range s.Graphs {
+		p.Graphs[i] = graph.MarshalParser()
+	}
+
+	for i, mapping := range s.Mapping {
+		p.Mapping[i] = mapping.MarshalParser()
+	}
+
+	return p
+}