Watching & requesting

This is the home media system — everything the household can watch, on the TV, a laptop, or a phone. There are two apps, and it helps to know which is which:

Jellyfin — the TV. Where you actually watch movies and shows.
Jellyseerr — the shop. Where you ask for something new. It doesn't play anything itself; it just puts in the request, and the film or series turns up in Jellyfin a little while later.

You need to be on the home Wi-Fi

Both apps only work when you're connected to the home network. They're not reachable from outside the house — there's nothing to open from a café or on mobile data.

Watching on the Apple TV

The Apple TV is the main way to watch, and there's just one app for everything: JellyTV. It plays your Jellyfin library and lets you request new titles, so it's the only app you need to install. Set it up once:

On the Apple TV, open the App Store and install JellyTV.
Open the app and choose Add Server.
Enter the address: https://jellyfin.local.spaelling.xyz
Sign in with your Jellyfin username and password (ask whoever runs the system to make you one if you don't have it yet).
In JellyTV's settings, turn on the Remux playback engine (it's marked experimental). Don't skip this one — it's what makes playback smooth.

After that, just open the app, pick something, and press play.

Leave the Remux engine switched on

With it off, playback stutters and titles are slow to start. The Apple TV can't open these video files by itself, so the server has to rebuild the video as it goes — and it isn't fast enough to keep up. With Remux on, the Apple TV does that work itself and the server just sends the file across untouched.

Why it matters — for whoever runs the system

Most of the library is HEVC (x265) video in an MKV container, which the Apple TV's built-in player cannot open. Jellyfin's fallback is to negotiate an fMP4 HLS stream, but JellyTV's request is refused by the server (Invalid HLS segment container: fmp4, default to mpegts) and HEVC cannot be carried in mpegts for Apple playback. That leaves Jellyfin one option: a full H.264 re-encode in software. The Raspberry Pi 5 has no hardware video encoder — the Pi 4's H.264 block was dropped, and BCM2712 only decodes HEVC — so libx264 runs on the CPU and cannot keep up. That was the stutter.

The Remux engine sidesteps the whole negotiation by repackaging the MKV into an Apple-friendly stream on the Apple TV itself, so the server direct-plays the original file and never launches ffmpeg.

Check it is working from the Sessions API — PlayMethod should be DirectPlay with no TranscodingInfo:

kubectl -n servarr exec deploy/jellyfin -- curl -s -H "Authorization: MediaBrowser Token=<api-key>" http://127.0.0.1:8096/Sessions

Anything other than DirectPlay means transcoding is back on that client. This applies to the Apple TV path only — browsers, phones and tablets still transcode, so Jellyfin's memory headroom and its NVMe transcode scratch are still needed (see Jellyfin). What it does settle is that the Apple TV alone is no reason to move Jellyfin to x86 for QuickSync hardware transcoding, which was seriously considered before the real cause was found.

Audio has to be a format the Apple TV understands

The Remux engine only repackages the container. The audio track still has to be one the Apple TV can decode natively — AAC, AC-3, E-AC-3, ALAC, FLAC, MP3 and LPCM/WAV all qualify. Opus does not, and it is the one that turns up here. When the audio isn't native, the Apple TV converts it on the fly, which is what makes a title slow to start or resume.

Keep Opus out of the library

Thirteen files — a full season from one release group — arrived with Opus audio and were converted in place to AAC on 2026-07-27, copying the video stream untouched so the picture was not re-encoded.

Sonarr blocks it coming back with a Custom Format named Opus Audio, scored negative in every quality profile: a Release Group condition matching HETeam and a Release Title condition matching \bopus\b. Neither is marked Required, and Servarr treats non-required conditions as OR, so either one alone applies the format. Sonarr and Radarr only ever see the release name, never the codec, so this is a name-pattern match and not a real inspection. Radarr has no equivalent yet — films are still unprotected.

Converting a file in place — for whoever runs the system

Copy every stream and re-encode only the audio, so the video is never touched:

ffmpeg -nostdin -i input.mkv -map 0 -c copy -c:a libfdk_aac -b:a 192k -y output.mkv

Two constraints decide where you can run that. Jellyfin mounts /data read-only, so it cannot write to the library; and libfdk_aac is absent from stock distro ffmpeg builds. The LSIO Jellyfin image satisfies both needs at once — it ships /usr/lib/jellyfin-ffmpeg/ffmpeg with libfdk_aac — so run a throwaway pod from that image with the data PVC mounted read-write:

kubectl run audiofix -n servarr --restart=Never --image=lscr.io/linuxserver/jellyfin:latest --overrides='{"spec":{"securityContext":{"runAsUser":1000,"runAsGroup":1000},"containers":[{"name":"ff","image":"lscr.io/linuxserver/jellyfin:latest","command":["sleep","infinity"],"volumeMounts":[{"name":"data","mountPath":"/data"}]}],"volumes":[{"name":"data","persistentVolumeClaim":{"claimName":"data"}}]}}'

Run as UID/GID 1000 so rewritten files keep their ownership, and do not set fsGroup — it would force a recursive chown of the whole shared volume. Write to a temp path on the same filesystem, verify the result (audio codec is aac, video codec unchanged, stream count and duration match), and only then mv over the original. Delete the pod when done.

Subtitles

While something is playing, open the on-screen controls and use the subtitles menu (the speech-bubble icon) to turn subtitles on or change the language. If a new title doesn't have subtitles yet, they usually appear on their own within a few minutes.

Watching on a phone, tablet, or laptop

Laptop or computer: open a browser, go to https://jellyfin.local.spaelling.xyz, sign in, and play. Nothing to install.
Phone or tablet: install the Jellyfin app (App Store / Google Play), add the same address, and sign in.

Requesting something new

If a film or series isn't in Jellyfin yet, ask for it in Jellyseerr:

Go to https://jellyseerr.local.spaelling.xyz and sign in with your Jellyfin account — the same username and password.
Search for the movie or show.
Press Request. For a series, tick the season(s) you want — you can pick a current season, or even one that hasn't aired yet, and it'll download automatically as new episodes come out.
That's it — the request is handed off for you. You can follow it in Jellyseerr as it moves from Requested → Processing → Available.
Once it says Available, open Jellyfin and it'll be there to watch.

Requesting from the Apple TV

You don't need a second app — JellyTV has Jellyseerr built in, so you can request from the couch in the same place you watch. Point it at the Jellyseerr address https://jellyseerr.local.spaelling.xyz in JellyTV's settings (ask whoever runs the system if it needs a key or sign-in). Once it's connected, browse or search for something that isn't in the library yet and press Request — it turns up in Jellyfin a little while later, exactly like a request made on the website.

If the in-app requesting ever isn't set up on your Apple TV, the Jellyseerr website (below) always works from any device on the home Wi-Fi.

One app does it all

On the Apple TV, JellyTV is the only app: browse and press play to watch, and use its built-in Jellyseerr to request. Anything you request always ends up playing back in JellyTV once it's ready.

If something won't play

Check that you're on the home Wi-Fi.
On the Apple TV, if playback stutters or a title is slow to start, check Remux is still switched on in JellyTV's settings (see Watching on the Apple TV).
If a title just finished being added, give it a minute or two and refresh — the system may still be reading it in.
Still stuck? Let whoever runs the system know which title it was and what the screen said.