140 lines
3.0 KiB
Go
140 lines
3.0 KiB
Go
package main
|
|
|
|
import (
|
|
"fmt"
|
|
"io"
|
|
"log"
|
|
"net/http"
|
|
"os"
|
|
"strings"
|
|
"time"
|
|
|
|
"github.com/kkdai/youtube/v2"
|
|
)
|
|
|
|
const (
|
|
ContentTypeAudioM4A = "audio/m4a"
|
|
ItagM4AAudio = 140
|
|
DefaultHTTPBindAddr = "0.0.0.0:8888"
|
|
DefaultTimeout = 5 * time.Second
|
|
)
|
|
|
|
type AudioDownloader struct {
|
|
videoID string
|
|
ytClient youtube.Client
|
|
reader io.Reader
|
|
}
|
|
|
|
func NewAudioDownloader(videoID string) (*AudioDownloader, error) {
|
|
var (
|
|
reader io.Reader
|
|
ytClient youtube.Client
|
|
)
|
|
|
|
cachePath := fmt.Sprintf("cache/%s.m4a", videoID)
|
|
fetch := true
|
|
|
|
if _, err := os.Stat(cachePath); err == nil {
|
|
if fptr, err := os.Open(cachePath); err == nil {
|
|
reader = fptr
|
|
fetch = false
|
|
} else {
|
|
log.Printf("warning: error opening cache file: %v", err)
|
|
}
|
|
}
|
|
|
|
if fetch {
|
|
log.Println("fetching audio stream from youtube...")
|
|
|
|
video, err := ytClient.GetVideo(videoID)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("error fetching video: %v", err)
|
|
}
|
|
|
|
format := video.Formats.FindByItag(ItagM4AAudio)
|
|
log.Printf("M4A format expected to contain %d bytes", format.ContentLength)
|
|
stream, _, err := ytClient.GetStream(video, format)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("error fetching stream: %v", err)
|
|
}
|
|
|
|
// TODO: only allow the cached file to be accessed after it has been
|
|
// successfully downloaded.
|
|
cacheFile, err := os.Create(cachePath)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("error creating cache file: %v", err)
|
|
}
|
|
reader = io.TeeReader(stream, cacheFile)
|
|
}
|
|
|
|
return &AudioDownloader{
|
|
videoID: videoID,
|
|
ytClient: ytClient,
|
|
reader: reader,
|
|
}, nil
|
|
}
|
|
|
|
func (d *AudioDownloader) Read(p []byte) (int, error) {
|
|
return d.reader.Read(p)
|
|
}
|
|
|
|
func (d *AudioDownloader) Close() error {
|
|
if rc, ok := d.reader.(io.ReadCloser); ok {
|
|
return rc.Close()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func handleRequest(w http.ResponseWriter, r *http.Request) {
|
|
if r.Method != http.MethodGet {
|
|
w.WriteHeader(http.StatusMethodNotAllowed)
|
|
w.Write([]byte("method not allowed"))
|
|
return
|
|
}
|
|
|
|
if !strings.HasPrefix(r.URL.Path, "/api/audio") {
|
|
w.WriteHeader(http.StatusNotFound)
|
|
w.Write([]byte("page not found"))
|
|
return
|
|
}
|
|
|
|
videoID := r.URL.Query().Get("video_id")
|
|
if videoID == "" {
|
|
w.WriteHeader(http.StatusBadRequest)
|
|
w.Write([]byte("no video ID provided"))
|
|
return
|
|
}
|
|
|
|
downloader, err := NewAudioDownloader(videoID)
|
|
if err != nil {
|
|
log.Printf("downloader error: %v", err)
|
|
w.WriteHeader(http.StatusInternalServerError)
|
|
w.Write([]byte("could not download video"))
|
|
return
|
|
}
|
|
defer downloader.Close()
|
|
|
|
w.Header().Add("Content-Type", ContentTypeAudioM4A)
|
|
w.Header().Add("Access-Control-Allow-Origin", "*")
|
|
w.WriteHeader(http.StatusOK)
|
|
|
|
n, err := io.Copy(w, downloader)
|
|
if err != nil {
|
|
log.Printf("error writing response: %v", err)
|
|
return
|
|
}
|
|
|
|
log.Printf("wrote %d bytes for video ID %s", n, videoID)
|
|
}
|
|
|
|
func main() {
|
|
srv := http.Server{
|
|
ReadTimeout: DefaultTimeout,
|
|
WriteTimeout: DefaultTimeout,
|
|
Addr: DefaultHTTPBindAddr,
|
|
Handler: http.HandlerFunc(handleRequest),
|
|
}
|
|
|
|
log.Fatal(srv.ListenAndServe())
|
|
}
|