Mitchell-JohnsonandClaude Fable 5.1
a9bcb88212
The viewer hands a video or audio file to the browser untouched — container, codec and all — and the browser plays what it can; when it can't, the viewer says so and offers the download. What the server adds is the part a player needs: /api/files/read now goes through http.ServeContent for a real file of known size, so Range requests (seeking) and HEAD work, and a download can resume. The root backend's helper takes an offset for that, and a Seeker opens the backend once, at the range asked for, instead of streaming from the top. Audio files are a preview kind too: their cover art is the thumbnail. Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
90 lines
1.9 KiB
Go
90 lines
1.9 KiB
Go
package files
|
|
|
|
import (
|
|
"context"
|
|
"errors"
|
|
"io"
|
|
)
|
|
|
|
// Seeker is an FS file as http.ServeContent wants one — something to seek in — for a file
|
|
// whose size is already known from a stat. ServeContent seeks to the end for the size, to
|
|
// the start of the range asked for, then reads: so the backend is opened once, at that
|
|
// position, and only ever read forward. The Sudo backend's helper is started at the offset
|
|
// rather than streamed from the top and skipped.
|
|
type Seeker struct {
|
|
ctx context.Context
|
|
fsys FS
|
|
path string
|
|
size int64
|
|
pos int64 // where the next Read reads from
|
|
at int64 // where cur is positioned, when open
|
|
cur io.ReadCloser
|
|
}
|
|
|
|
func NewSeeker(ctx context.Context, fsys FS, path string, size int64) *Seeker {
|
|
return &Seeker{ctx: ctx, fsys: fsys, path: path, size: size}
|
|
}
|
|
|
|
// Check opens the file now, from the start, so a file that cannot be read is known before
|
|
// any headers go out. A later seek elsewhere simply reopens.
|
|
func (s *Seeker) Check() error {
|
|
if s.cur != nil {
|
|
return nil
|
|
}
|
|
f, err := s.fsys.OpenAt(s.ctx, s.path, 0)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
s.cur, s.at = f, 0
|
|
return nil
|
|
}
|
|
|
|
func (s *Seeker) Seek(offset int64, whence int) (int64, error) {
|
|
var pos int64
|
|
switch whence {
|
|
case io.SeekStart:
|
|
pos = offset
|
|
case io.SeekCurrent:
|
|
pos = s.pos + offset
|
|
case io.SeekEnd:
|
|
pos = s.size + offset
|
|
default:
|
|
return 0, errors.New("bad whence")
|
|
}
|
|
if pos < 0 {
|
|
return 0, errors.New("seek before start")
|
|
}
|
|
if s.cur != nil && pos != s.at {
|
|
s.cur.Close()
|
|
s.cur = nil
|
|
}
|
|
s.pos = pos
|
|
return pos, nil
|
|
}
|
|
|
|
func (s *Seeker) Read(p []byte) (int, error) {
|
|
if s.pos >= s.size {
|
|
return 0, io.EOF
|
|
}
|
|
if s.cur == nil {
|
|
f, err := s.fsys.OpenAt(s.ctx, s.path, s.pos)
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
s.cur, s.at = f, s.pos
|
|
}
|
|
n, err := s.cur.Read(p)
|
|
s.pos += int64(n)
|
|
s.at += int64(n)
|
|
return n, err
|
|
}
|
|
|
|
func (s *Seeker) Close() error {
|
|
if s.cur == nil {
|
|
return nil
|
|
}
|
|
err := s.cur.Close()
|
|
s.cur = nil
|
|
return err
|
|
}
|