A Car TV Jellyfin Box for the Honda Odyssey, Toyota Sienna, and Any HDMI Rear Screen

What “Good” Looks Like

After boot, with no keyboard, on a PC that meets the minimum above:

1. The desktop user is logged in.
2. Jellyfin is Healthy on port 8096.
3. Jellyfin Media Player is fullscreen in TV mode, pointed at http://127.0.0.1:8096.
4. A baseline file plays and the Jellyfin dashboard says Direct Play, not Transcode.
5. A file copied from a Mac or a Windows PC is readable by the jellyfin user.
6. Boot reaches the desktop without a multi-minute wait for the internet.
7. System volume and the Jellyfin slider are both at 100% when the car screen is connected, and sound comes out of that screen.

The file that counts as working

Keep the library in this shape. It hardware-decodes on every PC in the minimum, including a 6th-gen NUC. Newer NUCs play the same files. You do not need a second format.

Install Ubuntu Desktop

Install the current Ubuntu Desktop LTS from the USB installer. As of this guide that is 26.04. Desktop is easier to keep working for years than Ubuntu Server or a hand-built kiosk. A clean start is Erase disk and install Ubuntu.

After the first boot:

• Install updates and reboot once.
• Create the desktop user that will auto-login. The examples below call that user car.
• Use one password for the Linux account, Samba, and the Jellyfin admin. Keep that password off anything you publish.

If the disk is LVM and the installer left free space in the volume group, give it all to root:

sudo lvextend -l +100%FREE --resizefs /dev/ubuntu-vg/ubuntu-lv

Confirm with df -h / and sudo lvs.

Driver and Codecs for the Minimum PC

The pass line is H.264 decode in hardware. After Ubuntu is installed, vainfo has to list VAProfileH264High with VAEntrypointVLD. If that line is missing, the PC is below the minimum. A video transcode will not make it a car player.

vainfo
ls -l /dev/dri/renderD128

Install one driver. Match it to what vainfo prints, not to the sticker on the case.

The iHD driver is the wrong package on a 6th-gen chip. The i965 driver is the wrong package once vainfo is already using iHD.

i965-only drop-in, /etc/systemd/system/jellyfin.service.d/vaapi.conf, then sudo systemctl daemon-reload && sudo systemctl restart jellyfin. Skip this file when vainfo already shows iHD:

[Service]
Environment=LIBVA_DRIVER_NAME=i965

Trust vainfo, not the generation printed on the case.

encoding.xml on a weak box

These values in /etc/jellyfin/encoding.xml are a backstop. Video transcoding is disabled on the user, so they are not the normal path.

User policy for the admin account

Set this in the dashboard, or with the user policy API.

Remux only changes the container. It does not re-encode the picture. Audio conversion is cheap and keeps odd sound tracks audible. A bitrate limit of 0 means the stream is not squeezed.

Codecs that play well

Standardize on the baseline. It is the format a 6th-gen NUC and every newer Intel NUC both direct-play. 8-bit HEVC also direct-plays on that floor when vainfo lists HEVC Main. You do not need it.

When a file is outside that table, re-encode it with HandBrake on another computer before you copy it: H.264, 1080p, 8-bit, yuv420p, AAC stereo. Then the dashboard should say Direct Play.

Three failures that look the same from the back seat

Jellyfin’s own ffmpeg is /usr/lib/jellyfin-ffmpeg/ffmpeg, from the jellyfin-ffmpeg8 package. Leave the service pointed at that binary, not the distro ffmpeg. Playback logs are /var/log/jellyfin/FFmpeg.*.log plus jellyfinYYYYMMDD.log.

Media Folders and Permissions

This was the actual playback bug. It looked like a driver problem and a transcode problem. It was file mode. macOS, copying over SMB, created files as mode 700 and set the ACL mask to ---. Jellyfin runs as user jellyfin. Direct play and transcode both need that user to open the file. FFmpeg exited 243 with Permission denied. ffprobe as root worked. ffprobe as jellyfin failed. Logs said “streams and format are both null” for the same reason.

sudo groupadd --system media || true
sudo usermod -aG media,video,render "$USER"
sudo usermod -aG media,video,render jellyfin

sudo mkdir -p /srv/media/movies /srv/media/tv
sudo chown -R "$USER":media /srv/media
sudo chmod 2775 /srv/media /srv/media/movies /srv/media/tv

sudo setfacl -m u:jellyfin:rx,g:media:rx /srv/media /srv/media/movies /srv/media/tv
sudo setfacl -d -m u:jellyfin:rx,g:media:rx,o::rx /srv/media /srv/media/movies /srv/media/tv

