rob
/
clipper
2
0
Fork 0
Code Issues 11 Pull Requests 1 Projects Releases Wiki Activity

Introduce PG store

This commit is contained in:
Rob Watson 2021-11-01 06:28:40 +01:00
parent 281d5ce8a2
commit 7c5b22a407
21 changed files with 628 additions and 468 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
.gitignore vendored
View File

@ -1,4 +1,4 @@
*.m4a
/backend/.env
/backend/cache/
/backend/debug/

2
backend/.env
View File

@ -1,2 +0,0 @@
AWS_ACCESS_KEY_ID=AKIARZPRT6YGKUMKQPV5
AWS_SECRET_ACCESS_KEY=P8zJInhiHoXT4NV0gFMNHy8XVN285CqfOSCeaCHX

4
backend/.env.example Normal file
View File

@ -0,0 +1,4 @@
AWS_ACCESS_KEY_ID=
AWS_SECRET_ACCESS_KEY=
DATABASE_URL=

17
backend/cmd/clipper/main.go
View File

@ -2,13 +2,17 @@ package main
import (
"context"
"database/sql"
"log"
"os"
"time"
"git.netflux.io/rob/clipper/generated/store"
"git.netflux.io/rob/clipper/server"
"github.com/aws/aws-sdk-go-v2/config"
"github.com/aws/aws-sdk-go-v2/service/s3"
"github.com/kkdai/youtube/v2"
_ "github.com/lib/pq"
)
const (
@ -19,12 +23,20 @@ const (
func main() {
ctx := context.Background()
// Create a store
databaseURL := os.Getenv("DATABASE_URL")
log.Printf("DATABASE_URL = %s", databaseURL)
db, err := sql.Open("postgres", databaseURL)
if err != nil {
log.Fatal(err)
}
store := store.New(db)
// Create an Amazon S3 service s3Client
cfg, err := config.LoadDefaultConfig(ctx)
if err != nil {
log.Fatal(err)
}
// Create an Amazon S3 service s3Client
s3Client := s3.NewFromConfig(cfg)
// Create a Youtube client
@ -33,6 +45,7 @@ func main() {
serverOptions := server.Options{
BindAddr: DefaultHTTPBindAddr,
Timeout: DefaultTimeout,
Store: store,
YoutubeClient: &youtubeClient,
S3Client: s3Client,
}

23
backend/cmd/progress-test/main.go
View File

@ -2,13 +2,18 @@ package main
import (
"context"
"database/sql"
"io"
"log"
"os"
"git.netflux.io/rob/clipper/generated/store"
"git.netflux.io/rob/clipper/media"
"github.com/aws/aws-sdk-go-v2/config"
"github.com/aws/aws-sdk-go-v2/service/s3"
"github.com/google/uuid"
"github.com/kkdai/youtube/v2"
_ "github.com/lib/pq"
)
const (
@ -18,22 +23,30 @@ const (
func main() {
ctx := context.Background()
// Create a store
databaseURL := os.Getenv("DATABASE_URL")
db, err := sql.Open("postgres", databaseURL)
if err != nil {
log.Fatal(err)
}
store := store.New(db)
// Create an Amazon S3 service s3Client
cfg, err := config.LoadDefaultConfig(ctx)
if err != nil {
log.Fatal(err)
}
// Create an Amazon S3 service s3Client
s3Client := s3.NewFromConfig(cfg)
// Create a Youtube client
var youtubeClient youtube.Client
// Create a VideoFetchService
fetchService := media.NewFetchMediaSetService(&youtubeClient, s3Client)
// Create a MediaSetService
mediaSetService := media.NewMediaSetService(store, &youtubeClient, s3Client)
// Create a progressReader
progressReader, err := fetchService.FetchAudio(ctx, videoID)
// TODO: fix
progressReader, err := mediaSetService.GetAudio(ctx, uuid.New(), 100)
if err != nil {
log.Fatalf("error calling fetch service: %v", err)
}

2
backend/go.mod
View File

@ -3,6 +3,7 @@ module git.netflux.io/rob/clipper
go 1.17
require (
github.com/google/uuid v1.1.2
github.com/improbable-eng/grpc-web v0.14.1
github.com/kkdai/youtube/v2 v2.7.4
github.com/labstack/echo/v4 v4.6.0
@ -30,6 +31,7 @@ require (
github.com/golang/protobuf v1.5.2 // indirect
github.com/klauspost/compress v1.11.7 // indirect
github.com/labstack/gommon v0.3.0 // indirect
github.com/lib/pq v1.10.3 // indirect
github.com/mattn/go-colorable v0.1.8 // indirect
github.com/mattn/go-isatty v0.0.14 // indirect
github.com/pmezard/go-difflib v1.0.0 // indirect

3
backend/go.sum
View File

@ -252,6 +252,7 @@ github.com/google/pprof v0.0.0-20210122040257-d980be63207e/go.mod h1:kpwsk12EmLe
github.com/google/pprof v0.0.0-20210226084205-cbba55b83ad5/go.mod h1:kpwsk12EmLew5upagYY7GY0pfYCcupk39gWOCRROcvE=
github.com/google/renameio v0.1.0/go.mod h1:KWCgfxg9yswjAJkECMjeO8J8rahYeXnNhOm40UhjYkI=
github.com/google/uuid v1.0.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
github.com/google/uuid v1.1.2 h1:EVhdT+1Kseyi1/pUmXKaFxYsDNy9RQYkMWRH68J/W7Y=
github.com/google/uuid v1.1.2/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
github.com/googleapis/gax-go/v2 v2.0.4/go.mod h1:0Wqv26UfaUD9n4G6kQubkQ+KchISgw+vpHVxEJEs9eg=
github.com/googleapis/gax-go/v2 v2.0.5/go.mod h1:DWXyrwAJ9X0FpwwEdw+IPEYBICEFu5mhpdKc/us6bOk=
@ -341,6 +342,8 @@ github.com/labstack/gommon v0.3.0 h1:JEeO0bvc78PKdyHxloTKiF8BD5iGrH8T6MSeGvSgob0
github.com/labstack/gommon v0.3.0/go.mod h1:MULnywXg0yavhxWKc+lOruYdAhDwPK9wf0OL7NoOu+k=
github.com/leodido/go-urn v1.2.0 h1:hpXL4XnriNwQ/ABnpepYM/1vCLWNDfUNts8dX3xTG6Y=
github.com/leodido/go-urn v1.2.0/go.mod h1:+8+nEpDfqqsY+g338gtMEUOtuK+4dEMhiQEgxpxOKII=
github.com/lib/pq v1.10.3 h1:v9QZf2Sn6AmjXtQeFpdoq/eaNtYP6IN+7lcrygsIAtg=
github.com/lib/pq v1.10.3/go.mod h1:AlVN5x4E4T544tWzH6hKfbfQvm3HdbOxrmggDNAPY9o=
github.com/lightstep/lightstep-tracer-common/golang/gogo v0.0.0-20190605223551-bc2310a04743/go.mod h1:qklhhLq1aX+mtWk9cPHPzaBjWImj5ULL6C7HFJtXQMM=
github.com/lightstep/lightstep-tracer-go v0.18.1/go.mod h1:jlF1pusYV4pidLvZ+XD0UBX0ZE6WURAspgAczcDHrL4=
github.com/lyft/protoc-gen-validate v0.0.13/go.mod h1:XbGvPuh87YZc5TdIa2/I4pLk0QoUACkjt2znoq26NVQ=

20
backend/media/audio_progress.go
View File

@ -7,13 +7,13 @@ import (
"io"
)
type FetchAudioProgress struct {
type GetAudioProgress struct {
PercentComplete float32
Peaks []int16
}
type FetchAudioProgressReader interface {
Read() (FetchAudioProgress, error)
type GetAudioProgressReader interface {
Read() (GetAudioProgress, error)
Close() error
}
@ -29,19 +29,19 @@ type fetchAudioProgressReader struct {
currPeaks []int16
currCount int
framesProcessed int
progress chan FetchAudioProgress
progress chan GetAudioProgress
errorChan chan error
}
// TODO: validate inputs, debugging is confusing otherwise
func newFetchAudioProgressReader(framesExpected int64, channels, numBins int) *fetchAudioProgressReader {
func newGetAudioProgressReader(framesExpected int64, channels, numBins int) *fetchAudioProgressReader {
return &fetchAudioProgressReader{
channels: channels,
framesExpected: framesExpected,
framesPerBin: int(framesExpected / int64(numBins)),
samples: make([]int16, 8_192),
currPeaks: make([]int16, channels),
progress: make(chan FetchAudioProgress),
progress: make(chan GetAudioProgress),
errorChan: make(chan error, 1),
}
}
@ -90,7 +90,7 @@ func (w *fetchAudioProgressReader) Write(p []byte) (int, error) {
}
func (w *fetchAudioProgressReader) nextBin() {
var progress FetchAudioProgress
var progress GetAudioProgress
// TODO: avoid an allocation?
progress.Peaks = append(progress.Peaks, w.currPeaks...)
progress.PercentComplete = (float32(w.framesProcessed) / float32(w.framesExpected)) * 100.0
@ -105,16 +105,16 @@ func (w *fetchAudioProgressReader) nextBin() {
w.framesProcessed++
}
func (w *fetchAudioProgressReader) Read() (FetchAudioProgress, error) {
func (w *fetchAudioProgressReader) Read() (GetAudioProgress, error) {
for {
select {
case progress, ok := <-w.progress:
if !ok {
return FetchAudioProgress{}, io.EOF
return GetAudioProgress{}, io.EOF
}
return progress, nil
case err := <-w.errorChan:
return FetchAudioProgress{}, fmt.Errorf("error waiting for progress: %v", err)
return GetAudioProgress{}, fmt.Errorf("error waiting for progress: %v", err)
}
}
}

268
backend/media/fetch.go
View File

@ -1,268 +0,0 @@
package media
import (
"context"
"errors"
"fmt"
"io"
"log"
"strconv"
"time"
"github.com/aws/aws-sdk-go-v2/service/s3"
youtubev2 "github.com/kkdai/youtube/v2"
)
const s3Bucket = "clipper-development"
const (
rawAudioCodec = "pcm_s16le"
rawAudioFormat = "s16le"
rawAudioSampleRate = 48_000
)
const (
thumbnailWidth = 177 // 16:9
thumbnailHeight = 100 // "
)
// progressReader is a reader that prints progress logs as it reads.
type progressReader struct {
io.Reader
label string
total, exp int
}
func (pw *progressReader) Read(p []byte) (int, error) {
n, err := pw.Reader.Read(p)
pw.total += n
log.Printf("[ProgressReader] [%s] Read %d of %d (%.02f%%) bytes from the provided reader", pw.label, pw.total, pw.exp, (float32(pw.total)/float32(pw.exp))*100.0)
return n, err
}
// S3Client wraps the AWS S3 service client.
type S3Client interface {
CreateMultipartUpload(context.Context, *s3.CreateMultipartUploadInput, ...func(*s3.Options)) (*s3.CreateMultipartUploadOutput, error)
UploadPart(context.Context, *s3.UploadPartInput, ...func(*s3.Options)) (*s3.UploadPartOutput, error)
AbortMultipartUpload(ctx context.Context, params *s3.AbortMultipartUploadInput, optFns ...func(*s3.Options)) (*s3.AbortMultipartUploadOutput, error)
CompleteMultipartUpload(context.Context, *s3.CompleteMultipartUploadInput, ...func(*s3.Options)) (*s3.CompleteMultipartUploadOutput, error)
}
// YoutubeClient wraps the youtube.Client client.
type YoutubeClient interface {
GetVideoContext(context.Context, string) (*youtubev2.Video, error)
GetStreamContext(context.Context, *youtubev2.Video, *youtubev2.Format) (io.ReadCloser, int64, error)
}
// FetchMediaSetService fetches a video via an io.Reader.
type FetchMediaSetService struct {
youtube YoutubeClient
s3 S3Client
}
func NewFetchMediaSetService(youtubeClient YoutubeClient, s3Client S3Client) *FetchMediaSetService {
return &FetchMediaSetService{
youtube: youtubeClient,
s3: s3Client,
}
}
// Fetch fetches the metadata for a given MediaSet source.
func (s *FetchMediaSetService) Fetch(ctx context.Context, id string) (*MediaSet, error) {
video, err := s.youtube.GetVideoContext(ctx, id)
if err != nil {
return nil, fmt.Errorf("error fetching video: %v", err)
}
if len(video.Formats) == 0 {
return nil, errors.New("no format available")
}
audioMetadata, err := s.fetchAudioMetadata(ctx, video)
if err != nil {
return nil, fmt.Errorf("error fetching audio metadata: %v", err)
}
videoMetadata, err := s.fetchVideoMetadata(ctx, video)
if err != nil {
return nil, fmt.Errorf("error fetching video metadata: %v", err)
}
mediaSet := MediaSet{
ID: id,
Audio: audioMetadata,
Video: videoMetadata,
}
// TODO: save to JSON
return &mediaSet, nil
}
func (s *FetchMediaSetService) fetchVideoMetadata(ctx context.Context, video *youtubev2.Video) (Video, error) {
formats := FilterYoutubeVideo(video.Formats)
if len(video.Formats) == 0 {
return Video{}, errors.New("no format available")
}
format := formats[0]
durationMsecs, err := strconv.Atoi(format.ApproxDurationMs)
if err != nil {
return Video{}, fmt.Errorf("could not parse video duration: %s", err)
}
return Video{
Bytes: format.ContentLength,
ThumbnailWidth: thumbnailWidth,
ThumbnailHeight: thumbnailHeight,
Duration: time.Duration(durationMsecs) * time.Millisecond,
}, nil
}
func (s *FetchMediaSetService) fetchAudioMetadata(ctx context.Context, video *youtubev2.Video) (Audio, error) {
formats := FilterYoutubeAudio(video.Formats)
if len(video.Formats) == 0 {
return Audio{}, errors.New("no format available")
}
format := formats[0]
sampleRate, err := strconv.Atoi(format.AudioSampleRate)
if err != nil {
return Audio{}, fmt.Errorf("invalid samplerate: %s", format.AudioSampleRate)
}
approxDurationMsecs, err := strconv.Atoi(format.ApproxDurationMs)
if err != nil {
return Audio{}, fmt.Errorf("could not parse audio duration: %s", err)
}
approxDuration := time.Duration(approxDurationMsecs) * time.Millisecond
approxFrames := int64(approxDuration/time.Second) * int64(sampleRate)
return Audio{
// we need to decode it to be able to know bytes and frame counts exactly
ApproxFrames: approxFrames,
Channels: format.AudioChannels,
SampleRate: sampleRate,
}, nil
}
// FetchAudio fetches the audio part of a MediaSet.
func (s *FetchMediaSetService) FetchAudio(ctx context.Context, id string, numBins int) (FetchAudioProgressReader, error) {
mediaSet := NewMediaSet(id)
if !mediaSet.Exists() {
// TODO check if audio uploaded already, don't bother again
return nil, errors.New("no media set found")
}
if err := mediaSet.Load(); err != nil {
return nil, fmt.Errorf("error loading media set: %v", err)
}
video, err := s.youtube.GetVideoContext(ctx, id)
if err != nil {
return nil, fmt.Errorf("error fetching video: %v", err)
}
formats := FilterYoutubeAudio(video.Formats)
if len(video.Formats) == 0 {
return nil, errors.New("no format available")
}
format := formats[0]
stream, _, err := s.youtube.GetStreamContext(ctx, video, &format)
if err != nil {
return nil, fmt.Errorf("error fetching stream: %v", err)
}
// wrap it in a progress reader
progressStream := &progressReader{Reader: stream, label: "audio", exp: int(format.ContentLength)}
ffmpegReader, err := newFfmpegReader(ctx, progressStream, "-i", "-", "-f", rawAudioFormat, "-ar", strconv.Itoa(rawAudioSampleRate), "-acodec", rawAudioCodec, "-")
if err != nil {
return nil, fmt.Errorf("error creating ffmpegreader: %v", err)
}
// set up uploader, this is writer 1
uploader, err := newMultipartUploadWriter(
ctx,
s.s3,
s3Bucket,
fmt.Sprintf("media_sets/%s/audio.webm", id),
"application/octet-stream",
)
if err != nil {
return nil, fmt.Errorf("error creating uploader: %v", err)
}
fetchAudioProgressReader := newFetchAudioProgressReader(
mediaSet.Audio.ApproxFrames,
format.AudioChannels,
100,
)
state := fetchAudioState{
fetchAudioProgressReader: fetchAudioProgressReader,
ffmpegReader: ffmpegReader,
uploader: uploader,
}
go state.run(ctx)
return &state, nil
}
type fetchAudioState struct {
*fetchAudioProgressReader
ffmpegReader io.ReadCloser
uploader *multipartUploadWriter
}
func (s *fetchAudioState) run(ctx context.Context) {
mw := io.MultiWriter(s, s.uploader)
done := make(chan error)
var err error
go func() {
_, copyErr := io.Copy(mw, s.ffmpegReader)
done <- copyErr
}()
outer:
for {
select {
case <-ctx.Done():
err = ctx.Err()
break outer
case err = <-done:
break outer
}
}
if readerErr := s.ffmpegReader.Close(); readerErr != nil {
if err == nil {
err = readerErr
}
}
if err == nil {
if uploaderErr := s.uploader.Complete(); uploaderErr != nil {
err = uploaderErr
}
}
if err != nil {
newCtx, cancel := context.WithTimeout(context.Background(), time.Second*5)
defer cancel()
if abortUploadErr := s.uploader.Abort(newCtx); abortUploadErr != nil {
log.Printf("error aborting uploader: %v", abortUploadErr)
}
s.Abort(err)
return
}
if iterErr := s.Close(); iterErr != nil {
log.Printf("error closing peak iterator: %v", iterErr)
}
}

25
backend/media/media_set.go
View File

@ -21,6 +21,8 @@ type Audio struct {
ApproxFrames int64 `json:"approx_frames"`
Frames int64 `json:"frames"`
SampleRate int `json:"sample_rate"`
YoutubeItag int `json:"youtube_itag"`
MimeType string `json:"mime_type"`
}
type Video struct {
@ -29,6 +31,8 @@ type Video struct {
// not sure if this are needed any more?
ThumbnailWidth int `json:"thumbnail_width"`
ThumbnailHeight int `json:"thumbnail_height"`
YoutubeItag int `json:"youtube_itag"`
MimeType string `json:"mime_type"`
}
// MediaSet represents the media and metadata associated with a single media
@ -37,24 +41,25 @@ type MediaSet struct {
Audio Audio `json:"audio"`
Video Video `json:"video"`
ID string `json:"id"`
YoutubeID string `json:"youtube_id"`
exists bool
exists bool `json:"exists"`
}
// New builds a new MediaSet with the given ID.
func NewMediaSet(id string) *MediaSet {
return &MediaSet{ID: id}
func NewMediaSet(youtubeID string) *MediaSet {
return &MediaSet{YoutubeID: youtubeID}
}
// TODO: pass io.Readers/Writers instead of strings.
func (m *MediaSet) RawAudioPath() string { return fmt.Sprintf("cache/%s.raw", m.ID) }
func (m *MediaSet) EncodedAudioPath() string { return fmt.Sprintf("cache/%s.m4a", m.ID) }
func (m *MediaSet) VideoPath() string { return fmt.Sprintf("cache/%s.mp4", m.ID) }
func (m *MediaSet) ThumbnailPath() string { return fmt.Sprintf("cache/%s.jpg", m.ID) }
func (m *MediaSet) MetadataPath() string { return fmt.Sprintf("cache/%s.json", m.ID) }
func (m *MediaSet) RawAudioPath() string { return fmt.Sprintf("cache/%s.raw", m.YoutubeID) }
func (m *MediaSet) EncodedAudioPath() string { return fmt.Sprintf("cache/%s.m4a", m.YoutubeID) }
func (m *MediaSet) VideoPath() string { return fmt.Sprintf("cache/%s.mp4", m.YoutubeID) }
func (m *MediaSet) ThumbnailPath() string { return fmt.Sprintf("cache/%s.jpg", m.YoutubeID) }
func (m *MediaSet) MetadataPath() string { return fmt.Sprintf("cache/%s.json", m.YoutubeID) }
func (m *MediaSet) Exists() bool {
if m.ID == "" {
if m.YoutubeID == "" {
return false
}
if m.exists {
@ -68,7 +73,7 @@ func (m *MediaSet) Exists() bool {
}
func (m *MediaSet) Load() error {
if m.ID == "" {
if m.YoutubeID == "" {
return errors.New("error opening mediaset with blank ID")
}

349
backend/media/service.go
View File

@ -2,28 +2,345 @@ package media
import (
"context"
"database/sql"
"errors"
"fmt"
"io"
"log"
"strconv"
"time"
"git.netflux.io/rob/clipper/generated/store"
"github.com/aws/aws-sdk-go-v2/service/s3"
"github.com/google/uuid"
youtubev2 "github.com/kkdai/youtube/v2"
)
type MediaSetService struct{}
const s3Bucket = "clipper-development"
func (s *MediaSetService) GetMediaSet(ctx context.Context, source string, id string) (*MediaSet, error) {
log.Printf("GetMediaSet called with source %q, id %q", source, id)
const (
rawAudioCodec = "pcm_s16le"
rawAudioFormat = "s16le"
rawAudioSampleRate = 48_000
)
if source != "youtube" {
return nil, errors.New("unknown source")
}
const (
thumbnailWidth = 177 // 16:9
thumbnailHeight = 100 // "
)
// try to load and return a cached MediaSet, if possible:
mediaSet := NewMediaSet(id)
if mediaSet.Exists() {
if err := mediaSet.Load(); err != nil {
return nil, fmt.Errorf("error loading MediaSet: %v", err)
}
return mediaSet, nil
}
return &MediaSet{ID: id}, nil
// progressReader is a reader that prints progress logs as it reads.
type progressReader struct {
io.Reader
label string
total, exp int
}
func (pw *progressReader) Read(p []byte) (int, error) {
n, err := pw.Reader.Read(p)
pw.total += n
log.Printf("[ProgressReader] [%s] Read %d of %d (%.02f%%) bytes from the provided reader", pw.label, pw.total, pw.exp, (float32(pw.total)/float32(pw.exp))*100.0)
return n, err
}
// Store wraps a database store.
type Store interface {
GetMediaSet(ctx context.Context, id uuid.UUID) (store.MediaSet, error)
GetMediaSetByYoutubeID(ctx context.Context, youtubeID string) (store.MediaSet, error)
CreateMediaSet(ctx context.Context, arg store.CreateMediaSetParams) (store.MediaSet, error)
}
// S3Client wraps the AWS S3 service client.
type S3Client interface {
CreateMultipartUpload(context.Context, *s3.CreateMultipartUploadInput, ...func(*s3.Options)) (*s3.CreateMultipartUploadOutput, error)
UploadPart(context.Context, *s3.UploadPartInput, ...func(*s3.Options)) (*s3.UploadPartOutput, error)
AbortMultipartUpload(ctx context.Context, params *s3.AbortMultipartUploadInput, optFns ...func(*s3.Options)) (*s3.AbortMultipartUploadOutput, error)
CompleteMultipartUpload(context.Context, *s3.CompleteMultipartUploadInput, ...func(*s3.Options)) (*s3.CompleteMultipartUploadOutput, error)
}
// YoutubeClient wraps the youtube.Client client.
type YoutubeClient interface {
GetVideoContext(context.Context, string) (*youtubev2.Video, error)
GetStreamContext(context.Context, *youtubev2.Video, *youtubev2.Format) (io.ReadCloser, int64, error)
}
// MediaSetService exposes logical flows handling MediaSets.
type MediaSetService struct {
store Store
youtube YoutubeClient
s3 S3Client
}
func NewMediaSetService(store Store, youtubeClient YoutubeClient, s3Client S3Client) *MediaSetService {
return &MediaSetService{
store: store,
youtube: youtubeClient,
s3: s3Client,
}
}
// Get fetches the metadata for a given MediaSet source.
func (s *MediaSetService) Get(ctx context.Context, youtubeID string) (*MediaSet, error) {
var (
mediaSet *MediaSet
err error
)
mediaSet, err = s.findMediaSet(ctx, youtubeID)
if err != nil {
return nil, fmt.Errorf("error getting existing media set: %v", err)
}
if mediaSet == nil {
mediaSet, err = s.createMediaSet(ctx, youtubeID)
if err != nil {
return nil, fmt.Errorf("error getting new media set: %v", err)
}
}
return mediaSet, nil
}
func (s *MediaSetService) createMediaSet(ctx context.Context, youtubeID string) (*MediaSet, error) {
video, err := s.youtube.GetVideoContext(ctx, youtubeID)
if err != nil {
return nil, fmt.Errorf("error fetching video: %v", err)
}
if len(video.Formats) == 0 {
return nil, errors.New("no format available")
}
audioMetadata, err := s.fetchAudioMetadata(ctx, video)
if err != nil {
return nil, fmt.Errorf("error fetching audio metadata: %v", err)
}
videoMetadata, err := s.fetchVideoMetadata(ctx, video)
if err != nil {
return nil, fmt.Errorf("error fetching video metadata: %v", err)
}
params := store.CreateMediaSetParams{
YoutubeID: youtubeID,
AudioYoutubeItag: int32(audioMetadata.YoutubeItag),
AudioChannels: int32(audioMetadata.Channels),
AudioFramesApprox: audioMetadata.ApproxFrames,
AudioSampleRateRaw: int32(audioMetadata.SampleRate),
AudioMimeTypeEncoded: audioMetadata.MimeType,
VideoYoutubeItag: int32(videoMetadata.YoutubeItag),
VideoMimeType: videoMetadata.MimeType,
VideoDurationNanos: videoMetadata.Duration.Nanoseconds(),
}
mediaSet, err := s.store.CreateMediaSet(ctx, params)
if err != nil {
return nil, fmt.Errorf("error creating media set in store: %v", err)
}
return &MediaSet{
ID: mediaSet.ID.String(),
YoutubeID: youtubeID,
Audio: audioMetadata,
Video: videoMetadata,
}, nil
}
// findMediaSet fetches a record from the database, returning (nil, nil) if it does not exist.
func (s *MediaSetService) findMediaSet(ctx context.Context, youtubeID string) (*MediaSet, error) {
mediaSet, err := s.store.GetMediaSetByYoutubeID(ctx, youtubeID)
if err != nil {
if err == sql.ErrNoRows {
return nil, nil
}
return nil, fmt.Errorf("error getting existing media set: %v", err)
}
var frames int64
if mediaSet.AudioFramesRaw.Valid {
frames = mediaSet.AudioFramesRaw.Int64
}
return &MediaSet{
Audio: Audio{
YoutubeItag: int(mediaSet.AudioYoutubeItag),
Bytes: 0, // DEPRECATED
Channels: int(mediaSet.AudioChannels),
ApproxFrames: int64(mediaSet.AudioFramesApprox),
Frames: frames,
SampleRate: int(mediaSet.AudioSampleRateRaw),
},
Video: Video{
YoutubeItag: int(mediaSet.VideoYoutubeItag),
Bytes: 0, // DEPRECATED?
Duration: time.Duration(mediaSet.VideoDurationNanos),
ThumbnailWidth: 0, // ??
ThumbnailHeight: 0, // ??
},
YoutubeID: mediaSet.YoutubeID,
}, nil
}
func (s *MediaSetService) fetchVideoMetadata(ctx context.Context, video *youtubev2.Video) (Video, error) {
formats := FilterYoutubeVideo(video.Formats)
if len(video.Formats) == 0 {
return Video{}, errors.New("no format available")
}
format := formats[0]
durationMsecs, err := strconv.Atoi(format.ApproxDurationMs)
if err != nil {
return Video{}, fmt.Errorf("could not parse video duration: %s", err)
}
return Video{
YoutubeItag: format.ItagNo,
MimeType: format.MimeType,
Bytes: format.ContentLength,
ThumbnailWidth: thumbnailWidth,
ThumbnailHeight: thumbnailHeight,
Duration: time.Duration(durationMsecs) * time.Millisecond,
}, nil
}
func (s *MediaSetService) fetchAudioMetadata(ctx context.Context, video *youtubev2.Video) (Audio, error) {
formats := FilterYoutubeAudio(video.Formats)
if len(video.Formats) == 0 {
return Audio{}, errors.New("no format available")
}
format := formats[0]
sampleRate, err := strconv.Atoi(format.AudioSampleRate)
if err != nil {
return Audio{}, fmt.Errorf("invalid samplerate: %s", format.AudioSampleRate)
}
approxDurationMsecs, err := strconv.Atoi(format.ApproxDurationMs)
if err != nil {
return Audio{}, fmt.Errorf("could not parse audio duration: %s", err)
}
approxDuration := time.Duration(approxDurationMsecs) * time.Millisecond
approxFrames := int64(approxDuration/time.Second) * int64(sampleRate)
return Audio{
MimeType: format.MimeType,
YoutubeItag: format.ItagNo,
ApproxFrames: approxFrames,
Channels: format.AudioChannels,
SampleRate: sampleRate,
}, nil
}
// GetAudio fetches the audio part of a MediaSet.
func (s *MediaSetService) GetAudio(ctx context.Context, id uuid.UUID, numBins int) (GetAudioProgressReader, error) {
mediaSet, err := s.store.GetMediaSet(ctx, id)
if err != nil {
return nil, fmt.Errorf("error getting media set: %v", err)
}
video, err := s.youtube.GetVideoContext(ctx, mediaSet.YoutubeID)
if err != nil {
return nil, fmt.Errorf("error fetching video: %v", err)
}
format := video.Formats.FindByItag(int(mediaSet.AudioYoutubeItag))
if format == nil {
return nil, fmt.Errorf("error finding itag: %v", err)
}
stream, _, err := s.youtube.GetStreamContext(ctx, video, format)
if err != nil {
return nil, fmt.Errorf("error fetching stream: %v", err)
}
// wrap it in a progress reader
progressStream := &progressReader{Reader: stream, label: "audio", exp: int(format.ContentLength)}
ffmpegReader, err := newFfmpegReader(ctx, progressStream, "-i", "-", "-f", rawAudioFormat, "-ar", strconv.Itoa(rawAudioSampleRate), "-acodec", rawAudioCodec, "-")
if err != nil {
return nil, fmt.Errorf("error creating ffmpegreader: %v", err)
}
// set up uploader, this is writer 1
uploader, err := newMultipartUploadWriter(
ctx,
s.s3,
s3Bucket,
fmt.Sprintf("media_sets/%s/audio.webm", id),
"application/octet-stream",
)
if err != nil {
return nil, fmt.Errorf("error creating uploader: %v", err)
}
fetchAudioProgressReader := newGetAudioProgressReader(
int64(mediaSet.AudioFramesApprox),
format.AudioChannels,
100,
)
state := fetchAudioState{
fetchAudioProgressReader: fetchAudioProgressReader,
ffmpegReader: ffmpegReader,
uploader: uploader,
}
go state.run(ctx)
return &state, nil
}
type fetchAudioState struct {
*fetchAudioProgressReader
ffmpegReader io.ReadCloser
uploader *multipartUploadWriter
}
func (s *fetchAudioState) run(ctx context.Context) {
mw := io.MultiWriter(s, s.uploader)
done := make(chan error)
var err error
go func() {
_, copyErr := io.Copy(mw, s.ffmpegReader)
done <- copyErr
}()
outer:
for {
select {
case <-ctx.Done():
err = ctx.Err()
break outer
case err = <-done:
break outer
}
}
if readerErr := s.ffmpegReader.Close(); readerErr != nil {
if err == nil {
err = readerErr
}
}
if err == nil {
if uploaderErr := s.uploader.Complete(); uploaderErr != nil {
err = uploaderErr
}
}
if err != nil {
newCtx, cancel := context.WithTimeout(context.Background(), time.Second*5)
defer cancel()
if abortUploadErr := s.uploader.Abort(newCtx); abortUploadErr != nil {
log.Printf("error aborting uploader: %v", abortUploadErr)
}
s.Abort(err)
return
}
if iterErr := s.Close(); iterErr != nil {
log.Printf("error closing peak iterator: %v", iterErr)
}
}

148
backend/server/handlers.go
View File

@ -1,95 +1,83 @@
package server
import (
"encoding/json"
"log"
"net/http"
"strconv"
// // getMediaSet is a handler that responds with a MediaSet.
// func getMediaSet(c echo.Context) error {
// videoID := c.Param("id")
// mediaSet := media.NewMediaSet(videoID)
"git.netflux.io/rob/clipper/media"
"git.netflux.io/rob/clipper/youtube"
youtubev2 "github.com/kkdai/youtube/v2"
"github.com/labstack/echo/v4"
)
// if mediaSet.Exists() {
// if err := mediaSet.Load(); err != nil {
// log.Printf("error loading MediaSet: %v", err)
// return echo.NewHTTPError(http.StatusInternalServerError, "could not fetch media set")
// }
// return c.JSON(http.StatusOK, mediaSet)
// }
// getMediaSet is a handler that responds with a MediaSet.
func getMediaSet(c echo.Context) error {
videoID := c.Param("id")
mediaSet := media.NewMediaSet(videoID)
// var youtubeClient youtubev2.Client
// downloader := youtube.NewDownloader(&youtubeClient)
// mediaSet, err := downloader.Download(c.Request().Context(), videoID)
// if err != nil {
// log.Printf("error downloading MediaSet: %v", err)
// return echo.NewHTTPError(http.StatusInternalServerError, "could not fetch media set")
// }
// return c.JSON(http.StatusOK, mediaSet)
// }
if mediaSet.Exists() {
if err := mediaSet.Load(); err != nil {
log.Printf("error loading MediaSet: %v", err)
return echo.NewHTTPError(http.StatusInternalServerError, "could not fetch media set")
}
return c.JSON(http.StatusOK, mediaSet)
}
// // getThumbnails is a handler that responds with a MediaSet thumbnail grid.
// func getThumbnails(c echo.Context) error {
// videoID := c.Param("id")
// mediaSet := media.NewMediaSet(videoID)
// if err := mediaSet.Load(); err != nil {
// log.Printf("error loading MediaSet: %v", err)
// return echo.NewHTTPError(http.StatusInternalServerError, "could not load media set")
// }
var youtubeClient youtubev2.Client
downloader := youtube.NewDownloader(&youtubeClient)
mediaSet, err := downloader.Download(c.Request().Context(), videoID)
if err != nil {
log.Printf("error downloading MediaSet: %v", err)
return echo.NewHTTPError(http.StatusInternalServerError, "could not fetch media set")
}
return c.JSON(http.StatusOK, mediaSet)
}
// return c.File(mediaSet.ThumbnailPath())
// }
// getThumbnails is a handler that responds with a MediaSet thumbnail grid.
func getThumbnails(c echo.Context) error {
videoID := c.Param("id")
mediaSet := media.NewMediaSet(videoID)
if err := mediaSet.Load(); err != nil {
log.Printf("error loading MediaSet: %v", err)
return echo.NewHTTPError(http.StatusInternalServerError, "could not load media set")
}
// // getVideo is a handler that responds with the video file for a MediaSet
// func getVideo(c echo.Context) error {
// videoID := c.Param("id")
// mediaSet := media.NewMediaSet(videoID)
// if err := mediaSet.Load(); err != nil {
// log.Printf("error loading MediaSet: %v", err)
// return echo.NewHTTPError(http.StatusInternalServerError, "could not load media set")
// }
return c.File(mediaSet.ThumbnailPath())
}
// return c.File(mediaSet.VideoPath())
// }
// getVideo is a handler that responds with the video file for a MediaSet
func getVideo(c echo.Context) error {
videoID := c.Param("id")
mediaSet := media.NewMediaSet(videoID)
if err := mediaSet.Load(); err != nil {
log.Printf("error loading MediaSet: %v", err)
return echo.NewHTTPError(http.StatusInternalServerError, "could not load media set")
}
// // getPeaks is a handler that returns a two-dimensional array of peaks, with
// // the number of bins matching the provided parameter.
// func getPeaks(c echo.Context) error {
// videoID := c.Param("id")
return c.File(mediaSet.VideoPath())
}
// start, err := strconv.ParseInt(c.QueryParam("start"), 0, 64)
// if err != nil {
// return echo.NewHTTPError(http.StatusBadRequest, "invalid start parameter provided")
// }
// getPeaks is a handler that returns a two-dimensional array of peaks, with
// the number of bins matching the provided parameter.
func getPeaks(c echo.Context) error {
videoID := c.Param("id")
// end, err := strconv.ParseInt(c.QueryParam("end"), 0, 64)
// if err != nil {
// return echo.NewHTTPError(http.StatusBadRequest, "invalid end parameter provided")
// }
start, err := strconv.ParseInt(c.QueryParam("start"), 0, 64)
if err != nil {
return echo.NewHTTPError(http.StatusBadRequest, "invalid start parameter provided")
}
// numBins, err := strconv.Atoi(c.QueryParam("bins"))
// if err != nil {
// return echo.NewHTTPError(http.StatusBadRequest, "invalid bins parameter provided")
// }
end, err := strconv.ParseInt(c.QueryParam("end"), 0, 64)
if err != nil {
return echo.NewHTTPError(http.StatusBadRequest, "invalid end parameter provided")
}
// mediaSet := media.NewMediaSet(videoID)
// if err = mediaSet.Load(); err != nil {
// log.Printf("error loading MediaSet: %v", err)
// return echo.NewHTTPError(http.StatusInternalServerError, "could not load media set")
// }
numBins, err := strconv.Atoi(c.QueryParam("bins"))
if err != nil {
return echo.NewHTTPError(http.StatusBadRequest, "invalid bins parameter provided")
}
// peaks, err := mediaSet.Peaks(start, end, numBins)
// if err != nil {
// log.Printf("error generating peaks: %v", err)
// return echo.NewHTTPError(http.StatusInternalServerError, "could not generate peaks")
// }
mediaSet := media.NewMediaSet(videoID)
if err = mediaSet.Load(); err != nil {
log.Printf("error loading MediaSet: %v", err)
return echo.NewHTTPError(http.StatusInternalServerError, "could not load media set")
}
peaks, err := mediaSet.Peaks(start, end, numBins)
if err != nil {
log.Printf("error generating peaks: %v", err)
return echo.NewHTTPError(http.StatusInternalServerError, "could not generate peaks")
}
return json.NewEncoder(c.Response()).Encode(peaks)
}
// return json.NewEncoder(c.Response()).Encode(peaks)
// }

65
backend/server/server.go
View File

@ -2,6 +2,7 @@ package server
import (
"context"
"fmt"
"io"
"log"
"net/http"
@ -11,39 +12,60 @@ import (
pbMediaSet "git.netflux.io/rob/clipper/generated/pb/media_set"
"git.netflux.io/rob/clipper/media"
"git.netflux.io/rob/clipper/youtube"
"github.com/google/uuid"
"github.com/improbable-eng/grpc-web/go/grpcweb"
"google.golang.org/grpc"
"google.golang.org/grpc/codes"
"google.golang.org/grpc/grpclog"
"google.golang.org/protobuf/types/known/durationpb"
)
type ResponseError struct {
error
ResponseCode codes.Code
}
func (r *ResponseError) Error() string {
return fmt.Sprintf("An unexpected error occurred: %v (error code = %d).", r.error.Error(), r.ResponseCode)
}
func (r *ResponseError) Unwrap() error {
return r.error
}
func newResponseError(err error, code codes.Code) *ResponseError {
return &ResponseError{error: err, ResponseCode: code}
}
type Options struct {
BindAddr string
Timeout time.Duration
Store media.Store
YoutubeClient youtube.YoutubeClient
S3Client media.S3Client
}
const (
fetchAudioTimeout = time.Minute * 5
getAudioTimeout = time.Minute * 5
)
// fetchMediaSetServiceController implements gRPC controller for FetchMediaSetService
type fetchMediaSetServiceController struct {
pbMediaSet.UnimplementedFetchServiceServer
// mediaSetServiceController implements gRPC controller for MediaSetService
type mediaSetServiceController struct {
pbMediaSet.UnimplementedMediaSetServiceServer
fetchMediaSetService *media.FetchMediaSetService
mediaSetService *media.MediaSetService
}
// Fetch fetches a pbMediaSet.MediaSet
func (c *fetchMediaSetServiceController) Fetch(ctx context.Context, request *pbMediaSet.FetchRequest) (*pbMediaSet.MediaSet, error) {
mediaSet, err := c.fetchMediaSetService.Fetch(ctx, request.GetId())
// Get returns a pbMediaSet.MediaSet
func (c *mediaSetServiceController) Get(ctx context.Context, request *pbMediaSet.GetRequest) (*pbMediaSet.MediaSet, error) {
mediaSet, err := c.mediaSetService.Get(ctx, request.GetYoutubeId())
if err != nil {
return nil, err
return nil, newResponseError(err, codes.Unknown)
}
result := pbMediaSet.MediaSet{
Id: mediaSet.ID,
Id: mediaSet.YoutubeID,
Audio: &pbMediaSet.MediaSet_Audio{
Bytes: mediaSet.Audio.Bytes,
Channels: int32(mediaSet.Audio.Channels),
@ -61,14 +83,19 @@ func (c *fetchMediaSetServiceController) Fetch(ctx context.Context, request *pbM
return &result, nil
}
// TODO: wrap errors
func (c *fetchMediaSetServiceController) FetchAudio(request *pbMediaSet.FetchAudioRequest, stream pbMediaSet.FetchService_FetchAudioServer) error {
ctx, cancel := context.WithTimeout(context.Background(), fetchAudioTimeout)
// GetAudio streams the progress report of GetAudio.
func (c *mediaSetServiceController) GetAudio(request *pbMediaSet.GetAudioRequest, stream pbMediaSet.MediaSetService_GetAudioServer) error {
ctx, cancel := context.WithTimeout(context.Background(), getAudioTimeout)
defer cancel()
reader, err := c.fetchMediaSetService.FetchAudio(ctx, request.GetId(), int(request.GetNumBins()))
id, err := uuid.Parse(request.GetId())
if err != nil {
return err
return newResponseError(err, codes.Unknown)
}
reader, err := c.mediaSetService.GetAudio(ctx, id, int(request.GetNumBins()))
if err != nil {
return newResponseError(err, codes.Unknown)
}
for {
@ -77,7 +104,7 @@ func (c *fetchMediaSetServiceController) FetchAudio(request *pbMediaSet.FetchAud
if err == io.EOF {
break
}
return err
return newResponseError(err, codes.Unknown)
}
// TODO: consider using int32 throughout the backend flow to avoid this.
@ -86,7 +113,7 @@ func (c *fetchMediaSetServiceController) FetchAudio(request *pbMediaSet.FetchAud
peaks[i] = int32(p)
}
progressPb := pbMediaSet.FetchAudioProgress{
progressPb := pbMediaSet.GetAudioProgress{
PercentCompleted: progress.PercentComplete,
Peaks: peaks,
}
@ -100,9 +127,9 @@ func (c *fetchMediaSetServiceController) FetchAudio(request *pbMediaSet.FetchAud
func Start(options Options) error {
grpcServer := grpc.NewServer()
fetchMediaSetService := media.NewFetchMediaSetService(options.YoutubeClient, options.S3Client)
fetchMediaSetService := media.NewMediaSetService(options.Store, options.YoutubeClient, options.S3Client)
pbMediaSet.RegisterFetchServiceServer(grpcServer, &fetchMediaSetServiceController{fetchMediaSetService: fetchMediaSetService})
pbMediaSet.RegisterMediaSetServiceServer(grpcServer, &mediaSetServiceController{mediaSetService: fetchMediaSetService})
grpclog.SetLogger(log.New(os.Stdout, "server: ", log.LstdFlags))
// TODO: proper CORS support

3
backend/sql/migrations/1635710597_create_media_sets_table.down.sql Normal file
View File

@ -0,0 +1,3 @@
DROP TABLE media_sets;
DROP EXTENSION pgcrypto;

39
backend/sql/migrations/1635710597_create_media_sets_table.up.sql Normal file
View File

@ -0,0 +1,39 @@
CREATE EXTENSION pgcrypto;
CREATE TABLE media_sets (
id uuid PRIMARY KEY DEFAULT gen_random_uuid(),
youtube_id CHARACTER VARYING(32) NOT NULL,
audio_youtube_itag int NOT NULL,
audio_channels int NOT NULL,
audio_frames_approx bigint NOT NULL,
audio_frames bigint,
audio_sample_rate int NOT NULL,
audio_s3_bucket CHARACTER VARYING(256),
audio_s3_key CHARACTER VARYING(256),
audio_s3_uploaded_at TIMESTAMP WITH TIME ZONE,
audio_mime_type_encoded CHARACTER VARYING(256) NOT NULL,
video_youtube_itag int NOT NULL,
video_s3_bucket CHARACTER VARYING(256),
video_s3_key CHARACTER VARYING(256),
video_s3_uploaded_at TIMESTAMP WITH TIME ZONE,
video_mime_type CHARACTER VARYING(256) NOT NULL,
video_duration_nanos bigint NOT NULL,
video_thumbnail_s3_bucket CHARACTER VARYING(256),
video_thumbnail_s3_key CHARACTER VARYING(256),
video_thumbnail_s3_uploaded_at TIMESTAMP WITH TIME ZONE,
video_thumbnail_mime_type CHARACTER VARYING(256),
video_thumbnail_width int DEFAULT 0,
video_thumbnail_height int DEFAULT 0,
created_at TIMESTAMP WITH TIME ZONE NOT NULL,
updated_at TIMESTAMP WITH TIME ZONE NOT NULL
);
CREATE UNIQUE INDEX index_media_sets_on_youtube_id ON media_sets (youtube_id);
ALTER TABLE media_sets ADD CONSTRAINT check_audio_youtube_itag_gt_0 CHECK (audio_youtube_itag > 0);
ALTER TABLE media_sets ADD CONSTRAINT check_audio_frames_gt_0 CHECK (audio_frames > 0);
ALTER TABLE media_sets ADD CONSTRAINT check_audio_frames_approx_gt_0 CHECK (audio_frames_approx > 0);
ALTER TABLE media_sets ADD CONSTRAINT check_audio_channels_gt_0 CHECK (audio_channels > 0);
ALTER TABLE media_sets ADD CONSTRAINT check_audio_sample_rate_gt_0 CHECK (audio_sample_rate > 0);
ALTER TABLE media_sets ADD CONSTRAINT check_video_youtube_itag_gt_0 CHECK (video_youtube_itag > 0);
ALTER TABLE media_sets ADD CONSTRAINT check_video_duration_nanos_gt_0 CHECK (video_duration_nanos > 0);

10
backend/sql/queries.sql Normal file
View File

@ -0,0 +1,10 @@
-- name: GetMediaSet :one
SELECT * FROM media_sets WHERE id = $1;
-- name: GetMediaSetByYoutubeID :one
SELECT * FROM media_sets WHERE youtube_id = $1;
-- name: CreateMediaSet :one
INSERT INTO media_sets (youtube_id, audio_youtube_itag, audio_channels, audio_frames_approx, audio_sample_rate_raw, audio_mime_type_encoded, video_youtube_itag, video_mime_type, video_duration_nanos, created_at, updated_at)
VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, NOW(), NOW())
RETURNING *;

6
backend/sqlc.yaml Normal file
View File

@ -0,0 +1,6 @@
version: 1
packages:
- path: "generated/store"
engine: "postgresql"
schema: "sql/migrations"
queries: "sql/queries.sql"

2
backend/youtube/youtube2.go
View File

@ -53,7 +53,7 @@ func (s *MediaSetService) GetMediaSet(ctx context.Context, id string) (*media.Me
}
return &media.MediaSet{
ID: "",
YoutubeID: "",
Audio: media.Audio{
Bytes: audioFormat.ContentLength,
Channels: audioFormat.AudioChannels,

28
frontend/src/App.tsx
View File

@ -1,12 +1,12 @@
import { grpc } from '@improbable-eng/grpc-web';
import {
MediaSet as MediaSetPb,
FetchRequest,
FetchAudioRequest,
FetchAudioProgress,
GetRequest,
GetAudioRequest,
GetAudioProgress,
} from './generated/media_set_pb';
import { FetchMediaSet, FetchMediaSetAudio } from './GrpcWrapper';
import { GetMediaSet } from './GrpcWrapper';
import { useState, useEffect } from 'react';
import { VideoPreview } from './VideoPreview';
@ -65,20 +65,20 @@ function App(): JSX.Element {
// fetch mediaset on page load:
useEffect(() => {
(async function () {
const request = new FetchRequest();
request.setId(videoID);
const request = new GetRequest();
request.setYoutubeId(videoID);
const mediaSet = await FetchMediaSet(grpcHost, request);
const mediaSet = await GetMediaSet(grpcHost, request);
console.log('got media set:', mediaSet);
const handleProgress = (progress: FetchAudioProgress) => {
console.log('got progress', progress);
};
// const handleProgress = (progress: GetAudioProgress) => {
// console.log('got progress', progress);
// };
const audioRequest = new FetchAudioRequest();
audioRequest.setId(videoID);
audioRequest.setNumBins(1000);
FetchMediaSetAudio(grpcHost, audioRequest, handleProgress);
// const audioRequest = new GetAudioRequest();
// audioRequest.setId(videoID);
// audioRequest.setNumBins(1000);
// GetMediaSetAudio(grpcHost, audioRequest, handleProgress);
// console.log('fetching media...');
// const resp = await fetch(

50
frontend/src/GrpcWrapper.tsx
View File

@ -1,20 +1,20 @@
import { grpc } from '@improbable-eng/grpc-web';
import { FetchService } from './generated/media_set_pb_service';
import { MediaSetService } from './generated/media_set_pb_service';
import {
MediaSet,
FetchRequest,
FetchAudioProgress,
FetchAudioRequest,
GetRequest,
GetAudioProgress,
GetAudioRequest,
} from './generated/media_set_pb';
export const FetchMediaSet = (
export const GetMediaSet = (
host: string,
request: FetchRequest
request: GetRequest
): Promise<MediaSet> => {
return new Promise<MediaSet>((resolve, reject) => {
let result: MediaSet;
grpc.invoke(FetchService.Fetch, {
grpc.invoke(MediaSetService.Get, {
host: host,
request: request,
onMessage: (mediaSet: MediaSet) => {
@ -35,21 +35,21 @@ export const FetchMediaSet = (
});
};
export const FetchMediaSetAudio = (
host: string,
request: FetchAudioRequest,
onProgress: { (progress: FetchAudioProgress): void }
) => {
grpc.invoke(FetchService.FetchAudio, {
host: 'http://localhost:8888',
request: request,
onMessage: onProgress,
onEnd: (
code: grpc.Code,
msg: string | undefined,
trailers: grpc.Metadata
) => {
console.log('fetch audio request ended');
},
});
};
// export const etchMediaSetAudio = (
// host: string,
// request: FetchAudioRequest,
// onProgress: { (progress: FetchAudioProgress): void }
// ) => {
// grpc.invoke(FetchService.FetchAudio, {
// host: 'http://localhost:8888',
// request: request,
// onMessage: onProgress,
// onEnd: (
// code: grpc.Code,
// msg: string | undefined,
// trailers: grpc.Metadata
// ) => {
// console.log('fetch audio request ended');
// },
// });
// };

14
proto/media_set.proto
View File

@ -27,21 +27,21 @@ message MediaSet {
bool loaded = 4;
};
message FetchAudioProgress {
message GetAudioProgress {
float percent_completed = 2;
repeated int32 peaks = 1;
}
message FetchRequest {
string id = 1;
message GetRequest {
string youtube_id = 1;
}
message FetchAudioRequest {
message GetAudioRequest {
string id = 1;
int32 num_bins = 2;
}
service FetchService {
rpc Fetch(FetchRequest) returns (MediaSet) {}
rpc FetchAudio(FetchAudioRequest) returns (stream FetchAudioProgress) {}
service MediaSetService {
rpc Get(GetRequest) returns (MediaSet) {}
rpc GetAudio(GetAudioRequest) returns (stream GetAudioProgress) {}
}