467 lines
15 KiB
Go
467 lines
15 KiB
Go
package api
|
||
|
||
import (
|
||
"context"
|
||
"encoding/json"
|
||
"net/http"
|
||
"net/url"
|
||
"strconv"
|
||
"strings"
|
||
|
||
"github.com/ponzischeme89/memby/server/internal/emby"
|
||
"github.com/ponzischeme89/memby/server/internal/store"
|
||
)
|
||
|
||
const ticksPerMillisecond = 10_000
|
||
|
||
type playbackResponse struct {
|
||
ItemID string `json:"itemId"`
|
||
Title string `json:"title"`
|
||
URL string `json:"url"`
|
||
ResumePositionMs int64 `json:"resumePositionMs"`
|
||
Subtitles []playableSubtitle `json:"subtitles"`
|
||
MediaSourceID string `json:"mediaSourceId"`
|
||
PlaySessionID string `json:"playSessionId"`
|
||
PlayMethod string `json:"playMethod"`
|
||
}
|
||
|
||
type playableSubtitle struct {
|
||
ID string `json:"id"`
|
||
URL string `json:"url"`
|
||
MimeType string `json:"mimeType"`
|
||
Language string `json:"language,omitempty"`
|
||
Label string `json:"label,omitempty"`
|
||
IsDefault bool `json:"isDefault"`
|
||
IsForced bool `json:"isForced"`
|
||
IsHearingImpaired bool `json:"isHearingImpaired"`
|
||
DeliveryMethod string `json:"deliveryMethod"`
|
||
Codec string `json:"codec,omitempty"`
|
||
}
|
||
|
||
type playbackReport struct {
|
||
ItemID string `json:"itemId"`
|
||
PositionMs int64 `json:"positionMs"`
|
||
IsPaused bool `json:"isPaused"`
|
||
MediaSourceID string `json:"mediaSourceId"`
|
||
PlaySessionID string `json:"playSessionId"`
|
||
PlayMethod string `json:"playMethod"`
|
||
EventName string `json:"eventName,omitempty"`
|
||
}
|
||
|
||
// nextEpisodeResponse carries the episode that follows the one being watched. Item is
|
||
// Emby's own item JSON, forwarded verbatim like every other item the gateway returns, so
|
||
// the client decodes it into the same BaseItem it uses everywhere else.
|
||
type nextEpisodeResponse struct {
|
||
Item json.RawMessage `json:"item"`
|
||
Title string `json:"title"`
|
||
URL string `json:"url"`
|
||
ResumePositionMs int64 `json:"resumePositionMs"`
|
||
Subtitles []playableSubtitle `json:"subtitles"`
|
||
MediaSourceID string `json:"mediaSourceId"`
|
||
PlaySessionID string `json:"playSessionId"`
|
||
PlayMethod string `json:"playMethod"`
|
||
}
|
||
|
||
// handlePlayback resolves what to actually play.
|
||
//
|
||
// This is logic the TV used to carry: a series resolves to its next-up episode (falling
|
||
// back to the first), and the returned URL points straight at Emby so the video stream
|
||
// never traverses the gateway.
|
||
func (s *Server) handlePlayback(w http.ResponseWriter, r *http.Request, sess store.Session) {
|
||
ctx := r.Context()
|
||
itemID := r.PathValue("id")
|
||
if itemID == "" {
|
||
writeError(w, http.StatusBadRequest, "item id is required")
|
||
return
|
||
}
|
||
cred := credentials(sess)
|
||
|
||
item, hinted := playbackHint(r, itemID)
|
||
if !hinted {
|
||
raw, err := s.emby.Item(ctx, cred, itemID, "RunTimeTicks,SeriesName")
|
||
if err != nil {
|
||
s.writeUpstreamError(w, err, "could not load the item")
|
||
return
|
||
}
|
||
item, err = emby.Summarise(raw)
|
||
if err != nil {
|
||
writeError(w, http.StatusBadGateway, "unreadable item from emby")
|
||
return
|
||
}
|
||
}
|
||
|
||
target := item
|
||
title := item.Name
|
||
|
||
if strings.EqualFold(item.Type, "Series") {
|
||
episode, err := s.firstPlayableEpisode(ctx, cred, item.ID)
|
||
if err != nil {
|
||
s.writeUpstreamError(w, err, "could not find an episode to play")
|
||
return
|
||
}
|
||
if episode == nil {
|
||
writeError(w, http.StatusNotFound, "no episodes found for this series")
|
||
return
|
||
}
|
||
target = *episode
|
||
if episode.Name != "" {
|
||
title = item.Name + " – " + episode.Name
|
||
}
|
||
}
|
||
|
||
var subtitleIndex *int
|
||
if raw := strings.TrimSpace(r.URL.Query().Get("subtitleIndex")); raw != "" {
|
||
if parsed, err := strconv.Atoi(raw); err == nil && parsed >= 0 {
|
||
subtitleIndex = &parsed
|
||
}
|
||
}
|
||
subtitles, mediaSourceID, playSessionID, negotiatedURL, playMethod := s.playbackSubtitles(
|
||
ctx, cred, target.ID, target.UserData.PlaybackPositionTicks, subtitleIndex, "",
|
||
)
|
||
streamURL := s.emby.StreamURL(cred, target.ID)
|
||
if negotiatedURL != "" {
|
||
streamURL = negotiatedURL
|
||
}
|
||
writeJSON(w, http.StatusOK, playbackResponse{
|
||
ItemID: target.ID,
|
||
Title: title,
|
||
URL: streamURL,
|
||
ResumePositionMs: max64(target.UserData.PlaybackPositionTicks/ticksPerMillisecond, 0),
|
||
Subtitles: subtitles,
|
||
MediaSourceID: mediaSourceID,
|
||
PlaySessionID: playSessionID,
|
||
PlayMethod: playMethod,
|
||
})
|
||
}
|
||
|
||
// Current clients already know the selected item's type, title and cached resume point.
|
||
// Accepting those as hints removes one serial Emby request from every launch. Older
|
||
// clients omit them and retain the authoritative lookup above.
|
||
func playbackHint(r *http.Request, itemID string) (emby.Summary, bool) {
|
||
itemType := strings.TrimSpace(r.URL.Query().Get("type"))
|
||
switch {
|
||
case strings.EqualFold(itemType, "Movie"):
|
||
itemType = "Movie"
|
||
case strings.EqualFold(itemType, "Episode"):
|
||
itemType = "Episode"
|
||
case strings.EqualFold(itemType, "Series"):
|
||
itemType = "Series"
|
||
default:
|
||
return emby.Summary{}, false
|
||
}
|
||
resumeMs, _ := strconv.ParseInt(r.URL.Query().Get("resumePositionMs"), 10, 64)
|
||
item := emby.Summary{
|
||
ID: itemID,
|
||
Name: strings.TrimSpace(r.URL.Query().Get("title")),
|
||
Type: itemType,
|
||
}
|
||
item.UserData.PlaybackPositionTicks = max64(resumeMs, 0) * ticksPerMillisecond
|
||
return item, true
|
||
}
|
||
|
||
// firstPlayableEpisode prefers the server's next-up choice and falls back to episode one.
|
||
func (s *Server) firstPlayableEpisode(ctx context.Context, cred emby.Credentials, seriesID string) (*emby.Summary, error) {
|
||
nextUp, err := s.emby.NextUp(ctx, cred, url.Values{
|
||
"SeriesId": {seriesID},
|
||
"Limit": {"1"},
|
||
"Fields": {"RunTimeTicks"},
|
||
"EnableUserData": {"true"},
|
||
})
|
||
if err == nil && len(nextUp.Items) > 0 {
|
||
if summary, err := emby.Summarise(nextUp.Items[0]); err == nil {
|
||
return &summary, nil
|
||
}
|
||
}
|
||
|
||
episodes, err := s.emby.Episodes(ctx, cred, seriesID, url.Values{
|
||
"Limit": {"1"},
|
||
"Fields": {"RunTimeTicks"},
|
||
"EnableUserData": {"true"},
|
||
})
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
if len(episodes.Items) == 0 {
|
||
return nil, nil
|
||
}
|
||
summary, err := emby.Summarise(episodes.Items[0])
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return &summary, nil
|
||
}
|
||
|
||
// handleNextEpisode resolves the episode that follows the one being watched, so the player
|
||
// can offer a "next up" countdown without the TV needing to know how Emby orders a series.
|
||
//
|
||
// "Nothing follows this" is a normal answer, not a failure: a movie, a series finale and an
|
||
// unreadable series all come back as 404 and the client simply shows no banner.
|
||
func (s *Server) handleNextEpisode(w http.ResponseWriter, r *http.Request, sess store.Session) {
|
||
ctx := r.Context()
|
||
itemID := r.PathValue("id")
|
||
if itemID == "" {
|
||
writeError(w, http.StatusBadRequest, "item id is required")
|
||
return
|
||
}
|
||
cred := credentials(sess)
|
||
|
||
// The client already knows which series it launched, so accepting it as a hint keeps
|
||
// this off Emby for one round trip. Older clients omit it and we look it up.
|
||
seriesID := strings.TrimSpace(r.URL.Query().Get("seriesId"))
|
||
if seriesID == "" {
|
||
raw, err := s.emby.Item(ctx, cred, itemID, "SeriesId")
|
||
if err != nil {
|
||
s.writeUpstreamError(w, err, "could not load the item")
|
||
return
|
||
}
|
||
var parsed struct {
|
||
SeriesID string `json:"SeriesId"`
|
||
}
|
||
if err := json.Unmarshal(raw, &parsed); err != nil {
|
||
writeError(w, http.StatusBadGateway, "unreadable item from emby")
|
||
return
|
||
}
|
||
seriesID = parsed.SeriesID
|
||
}
|
||
if seriesID == "" {
|
||
writeError(w, http.StatusNotFound, "this item is not part of a series")
|
||
return
|
||
}
|
||
|
||
episodes, err := s.emby.Episodes(ctx, cred, seriesID, url.Values{
|
||
"AdjacentTo": {itemID},
|
||
"Fields": {"RunTimeTicks,Overview,SeriesName"},
|
||
"EnableUserData": {"true"},
|
||
"EnableImageTypes": {"Primary,Thumb"},
|
||
})
|
||
if err != nil {
|
||
s.writeUpstreamError(w, err, "could not load the next episode")
|
||
return
|
||
}
|
||
|
||
raw, next, ok := episodeAfter(episodes.Items, itemID)
|
||
if !ok {
|
||
writeError(w, http.StatusNotFound, "no episode follows this one")
|
||
return
|
||
}
|
||
|
||
title := next.Name
|
||
if series := strings.TrimSpace(seriesNameOf(raw)); series != "" && title != "" {
|
||
title = series + " – " + title
|
||
}
|
||
subtitles, mediaSourceID, playSessionID, _, playMethod := s.playbackSubtitles(
|
||
ctx, cred, next.ID, next.UserData.PlaybackPositionTicks, nil, "",
|
||
)
|
||
writeJSON(w, http.StatusOK, nextEpisodeResponse{
|
||
Item: raw,
|
||
Title: title,
|
||
URL: s.emby.StreamURL(cred, next.ID),
|
||
ResumePositionMs: max64(next.UserData.PlaybackPositionTicks/ticksPerMillisecond, 0),
|
||
Subtitles: subtitles,
|
||
MediaSourceID: mediaSourceID,
|
||
PlaySessionID: playSessionID,
|
||
PlayMethod: playMethod,
|
||
})
|
||
}
|
||
|
||
func (s *Server) playbackSubtitles(
|
||
ctx context.Context, cred emby.Credentials, itemID string, startTicks int64,
|
||
subtitleIndex *int, currentPlaySessionID string,
|
||
) ([]playableSubtitle, string, string, string, string) {
|
||
info, err := s.emby.PlaybackInfo(
|
||
ctx, cred, itemID, startTicks, subtitleIndex, currentPlaySessionID,
|
||
)
|
||
if err != nil {
|
||
s.log.Warn("could not load subtitle metadata", "item_id", itemID, "error", err)
|
||
return []playableSubtitle{}, itemID, "", "", "DirectPlay"
|
||
}
|
||
if len(info.MediaSources) == 0 {
|
||
return []playableSubtitle{}, itemID, info.PlaySessionID, "", "DirectPlay"
|
||
}
|
||
out := make([]playableSubtitle, 0)
|
||
seen := make(map[string]bool)
|
||
source := info.MediaSources[0]
|
||
for _, stream := range source.MediaStreams {
|
||
if !strings.EqualFold(stream.Type, "Subtitle") || stream.Index < 0 {
|
||
continue
|
||
}
|
||
method := stream.DeliveryMethod
|
||
if method == "" {
|
||
if stream.IsTextSubtitleStream {
|
||
method = "External"
|
||
} else {
|
||
method = "Encode"
|
||
}
|
||
}
|
||
delivery := ""
|
||
mimeType := subtitleMIME(stream.Codec, stream.DeliveryURL)
|
||
if strings.EqualFold(method, "External") && mimeType != "" {
|
||
if stream.DeliveryURL != "" {
|
||
delivery = s.emby.DeliveryURL(cred, stream.DeliveryURL)
|
||
} else {
|
||
delivery = s.emby.SubtitleURL(cred, itemID, source.ID, stream.Index, subtitleExtension(stream.Codec))
|
||
}
|
||
}
|
||
key := strconv.Itoa(stream.Index)
|
||
if seen[key] {
|
||
continue
|
||
}
|
||
seen[key] = true
|
||
label := strings.TrimSpace(stream.DisplayTitle)
|
||
if label == "" {
|
||
label = strings.TrimSpace(stream.Title)
|
||
}
|
||
out = append(out, playableSubtitle{
|
||
ID: strconv.Itoa(stream.Index),
|
||
URL: delivery,
|
||
MimeType: mimeType,
|
||
Language: strings.TrimSpace(stream.Language),
|
||
Label: label,
|
||
IsDefault: stream.IsDefault,
|
||
IsForced: stream.IsForced,
|
||
IsHearingImpaired: stream.IsHearingImpaired ||
|
||
strings.Contains(strings.ToLower(stream.Title+" "+stream.DisplayTitle), "sdh") ||
|
||
strings.Contains(strings.ToLower(stream.Title+" "+stream.DisplayTitle), "hearing"),
|
||
DeliveryMethod: method,
|
||
Codec: stream.Codec,
|
||
})
|
||
}
|
||
negotiatedURL := ""
|
||
playMethod := "DirectPlay"
|
||
if subtitleIndex != nil && source.TranscodingURL != "" {
|
||
negotiatedURL = s.emby.DeliveryURL(cred, source.TranscodingURL)
|
||
playMethod = "Transcode"
|
||
}
|
||
return out, source.ID, info.PlaySessionID, negotiatedURL, playMethod
|
||
}
|
||
|
||
func subtitleExtension(codec string) string {
|
||
switch strings.ToLower(strings.TrimSpace(codec)) {
|
||
case "subrip":
|
||
return "srt"
|
||
case "webvtt":
|
||
return "vtt"
|
||
case "tx3g":
|
||
return "mov_text"
|
||
default:
|
||
if strings.TrimSpace(codec) == "" {
|
||
return "vtt"
|
||
}
|
||
return strings.ToLower(strings.TrimSpace(codec))
|
||
}
|
||
}
|
||
|
||
func subtitleMIME(codec, delivery string) string {
|
||
value := strings.ToLower(strings.TrimSpace(codec))
|
||
if value == "" {
|
||
path := delivery
|
||
if parsed, err := url.Parse(delivery); err == nil {
|
||
path = parsed.Path
|
||
}
|
||
if dot := strings.LastIndex(path, "."); dot >= 0 {
|
||
value = strings.ToLower(path[dot+1:])
|
||
}
|
||
}
|
||
switch value {
|
||
case "srt", "subrip":
|
||
return "application/x-subrip"
|
||
case "vtt", "webvtt":
|
||
return "text/vtt"
|
||
case "ass", "ssa":
|
||
return "text/x-ssa"
|
||
case "ttml", "dfxp":
|
||
return "application/ttml+xml"
|
||
case "tx3g", "mov_text":
|
||
return "application/x-quicktime-tx3g"
|
||
default:
|
||
return ""
|
||
}
|
||
}
|
||
|
||
// episodeAfter picks the episode following currentID out of an AdjacentTo result, which
|
||
// Emby returns in running order as [previous, current, next] minus whichever ends do not
|
||
// exist — so the position of the current episode is what identifies the next one, not the
|
||
// length of the list.
|
||
func episodeAfter(items []json.RawMessage, currentID string) (json.RawMessage, emby.Summary, bool) {
|
||
for i, raw := range items {
|
||
summary, err := emby.Summarise(raw)
|
||
if err != nil || summary.ID != currentID {
|
||
continue
|
||
}
|
||
if i+1 >= len(items) {
|
||
return nil, emby.Summary{}, false
|
||
}
|
||
next, err := emby.Summarise(items[i+1])
|
||
if err != nil || next.ID == "" {
|
||
return nil, emby.Summary{}, false
|
||
}
|
||
return items[i+1], next, true
|
||
}
|
||
return nil, emby.Summary{}, false
|
||
}
|
||
|
||
func seriesNameOf(raw json.RawMessage) string {
|
||
var parsed struct {
|
||
SeriesName string `json:"SeriesName"`
|
||
}
|
||
if err := json.Unmarshal(raw, &parsed); err != nil {
|
||
return ""
|
||
}
|
||
return parsed.SeriesName
|
||
}
|
||
|
||
// handlePlaybackReport forwards progress to Emby. Stopping invalidates the user's cache
|
||
// so Continue Watching reflects the new position on the next home load.
|
||
func (s *Server) handlePlaybackReport(w http.ResponseWriter, r *http.Request, sess store.Session) {
|
||
phase := r.PathValue("phase")
|
||
switch phase {
|
||
case "started", "progress", "stopped":
|
||
default:
|
||
writeError(w, http.StatusNotFound, "unknown playback phase")
|
||
return
|
||
}
|
||
|
||
var report playbackReport
|
||
if err := json.NewDecoder(http.MaxBytesReader(w, r.Body, 4<<10)).Decode(&report); err != nil {
|
||
writeError(w, http.StatusBadRequest, "malformed request body")
|
||
return
|
||
}
|
||
if report.ItemID == "" {
|
||
writeError(w, http.StatusBadRequest, "itemId is required")
|
||
return
|
||
}
|
||
|
||
err := s.emby.ReportPlayback(
|
||
r.Context(), credentials(sess), phase, report.ItemID, report.MediaSourceID,
|
||
report.PlaySessionID, report.PlayMethod, report.EventName,
|
||
max64(report.PositionMs, 0)*ticksPerMillisecond, report.IsPaused,
|
||
)
|
||
if err != nil {
|
||
// A dropped progress report is not worth failing playback over; log and accept.
|
||
s.log.Warn("playback report failed", "phase", phase, "error", err)
|
||
}
|
||
|
||
if phase == "stopped" {
|
||
if err := s.cache.InvalidateUser(r.Context(), sess.EmbyUserID); err != nil {
|
||
s.log.Warn("cache invalidation failed", "error", err)
|
||
}
|
||
// Finishing something is the one event that genuinely changes viewing history,
|
||
// so it is also the only thing that retires the recommendation rows.
|
||
if err := s.cache.InvalidateRecommendations(r.Context(), sess.EmbyUserID); err != nil {
|
||
s.log.Warn("recommendation invalidation failed", "error", err)
|
||
}
|
||
if s.forYou != nil {
|
||
s.forYou.MarkDirty(r.Context(), sess)
|
||
s.forYou.RefreshAsync(sess, true)
|
||
}
|
||
}
|
||
w.WriteHeader(http.StatusNoContent)
|
||
}
|
||
|
||
func max64(v, floor int64) int64 {
|
||
if v < floor {
|
||
return floor
|
||
}
|
||
return v
|
||
}
|