The 2 in 2775 is setgid, so new files stay in group media. The Samba settings in the next section keep new copies readable, including files a Mac would otherwise save as mode 700. After any batch of copies, check:

sudo -u jellyfin find /srv/media -type f ! -readable -print

Run that from /tmp. Running it from the desktop user’s home prints “Failed to restore initial working directory” because jellyfin cannot enter that home directory. That warning is not a media failure. No printed paths means every file is readable. /srv itself can stay 755 root:root. Jellyfin only needs to traverse it.

Jellyfin Media Player

Install the player from the Jellyfin Media Player releases. Trust dpkg for the version. jellyfinmediaplayer --version can report an older number than the package.

The published deb may still depend on the old t64 library names. Current Ubuntu dropped that suffix, so apt refuses the package. The unmet names are libqt6core6t64, libqt6dbus6t64, libqt6gui6t64, libqt6network6t64, libqt6opengl6t64, libqt6widgets6t64, and libqt6xml6t64. If the deb installs cleanly, skip the rewrite. If it does not, rewrite and install:

dpkg-deb -R jellyfin-media-player.deb /tmp/jmp-unpack
sed -i \
  -e 's/libqt6core6t64/libqt6core6/g' \
  -e 's/libqt6dbus6t64/libqt6dbus6/g' \
  -e 's/libqt6gui6t64/libqt6gui6/g' \
  -e 's/libqt6network6t64/libqt6network6/g' \
  -e 's/libqt6opengl6t64/libqt6opengl6/g' \
  -e 's/libqt6widgets6t64/libqt6widgets6/g' \
  -e 's/libqt6xml6t64/libqt6xml6/g' \
  /tmp/jmp-unpack/DEBIAN/control
dpkg-deb -b /tmp/jmp-unpack /tmp/jellyfin-media-player-resolute.deb
sudo apt-get install /tmp/jellyfin-media-player-resolute.deb

Other dependencies (libmpv2, Qt Quick, WebEngine, SDL2, libcec) are already in current Ubuntu. After install, confirm /usr/bin/jellyfinmediaplayer exists.

Current Ubuntu’s libmpv expects a playlist index in front of the loadfile options. The published player may still call it the old way, so every play click fails with Command loadfile: argument index has incompatible type. The poster goes fullscreen and the app looks frozen. FFmpeg is not involved. Zero-copy VA-API also fails in this player’s OpenGL path (VAAPI hwdec only works with OpenGL or Vulkan backends), so the same library switches hwdec=auto to hwdec=auto-copy. H.264 and 8-bit HEVC can use the GPU when vainfo lists them. 10-bit HEVC uses the GPU only when Main 10 is listed, and otherwise falls back to software.

Build the shim on the PC:

sudo apt install gcc libmpv-dev

Save this as /tmp/jmp-mpv-loadfile.c:

#define _GNU_SOURCE
#include <dlfcn.h>
#include <stdint.h>
#include <stdlib.h>
#include <string.h>
#include <mpv/client.h>

static int (*real_command_node)(mpv_handle *, mpv_node *, mpv_node *);
static int (*real_command_node_async)(mpv_handle *, uint64_t, mpv_node *);
static int (*real_set_property)(mpv_handle *, const char *, mpv_format, void *);
static int (*real_set_property_async)(mpv_handle *, uint64_t, const char *, mpv_format, void *);

static void resolve(void) __attribute__((constructor));
static void resolve(void) {
    real_command_node = dlsym(RTLD_NEXT, "mpv_command_node");
    real_command_node_async = dlsym(RTLD_NEXT, "mpv_command_node_async");
    real_set_property = dlsym(RTLD_NEXT, "mpv_set_property");
    real_set_property_async = dlsym(RTLD_NEXT, "mpv_set_property_async");
}

static int needs_index(const mpv_node *args) {
    if (!args || args->format != MPV_FORMAT_NODE_ARRAY || !args->u.list)
        return 0;
    const mpv_node_list *list = args->u.list;
    if (list->num < 4 || !list->values)
        return 0;
    if (list->values[0].format != MPV_FORMAT_STRING || !list->values[0].u.string)
        return 0;
    if (strcmp(list->values[0].u.string, "loadfile") != 0 &&
        strcmp(list->values[0].u.string, "loadlist") != 0)
        return 0;
    if (list->values[2].format != MPV_FORMAT_STRING)
        return 0;
    if (list->values[3].format == MPV_FORMAT_INT64)
        return 0;
    return 1;
}

