524 lines
18 KiB
Go
524 lines
18 KiB
Go
package app
|
|
|
|
import (
|
|
"context"
|
|
"encoding/json"
|
|
"errors"
|
|
"io"
|
|
"math"
|
|
"mime"
|
|
"net/http"
|
|
"net/url"
|
|
"strconv"
|
|
"strings"
|
|
"time"
|
|
)
|
|
|
|
const playbackIdleTimeout = 10 * time.Minute
|
|
const playbackSessionLimit = 4
|
|
const playbackMIME = `video/mp4; codecs="avc1.42C01F, mp4a.40.2"`
|
|
|
|
type playbackSession struct {
|
|
accountID string
|
|
dramaID string
|
|
id string
|
|
viewer *viewerRecords
|
|
tasks []Task
|
|
downloadIDs []string
|
|
prepared map[int]bool
|
|
expires time.Time
|
|
timer *time.Timer
|
|
cancel context.CancelFunc
|
|
run uint64
|
|
state string
|
|
error string
|
|
duration float64
|
|
currentIndex int
|
|
prefetchVersion uint64
|
|
prefetch *playbackPrefetch
|
|
native *playbackNative
|
|
media *playbackMediaSession
|
|
mediaReady chan struct{}
|
|
mediaError error
|
|
mediaWaiters int
|
|
quality int
|
|
streamVersion uint64
|
|
openedAt time.Time
|
|
historySequence uint64
|
|
historyRuns map[uint64]playbackHistoryRun
|
|
}
|
|
|
|
type playbackEpisode struct {
|
|
VIP bool `json:"vip,omitempty"`
|
|
Index int `json:"index"`
|
|
Episode string `json:"episode"`
|
|
Title string `json:"title"`
|
|
TaskID string `json:"taskId,omitempty"`
|
|
Danmaku bool `json:"danmaku,omitempty"`
|
|
ChapterID string `json:"chapterId,omitempty"`
|
|
Number int `json:"number"`
|
|
Total int `json:"total"`
|
|
}
|
|
|
|
type playbackView struct {
|
|
State string `json:"state"`
|
|
Error string `json:"error,omitempty"`
|
|
Run uint64 `json:"run"`
|
|
Duration float64 `json:"duration"`
|
|
Prefetch *playbackPrefetchView `json:"prefetch,omitempty"`
|
|
Plan *playbackMediaPlan `json:"plan,omitempty"`
|
|
MediaBytes int64 `json:"mediaBytes,omitempty"`
|
|
MediaFailure bool `json:"mediaFailure,omitempty"`
|
|
}
|
|
|
|
func (app *UIApp) registerPlaybackRoutes(mux *http.ServeMux) {
|
|
mux.HandleFunc("/api/ui/admin/playback", app.handlePlaybackSettings)
|
|
mux.HandleFunc("/api/ui/playback/plan", app.handlePlaybackPlan)
|
|
mux.HandleFunc("/api/ui/playback/media/", app.handlePlaybackMediaAsset)
|
|
mux.HandleFunc("/api/emby/media/", app.handleEmbyMediaAsset)
|
|
mux.HandleFunc("/api/ui/playback/open", app.handlePlaybackOpen)
|
|
mux.HandleFunc("/api/ui/playback/prepare", app.handlePlaybackPrepare)
|
|
mux.HandleFunc("/api/ui/playback/stream", app.handlePlaybackStream)
|
|
mux.HandleFunc("/api/ui/playback/hls/open", app.handlePlaybackNativeOpen)
|
|
mux.HandleFunc("/api/ui/playback/hls/index.m3u8", app.handlePlaybackNativeAsset)
|
|
mux.HandleFunc("/api/ui/playback/hls/segment.ts", app.handlePlaybackNativeAsset)
|
|
mux.HandleFunc("/api/ui/playback/control", app.handlePlaybackControl)
|
|
mux.HandleFunc("/api/ui/playback/status", app.handlePlaybackStatus)
|
|
mux.HandleFunc("/api/ui/playback/prefetch", app.handlePlaybackPrefetch)
|
|
mux.HandleFunc("/api/ui/playback/danmaku", app.handlePlaybackDanmaku)
|
|
mux.HandleFunc("/api/ui/playback/history", app.handlePlaybackHistory)
|
|
mux.HandleFunc("/api/ui/playback/history/remove", app.handlePlaybackHistoryRemove)
|
|
mux.HandleFunc("/api/ui/playback/progress", app.handlePlaybackProgress)
|
|
}
|
|
|
|
func playbackRequestAllowed(writer http.ResponseWriter, request *http.Request, method string) bool {
|
|
writer.Header().Set("Cache-Control", "private, no-store, no-transform")
|
|
writer.Header().Set("X-Accel-Buffering", "no")
|
|
writer.Header().Set("Cross-Origin-Resource-Policy", "same-origin")
|
|
writer.Header().Set("X-Content-Type-Options", "nosniff")
|
|
if request.Method != method {
|
|
writer.Header().Set("Allow", method)
|
|
writeJSON(writer, http.StatusMethodNotAllowed, map[string]string{"error": "请求方法不支持"})
|
|
return false
|
|
}
|
|
switch request.Header.Get("Sec-Fetch-Site") {
|
|
case "same-origin", "none":
|
|
return true
|
|
case "":
|
|
default:
|
|
writeJSON(writer, http.StatusForbidden, map[string]string{"error": "请从剧库页面发起播放"})
|
|
return false
|
|
}
|
|
if origin := request.Header.Get("Origin"); origin != "" {
|
|
parsed, err := url.Parse(origin)
|
|
if err != nil || parsed.User != nil || parsed.Scheme != "http" && parsed.Scheme != "https" || !originHostMatches(parsed, request.Host) {
|
|
writeJSON(writer, http.StatusForbidden, map[string]string{"error": "不允许跨站播放请求"})
|
|
return false
|
|
}
|
|
}
|
|
return true
|
|
}
|
|
|
|
func originHostMatches(origin *url.URL, host string) bool {
|
|
port := ":80"
|
|
if origin.Scheme == "https" {
|
|
port = ":443"
|
|
}
|
|
return strings.EqualFold(strings.TrimSuffix(origin.Host, port), strings.TrimSuffix(host, port))
|
|
}
|
|
|
|
func readPlaybackRequest(writer http.ResponseWriter, request *http.Request, destination any) bool {
|
|
if !playbackRequestAllowed(writer, request, http.MethodPost) {
|
|
return false
|
|
}
|
|
contentType, _, _ := mime.ParseMediaType(request.Header.Get("Content-Type"))
|
|
if contentType != "application/json" {
|
|
writeJSON(writer, http.StatusUnsupportedMediaType, map[string]string{"error": "请求必须使用 JSON"})
|
|
return false
|
|
}
|
|
decoder := json.NewDecoder(http.MaxBytesReader(writer, request.Body, 4096))
|
|
decoder.DisallowUnknownFields()
|
|
if err := decoder.Decode(destination); err != nil {
|
|
writeJSON(writer, http.StatusBadRequest, map[string]string{"error": "播放请求无效"})
|
|
return false
|
|
}
|
|
if err := decoder.Decode(new(any)); err != io.EOF {
|
|
writeJSON(writer, http.StatusBadRequest, map[string]string{"error": "播放请求包含多余数据"})
|
|
return false
|
|
}
|
|
return true
|
|
}
|
|
|
|
func (app *UIApp) handlePlaybackOpen(writer http.ResponseWriter, request *http.Request) {
|
|
var input struct {
|
|
DramaID string `json:"dramaId"`
|
|
TaskID string `json:"taskId"`
|
|
Resume bool `json:"resume"`
|
|
FromHistory bool `json:"fromHistory"`
|
|
}
|
|
if !readPlaybackRequest(writer, request, &input) {
|
|
return
|
|
}
|
|
if input.TaskID != "" && !requireDownload(writer, request) {
|
|
return
|
|
}
|
|
if input.TaskID != "" && input.DramaID != "" {
|
|
writeJSON(writer, http.StatusBadRequest, map[string]string{"error": "请选择剧库播放或合集播放"})
|
|
return
|
|
}
|
|
viewer := requestViewer(writer, request)
|
|
if viewer == nil {
|
|
return
|
|
}
|
|
if input.DramaID != "" && !app.requireDramaSources(writer, request, []string{input.DramaID}) {
|
|
return
|
|
}
|
|
openedAt := time.Now()
|
|
history := viewer.playbackHistory()
|
|
previous, hasPrevious := history.get(input.DramaID)
|
|
if input.FromHistory && (!input.Resume || !hasPrevious || input.TaskID != "") {
|
|
writeJSON(writer, http.StatusNotFound, map[string]string{"error": "此观看记录已移除，请从剧库重新选择"})
|
|
return
|
|
}
|
|
var drama Drama
|
|
var title string
|
|
var tasks []Task
|
|
var downloadIDs []string
|
|
initialIndex := 1
|
|
var collectionErr error
|
|
app.mu.Lock()
|
|
if input.FromHistory && previous.Mode == "collection" && downloadAllowed(request.Context()) {
|
|
candidate := app.tasks[previous.TaskID]
|
|
if isPlayableDownloadTask(candidate) && candidate.DramaID == previous.DramaID {
|
|
input.TaskID = candidate.ID
|
|
} else {
|
|
for _, taskID := range app.taskOrder {
|
|
candidate = app.tasks[taskID]
|
|
if isPlayableDownloadTask(candidate) && candidate.DramaID == previous.DramaID {
|
|
input.TaskID = candidate.ID
|
|
break
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if input.TaskID != "" {
|
|
if !app.requireTaskSourcesLocked(writer, request, taskSelection{IDs: []string{input.TaskID}}) {
|
|
app.mu.Unlock()
|
|
return
|
|
}
|
|
title, tasks, downloadIDs, initialIndex, collectionErr = app.collectionPlaybackTasksLocked(input.TaskID)
|
|
} else {
|
|
for _, candidate := range app.dramas {
|
|
if candidate.ID == input.DramaID && input.DramaID != "" {
|
|
drama = candidate
|
|
break
|
|
}
|
|
}
|
|
}
|
|
app.mu.Unlock()
|
|
if input.TaskID != "" && len(tasks) > 0 && input.Resume {
|
|
previous, hasPrevious = history.get(tasks[0].DramaID)
|
|
}
|
|
if input.TaskID == "" && drama.ID == "" && input.Resume && hasPrevious {
|
|
drama = Drama{ID: previous.DramaID, Source: previous.Source, Title: previous.Title}
|
|
}
|
|
if collectionErr != nil {
|
|
writeJSON(writer, http.StatusNotFound, map[string]string{"error": app.redactError(collectionErr)})
|
|
return
|
|
}
|
|
if input.TaskID == "" && drama.ID == "" {
|
|
writeJSON(writer, http.StatusNotFound, map[string]string{"error": "此短剧不在当前剧库中，请刷新剧库后重试"})
|
|
return
|
|
}
|
|
if drama.ID != "" && !dramaAllowed(request.Context(), drama.ID, drama.Source) {
|
|
writeSourceDenied(writer)
|
|
return
|
|
}
|
|
for _, task := range tasks {
|
|
if !taskSourceAllowed(request.Context(), task) {
|
|
writeSourceDenied(writer)
|
|
return
|
|
}
|
|
}
|
|
sessionDramaID := drama.ID
|
|
if len(tasks) > 0 {
|
|
sessionDramaID = tasks[0].DramaID
|
|
}
|
|
ctx, cancel := context.WithTimeout(request.Context(), 90*time.Second)
|
|
defer cancel()
|
|
id := randomHex(24)
|
|
if id == "" {
|
|
writeJSON(writer, http.StatusInternalServerError, map[string]string{"error": "无法创建播放会话"})
|
|
return
|
|
}
|
|
app.playbackMu.Lock()
|
|
if len(app.playbacks) >= app.mediaResources().snapshot().MaxSessions {
|
|
app.playbackMu.Unlock()
|
|
writeJSON(writer, http.StatusTooManyRequests, map[string]string{"error": "同时播放数量已达上限，请稍后再试"})
|
|
return
|
|
}
|
|
if app.playbacks == nil {
|
|
app.playbacks = make(map[string]*playbackSession)
|
|
}
|
|
session := &playbackSession{downloadIDs: downloadIDs, dramaID: sessionDramaID, id: id, viewer: viewer, expires: time.Now().Add(playbackIdleTimeout), state: "opening", cancel: cancel, openedAt: openedAt, historyRuns: make(map[uint64]playbackHistoryRun)}
|
|
viewer.retain()
|
|
app.playbacks[id] = session
|
|
session.timer = time.AfterFunc(playbackIdleTimeout, func() { app.expirePlayback(id) })
|
|
app.playbackMu.Unlock()
|
|
ready := false
|
|
defer func() {
|
|
if !ready {
|
|
app.closePlayback(id)
|
|
}
|
|
}()
|
|
if input.TaskID == "" {
|
|
fetchedTitle, chapters, err := app.downloader.GetDramaChapters(ctx, drama.ID)
|
|
if err == nil && len(chapters) == 0 {
|
|
err = errors.New("站点未返回可播放的分集")
|
|
}
|
|
if err != nil {
|
|
writeJSON(writer, http.StatusBadGateway, map[string]string{"error": "获取选集失败：" + app.redactError(err)})
|
|
return
|
|
}
|
|
title = firstNonEmpty(fetchedTitle, drama.DisplayTitle())
|
|
for index, chapter := range chapters {
|
|
tasks = append(tasks, Task{DramaID: drama.ID, DramaTitle: title, Chapter: chapter, Index: index + 1, Total: len(chapters)})
|
|
}
|
|
}
|
|
for _, task := range tasks {
|
|
if !taskSourceAllowed(request.Context(), task) {
|
|
writeSourceDenied(writer)
|
|
return
|
|
}
|
|
}
|
|
episodes := make([]playbackEpisode, 0, len(tasks))
|
|
for index, task := range tasks {
|
|
number := task.Index
|
|
if number < 1 {
|
|
number = index + 1
|
|
}
|
|
total := task.Total
|
|
if total < len(tasks) {
|
|
total = len(tasks)
|
|
}
|
|
if total < number {
|
|
total = number
|
|
}
|
|
episode := playbackEpisode{VIP: task.Chapter.VIP, Index: index + 1, Episode: task.Chapter.EpisodeString(number), Title: task.Chapter.Title, ChapterID: task.Chapter.ID, Number: number, Total: total}
|
|
_, _, episode.Danmaku = hongguoPlaybackIDs(task)
|
|
if len(downloadIDs) > 0 {
|
|
episode.TaskID = downloadIDs[index]
|
|
}
|
|
episodes = append(episodes, episode)
|
|
}
|
|
app.playbackMu.Lock()
|
|
if app.playbacks[id] == session && ctx.Err() == nil {
|
|
session.tasks = tasks
|
|
session.downloadIDs = downloadIDs
|
|
session.prepared = make(map[int]bool)
|
|
session.cancel = nil
|
|
session.state = "ready"
|
|
app.touchPlaybackLocked(session)
|
|
ready = true
|
|
}
|
|
app.playbackMu.Unlock()
|
|
if !ready {
|
|
writeJSON(writer, http.StatusRequestTimeout, map[string]string{"error": "播放准备超时，请重新打开本剧"})
|
|
return
|
|
}
|
|
mode := "online"
|
|
if len(downloadIDs) > 0 {
|
|
mode = "collection"
|
|
}
|
|
initialPosition, resumePaused, resumeMessage := float64(0), false, ""
|
|
if input.Resume && hasPrevious {
|
|
initialIndex, initialPosition, resumePaused, resumeMessage = playbackHistoryResume(previous, tasks, initialIndex)
|
|
}
|
|
dramaID, source, _ := playbackHistoryIdentity(tasks[0].DramaID)
|
|
writeJSON(writer, http.StatusOK, map[string]any{"session": id, "dramaId": dramaID, "source": source, "title": title, "releaseStatus": dramaReleaseStatus(drama), "vip": drama.VIP, "episodes": episodes, "mimeType": playbackMIME, "mode": mode, "initialIndex": initialIndex, "initialPosition": initialPosition, "resumePaused": resumePaused, "resumeMessage": resumeMessage})
|
|
}
|
|
|
|
func (app *UIApp) touchPlaybackLocked(session *playbackSession) {
|
|
session.expires = time.Now().Add(playbackIdleTimeout)
|
|
if session.timer != nil {
|
|
session.timer.Reset(playbackIdleTimeout)
|
|
}
|
|
}
|
|
|
|
func (app *UIApp) expirePlayback(id string) {
|
|
app.playbackMu.Lock()
|
|
session := app.playbacks[id]
|
|
if session != nil && time.Now().Before(session.expires) {
|
|
session.timer.Reset(time.Until(session.expires))
|
|
app.playbackMu.Unlock()
|
|
return
|
|
}
|
|
if session != nil {
|
|
delete(app.playbacks, id)
|
|
}
|
|
app.playbackMu.Unlock()
|
|
if session != nil && session.cancel != nil {
|
|
session.cancel()
|
|
}
|
|
if session != nil && session.prefetch != nil {
|
|
session.prefetch.cancel()
|
|
}
|
|
if session != nil {
|
|
session.viewer.release()
|
|
}
|
|
}
|
|
|
|
func (app *UIApp) closePlayback(id string) {
|
|
app.playbackMu.Lock()
|
|
session := app.playbacks[id]
|
|
if session != nil {
|
|
delete(app.playbacks, id)
|
|
session.timer.Stop()
|
|
}
|
|
app.playbackMu.Unlock()
|
|
if session != nil && session.cancel != nil {
|
|
session.cancel()
|
|
}
|
|
if session != nil && session.prefetch != nil {
|
|
session.prefetch.cancel()
|
|
}
|
|
if session != nil {
|
|
session.viewer.release()
|
|
}
|
|
}
|
|
|
|
func (app *UIApp) closePlaybacks() {
|
|
app.playbackMu.Lock()
|
|
sessions := app.playbacks
|
|
app.playbacks = nil
|
|
for _, session := range sessions {
|
|
session.timer.Stop()
|
|
}
|
|
app.playbackMu.Unlock()
|
|
for _, session := range sessions {
|
|
session.viewer.release()
|
|
if session.cancel != nil {
|
|
session.cancel()
|
|
}
|
|
if session.prefetch != nil {
|
|
session.prefetch.cancel()
|
|
}
|
|
}
|
|
}
|
|
|
|
func (app *UIApp) playbackStatus(id string, touch bool) (playbackView, bool) {
|
|
app.playbackMu.Lock()
|
|
defer app.playbackMu.Unlock()
|
|
session := app.playbacks[id]
|
|
if session == nil {
|
|
return playbackView{}, false
|
|
}
|
|
if touch {
|
|
app.touchPlaybackLocked(session)
|
|
}
|
|
view := playbackView{State: session.state, Error: session.error, Run: session.run, Duration: session.duration}
|
|
if session.native != nil {
|
|
state, err := session.native.state()
|
|
view.State = state
|
|
if err != nil {
|
|
view.Error = app.redactError(err)
|
|
}
|
|
}
|
|
if session.media != nil {
|
|
plan := session.media.plan
|
|
view.Plan = &plan
|
|
view.MediaBytes = session.media.bytes.Load()
|
|
view.MediaFailure = session.media.failed.Load() || session.media.proxy != nil && session.media.proxy.Err() != nil
|
|
}
|
|
if session.prefetch != nil {
|
|
view.Prefetch = session.prefetch.view()
|
|
}
|
|
return view, true
|
|
}
|
|
|
|
func (app *UIApp) handlePlaybackControl(writer http.ResponseWriter, request *http.Request) {
|
|
var input struct {
|
|
Session string `json:"session"`
|
|
Action string `json:"action"`
|
|
Progress *playbackHistoryProgress `json:"progress,omitempty"`
|
|
}
|
|
if !readPlaybackRequest(writer, request, &input) {
|
|
return
|
|
}
|
|
if !app.requirePlaybackOwner(writer, request, input.Session) {
|
|
return
|
|
}
|
|
if input.Action == "close" {
|
|
var progressError string
|
|
if input.Progress != nil {
|
|
if _, _, err := app.recordPlaybackProgress(contextViewer(request.Context()), input.Session, *input.Progress); err != nil {
|
|
progressError = publicError(err).Error()
|
|
}
|
|
}
|
|
app.closePlayback(input.Session)
|
|
writeJSON(writer, http.StatusOK, map[string]any{"ok": true, "historyError": progressError})
|
|
return
|
|
}
|
|
if input.Action != "heartbeat" {
|
|
writeJSON(writer, http.StatusBadRequest, map[string]string{"error": "不支持此播放操作"})
|
|
return
|
|
}
|
|
if state, ok := app.playbackStatus(input.Session, true); ok {
|
|
writeJSON(writer, http.StatusOK, state)
|
|
} else {
|
|
writeJSON(writer, http.StatusGone, map[string]string{"error": "播放会话已过期，请重新打开本剧"})
|
|
}
|
|
}
|
|
|
|
func (app *UIApp) handlePlaybackStatus(writer http.ResponseWriter, request *http.Request) {
|
|
if !playbackRequestAllowed(writer, request, http.MethodGet) {
|
|
return
|
|
}
|
|
if !app.requirePlaybackOwner(writer, request, request.URL.Query().Get("session")) {
|
|
return
|
|
}
|
|
if state, ok := app.playbackStatus(request.URL.Query().Get("session"), false); ok {
|
|
writeJSON(writer, http.StatusOK, state)
|
|
} else {
|
|
writeJSON(writer, http.StatusGone, map[string]string{"error": "播放会话已过期，请重新打开本剧"})
|
|
}
|
|
}
|
|
|
|
func (app *UIApp) handlePlaybackStream(writer http.ResponseWriter, request *http.Request) {
|
|
if !playbackRequestAllowed(writer, request, http.MethodGet) {
|
|
return
|
|
}
|
|
query := request.URL.Query()
|
|
index, indexErr := strconv.Atoi(query.Get("episode"))
|
|
offset, offsetErr := strconv.ParseFloat(firstNonEmpty(query.Get("start"), "0"), 64)
|
|
if indexErr != nil || index < 1 || offsetErr != nil || math.IsNaN(offset) || math.IsInf(offset, 0) || offset < 0 || offset > 24*60*60 {
|
|
writeJSON(writer, http.StatusBadRequest, map[string]string{"error": "集数或播放位置无效"})
|
|
return
|
|
}
|
|
quality, qualityErr := parsePlaybackQuality(query.Get("quality"))
|
|
version, versionErr := strconv.ParseUint(firstNonEmpty(query.Get("version"), "0"), 10, 64)
|
|
if qualityErr != nil || versionErr != nil {
|
|
writeJSON(writer, http.StatusBadRequest, map[string]string{"error": "清晰度或播放请求编号无效"})
|
|
return
|
|
}
|
|
ctx := context.WithValue(request.Context(), playbackRemuxKey{}, query.Get("remux") == "1")
|
|
run, status, err := app.beginPlayback(ctx, query.Get("session"), index, offset, quality, version, false)
|
|
if err != nil {
|
|
writeJSON(writer, status, map[string]string{"error": err.Error()})
|
|
return
|
|
}
|
|
defer run.stop()
|
|
writer = &playbackActivityWriter{ResponseWriter: writer, app: app, run: run}
|
|
startupTimer := time.AfterFunc(90*time.Second, run.cancel)
|
|
defer startupTimer.Stop()
|
|
ready := func(duration float64) {
|
|
startupTimer.Stop()
|
|
app.playbackRunReady(run, duration)
|
|
}
|
|
used, err := app.servePrefetchedPlayback(run.ctx, writer, run.cache, run.run, ready)
|
|
if !used {
|
|
err = app.streamPlayback(run.ctx, run.cancel, writer, run.task, run.downloadID, offset, run.run, ready)
|
|
}
|
|
app.finishPlaybackRun(run, err, request.Context().Err() != nil)
|
|
}
|