feat: spool media inputs to disk and report producer progress

This commit is contained in:
Levi committed 2026-09-16 23:16:19 +08:00
1 parent e99ef6c7f4
commit e0ced260e2
36 files changed
+1747 -366

No files matched your search

-91
View File
@@ -115,29 +115,6 @@ func TestHTTPSequentialAndValidation(t *testing.T) {
}
}
func TestStreamRing(t *testing.T) {
s := NewStreamInput(context.Background())
defer s.Close()
// Start near the boundary to exercise wrap-around without a huge fixture.
s.buffer = make([]byte, 256*1024)
s.read = int64(len(s.buffer)) - 3
s.written = s.read
if _, err := s.Write([]byte("abcdefgh")); err != nil {
t.Fatal(err)
}
s.End(nil)
b, err := io.ReadAll(s)
if err != nil || string(b) != "abcdefgh" {
t.Fatalf("%q %v", b, err)
}
if err = s.Close(); err != nil {
t.Fatal(err)
}
if s.buffer != nil {
t.Fatal("buffer retained after close")
}
}
func TestOutputArguments(t *testing.T) {
a, err := Arguments("", []string{"-shortest", "-metadata", "title=test"})
if err != nil {
@@ -152,71 +129,3 @@ func TestOutputArguments(t *testing.T) {
}
}
}
func TestStreamBackpressureAndCancel(t *testing.T) {
ctx, cancel := context.WithCancel(context.Background())
defer cancel()
s := NewStreamInput(ctx)
defer s.Close()
s.buffer = make([]byte, StreamBufferLimit)
s.written = StreamBufferLimit
finished := make(chan error, 1)
go func() { _, err := s.Write([]byte{42}); finished <- err }()
select {
case err := <-finished:
t.Fatalf("did not apply backpressure: %v", err)
case <-time.After(10 * time.Millisecond):
}
if _, err := s.Read(make([]byte, 1)); err != nil {
t.Fatal(err)
}
select {
case err := <-finished:
if err != nil {
t.Fatal(err)
}
case <-time.After(time.Second):
t.Fatal("writer did not resume")
}
go func() { _, err := s.Write([]byte{43}); finished <- err }()
cancel()
select {
case err := <-finished:
if err == nil {
t.Fatal("cancelled write succeeded")
}
case <-time.After(time.Second):
t.Fatal("writer did not cancel")
}
}
func TestStreamMemoryGrowthAndWrap(t *testing.T) {
s := NewStreamInput(context.Background())
defer s.Close()
if len(s.buffer) != 0 {
t.Fatal("buffer allocated before first write")
}
a := bytes.Repeat([]byte{1}, 200*1024)
b := bytes.Repeat([]byte{2}, 180*1024)
s.Write(a)
consumed := make([]byte, 180*1024)
if _, err := io.ReadFull(s, consumed); err != nil {
t.Fatal(err)
}
s.Write(b) // Wrap in the initial 256 KiB allocation.
c := bytes.Repeat([]byte{3}, 300*1024)
s.Write(c) // Grow while unread data wraps around the old ring.
s.End(nil)
got, err := io.ReadAll(s)
want := append(append(append([]byte{}, a[len(consumed):]...), b...), c...)
if err != nil || !bytes.Equal(got, want) {
t.Fatalf("growth corrupted data: %v", err)
}
if len(s.buffer) > StreamBufferLimit {
t.Fatal("buffer exceeded limit")
}
s.Close()
if s.buffer != nil {
t.Fatal("buffer retained on close")
}
}