package media import ( "encoding/binary" "encoding/json" "errors" "fmt" "io" "log" "os" "time" "github.com/google/uuid" ) const SizeOfInt16 = 2 type Audio struct { Bytes int64 `json:"bytes"` Channels int `json:"channels"` // ApproxFrames is used during initial processing when a precise frame count // cannot be determined. Prefer Frames in all other cases. 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 { Bytes int64 `json:"bytes"` Duration time.Duration `json:"duration"` // 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 // resource (for example, a YouTube video). type MediaSet struct { Audio Audio `json:"audio"` Video Video `json:"video"` ID uuid.UUID `json:"id"` YoutubeID string `json:"youtube_id"` exists bool `json:"exists"` } // New builds a new MediaSet with the given 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.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.YoutubeID == "" { return false } if m.exists { return true } if _, err := os.Stat(m.MetadataPath()); err == nil { m.exists = true return true } return false } func (m *MediaSet) Load() error { if m.YoutubeID == "" { return errors.New("error opening mediaset with blank ID") } metadataFile, err := os.Open(m.MetadataPath()) if err != nil { return fmt.Errorf("error opening metadata file: %v", err) } defer func() { _ = metadataFile.Close() }() if err := json.NewDecoder(metadataFile).Decode(m); err != nil { return fmt.Errorf("error decoding metadata: %v", err) } return nil } func (m *MediaSet) Peaks(start, end int64, numBins int) ([][]int16, error) { if !m.Exists() { return nil, errors.New("cannot compute peaks for non-existent MediaSet") } var err error fptr, err := os.Open(m.RawAudioPath()) if err != nil { return nil, fmt.Errorf("audio open error: %v", err) } defer fptr.Close() startByte := start * int64(m.Audio.Channels) * SizeOfInt16 if _, err = fptr.Seek(startByte, io.SeekStart); err != nil { return nil, fmt.Errorf("audio seek error: %v", err) } numFrames := end - start framesPerBin := numFrames / int64(numBins) peaks := make([][]int16, m.Audio.Channels) for i := 0; i < m.Audio.Channels; i++ { peaks[i] = make([]int16, numBins) } samples := make([]int16, framesPerBin*int64(m.Audio.Channels)) for binNum := 0; binNum < numBins; binNum++ { if err := binary.Read(fptr, binary.LittleEndian, samples); err != nil { return nil, fmt.Errorf("error reading samples: %v", err) } for i, samp := range samples { if samp < 0 { samp = -samp } chanIndex := i % m.Audio.Channels if samp > peaks[chanIndex][binNum] { peaks[chanIndex][binNum] = samp } } } log.Println("finished generating peaks") return peaks, nil }