static void call_rewritten(mpv_handle *ctx, mpv_node *args, mpv_node *result,
                           int async, uint64_t reply, int *rc) {
    mpv_node_list *old = args->u.list;
    mpv_node *values = calloc((size_t)old->num + 1, sizeof(mpv_node));
    mpv_node_list rewritten = *old;
    mpv_node saved = *args;
    if (!values) {
        *rc = real_command_node ? real_command_node(ctx, args, result) : -1;
        return;
    }
    values[0] = old->values[0];
    values[1] = old->values[1];
    values[2] = old->values[2];
    values[3].format = MPV_FORMAT_INT64;
    values[3].u.int64 = -1;
    for (int i = 3; i < old->num; i++)
        values[i + 1] = old->values[i];
    rewritten.num = old->num + 1;
    rewritten.values = values;
    args->u.list = &rewritten;
    if (async)
        *rc = real_command_node_async(ctx, reply, args);
    else
        *rc = real_command_node(ctx, args, result);
    *args = saved;
    free(values);
}

int mpv_command_node(mpv_handle *ctx, mpv_node *args, mpv_node *result) {
    if (!real_command_node)
        resolve();
    if (needs_index(args)) {
        int rc = 0;
        call_rewritten(ctx, args, result, 0, 0, &rc);
        return rc;
    }
    return real_command_node(ctx, args, result);
}

int mpv_command_node_async(mpv_handle *ctx, uint64_t reply_userdata, mpv_node *args) {
    if (!real_command_node_async)
        resolve();
    if (needs_index(args)) {
        int rc = 0;
        call_rewritten(ctx, args, NULL, 1, reply_userdata, &rc);
        return rc;
    }
    return real_command_node_async(ctx, reply_userdata, args);
}

static int rewrite_hwdec(mpv_handle *ctx, const char *name, mpv_format format, void *data,
                         int async, uint64_t reply) {
    if (name && data && format == MPV_FORMAT_STRING && strcmp(name, "hwdec") == 0) {
        char **value = data;
        if (value && *value && strcmp(*value, "auto") == 0) {
            char *copy = "auto-copy";
            if (async)
                return real_set_property_async(ctx, reply, name, format, &copy);
            return real_set_property(ctx, name, format, &copy);
        }
    }
    if (async)
        return real_set_property_async(ctx, reply, name, format, data);
    return real_set_property(ctx, name, format, data);
}

int mpv_set_property(mpv_handle *ctx, const char *name, mpv_format format, void *data) {
    if (!real_set_property)
        resolve();
    return rewrite_hwdec(ctx, name, format, data, 0, 0);
}

int mpv_set_property_async(mpv_handle *ctx, uint64_t reply_userdata, const char *name,
                           mpv_format format, void *data) {
    if (!real_set_property_async)
        resolve();
    return rewrite_hwdec(ctx, name, format, data, 1, reply_userdata);
}

sudo gcc -shared -fPIC -O2 -o /usr/local/lib/libjmp-mpv-loadfile.so /tmp/jmp-mpv-loadfile.c -ldl
sudo tee /usr/local/bin/jellyfinmediaplayer >/dev/null << 'EOF'
#!/bin/bash
export LD_PRELOAD="/usr/local/lib/libjmp-mpv-loadfile.so${LD_PRELOAD:+:$LD_PRELOAD}"
exec /usr/bin/jellyfinmediaplayer "$@"
EOF
sudo chmod 755 /usr/local/bin/jellyfinmediaplayer

Start the player through /usr/local/bin/jellyfinmediaplayer so the shim is loaded. Starting /usr/bin/jellyfinmediaplayer directly skips it. Without the shim, a loadfile probe returns loadfile_rc=-4 (invalid parameter). With LD_PRELOAD it returns loadfile_rc=0 and event=playback-restart.

Confirm the running player actually loaded the library:

grep libjmp-mpv-loadfile /proc/$(pgrep -n -f jellyfinmediaplayer)/maps

Player config

File: ~/.local/share/jellyfinmediaplayer/jellyfinmediaplayer.conf. The player reads it at launch. Editing it while the player is running does nothing until the process is restarted.

Section video:

• hardwareDecoding: enabled
• Every force-transcode flag false, including force_transcode_4k, force_transcode_hevc, force_transcode_hi10p, force_transcode_hdr, force_transcode_av1, and force_transcode_dovi
• allow_transcode_to_hevc and prefer_transcode_to_h265 false

Section main: layout = tv, fullscreen = true, enableMPV = true, userWebClient = http://127.0.0.1:8096.

Section audio: devicetype = hdmi, every passthrough flag false. A car head unit wants normal PCM. Bitstream passthrough is how you get silence. The web client’s saved volume key is 1 (100%).

The autostart script uses exec, so killing the player does not relaunch it. Start it again inside the logged-in session, through the wrapper. id -u car is the uid to put in the runtime path. A kill -9 is safer than a normal quit if you just wrote the config, because a graceful quit can save the old in-memory settings back over the file.

sudo -u car env \
  DISPLAY=:0 \
  WAYLAND_DISPLAY=wayland-0 \
  XDG_RUNTIME_DIR=/run/user/$(id -u car) \
  DBUS_SESSION_BUS_ADDRESS=unix:path=/run/user/$(id -u car)/bus \
  /usr/local/bin/jellyfinmediaplayer --fullscreen --tv

Checks Before You Call It Done

curl -sf http://127.0.0.1:8096/health
systemctl is-active jellyfin smbd
systemctl is-enabled systemd-networkd-wait-online.service NetworkManager-wait-online.service
pgrep -a -f jellyfinmediaplayer
sudo -u jellyfin find /srv/media -type f ! -readable -print
vainfo | head -40
amixer -c 0 sget Master
wpctl settings device.routes.default-sink-volume

Run the find from /tmp. You want:

• Healthy
• jellyfin and smbd active
• systemd-networkd-wait-online masked, NetworkManager-wait-online disabled
• A process line of jellyfinmediaplayer --fullscreen --tv once HDMI is connected, and libjmp-mpv-loadfile.so in that process’s maps
• No unreadable files
• VA-API profiles that include H.264 decode, and HEVC Main if you want 8-bit HEVC in hardware
• Master at 100%
• device.routes.default-sink-volume saved at 1.0
• With the screen connected, wpctl get-volume @DEFAULT_AUDIO_SINK@ prints Volume: 1.00

Play one known-good H.264 file (720p, AAC is the safe shape) and confirm the Jellyfin dashboard playback session says Direct Play, not Transcode. If FFmpeg logs an exit code, read the failure table in the playback section before changing drivers.

HDMI can be unplugged while you SSH. You will not see the picture until the car screen is connected, and the player process will be absent until then because the autostart script is waiting for a connected output.

Some of these small Intel PCs time out on the SSH banner from a Mac. Add -o IPQoS=none, and use your own account and the address your router shows. A single timeout does not mean the PC is off. Ping, then try again.

Questions People Ask About a Car Jellyfin Box

Will this Jellyfin box work with a Honda Odyssey rear screen?

It works when the Odyssey rear entertainment input is HDMI and the screen only receives picture and sound. The head unit does not click back at the PC, so Jellyfin Media Player has to already be fullscreen in TV mode when the screen comes up. This guide does not cover a specific Odyssey model year or a factory remote protocol.

Will this work with a Toyota Sienna rear entertainment system?

Same requirement as the Odyssey. If the Sienna rear screen, or a screen added in the vehicle, takes HDMI video and audio, the player, the libraries, and the boot path stay the same.

Can I use this with a generic car TV?

Yes. Any HDMI display in a car is the same job: video and audio out, no control channel back to the PC, power that disappears with the ignition, and no internet. Set the PC firmware to power on when AC returns, and let the autostart script wait until that HDMI output is connected.

Does the Jellyfin car box need internet?

No. Jellyfin serves the local player at http://127.0.0.1:8096. The guide masks the boot services that otherwise wait several minutes for a network that is not there. Metadata providers can use the internet later, when the box is home and online. Playback in the car does not.

Why is video transcoding turned off?

The minimum PC direct-plays H.264 at 720p or 1080p. It is not there to turn 10-bit 4K into a smooth 1080p stream. Remux stays on, audio transcoding stays on, and video transcoding stays off.

Why does a copied file fail to play in Jellyfin?

A Mac can save files over SMB as mode 700, and Jellyfin cannot open them. FFmpeg exits 243 with Permission denied. Windows uses the same share. The Samba settings unix extensions = no and force create mode = 0664 keep both Mac and Windows copies readable.

Why does Jellyfin Media Player freeze on the poster?

Current Ubuntu’s libmpv expects a playlist index on loadfile. The published player build may still call it the old way. The log line is Command loadfile: argument index has incompatible type. The preload shim inserts that index. FFmpeg never starts in this failure.

Which video formats play well on the minimum car PC?

H.264 High, 8-bit, yuv420p, 720p or 1080p, with AAC stereo. That is the format every PC in the minimum direct-plays, including a 6th-gen Intel NUC. 8-bit HEVC at 1080p also works when vainfo lists HEVC Main. 10-bit HEVC, 4K, HDR, and AV1 do not play well on the minimum. Re-encode those on another computer. Use text subtitles or none. Picture subtitles ask for a video transcode.