NixOS Wiki

Jellyfin: Difference between revisions

← Older edit
VisualWikitext
EyJhb (talk | contribs)
3 edits
m Clarified intro-skipper plugin.
Layer-09 (talk | contribs)
175 edits
Manual compliance
 
Line 1: Line 1:
[https://jellyfin.org/ Jellyfin] is an open source media server (Jellyfin Server) with several clients (Jellyfin Media Player and web client).
<languages/>


== Installation and configuration ==
{{infobox application
  |name=Jellyfin
  |image=Jelly-banner-light.svg
  |type=Media server
  |developer=Jellyfin Project
  |license=[https://www.gnu.org/licenses/gpl-2.0.html GPL-2.0]
  |os=Cross-platform (Linux, macOS, Windows)
  |platform=Server
  |programmingLanguage=C#
  |website=[https://jellyfin.org/ jellyfin.org]
  |github=jellyfin/jellyfin
  |bugTracker=[https://github.com/jellyfin/jellyfin/issues GitHub Issues]
  |documentation=[https://jellyfin.org/docs/ jellyfin.org/docs]
}}
<translate>
<!--T:1-->
<strong>[https://jellyfin.org/ Jellyfin]</strong><ref name="jellyfin">Jellyfin Project, "Jellyfin: The Free Software Media System", Official Website, Accessed October 2025. https://jellyfin.org/</ref> is a free and open-source media server that enables users to manage and stream their personal media libraries across various devices. It consists of the Jellyfin Server and multiple client applications including Jellyfin Media Player and a web interface.


To get up and running with Jellyfin, add the packages <code>pkgs.jellyfin</code> <code>pkgs.jellyfin-web</code> & <code>pkgs.jellyfin-ffmpeg</code> to your `configuration.nix` file as shown below.
== Installation == <!--T:2-->


<syntaxHighlight lang=nix>
<!--T:3-->
{
To enable Jellyfin on NixOS, add the service configuration to your <code>/etc/nixos/configuration.nix</code> file:
</translate>
 
{{code|lang=nix|line=no|1={
   services.jellyfin.enable = true;
   services.jellyfin.enable = true;
   environment.systemPackages = [
   environment.systemPackages = [
Line 14: Line 33:
   ];
   ];
}
}
</syntaxHighlight>
}}
 
<translate>
If you want more advanced configuration, use something like what's shown below and [https://search.nixos.org/options?query=jellyfin see the docs for more configuration options]
<!--T:4-->
For more advanced configuration options, refer to the [https://search.nixos.org/options?query=jellyfin NixOS options documentation]:<ref name="nixos-options">NixOS Wiki contributors, "Jellyfin NixOS module options", NixOS Search, Accessed October 2025. https://search.nixos.org/options?query=jellyfin</ref>
</translate>


<syntaxHighlight lang=nix>
{{code|lang=nix|line=no|1={
{
   services.jellyfin = {
   services.jellyfin = {
     enable = true;
     enable = true;
Line 25: Line 45:
   };
   };
}
}
</syntaxHighlight>
}}
<translate>
<!--T:5-->
After configuring Jellyfin, rebuild your system for the changes to take effect:
</translate>
{{code|lang=bash|line=no|$ sudo nixos-rebuild switch}}
<translate>
<!--T:6-->
After the rebuild completes, verify that Jellyfin is running:
</translate>
{{code|lang=bash|line=no|$ sudo systemctl status jellyfin}}
<translate>
<!--T:7-->
If Jellyfin is not running, you can start it manually:
</translate>
{{code|lang=bash|line=no|$ jellyfin}}
<translate>
<!--T:8-->
Once Jellyfin is running, you can access the web interface:


Once you have included the packages to be installed, and enabled and configured Jellyfin to your liking, then rebuild your system for changes to take effect.
<!--T:9-->
<syntaxHighlight lang=bash>$ sudo nixos-rebuild switch</syntaxHighlight>
* The Jellyfin server runs on port 8096 by default.<ref name="jellyfin-ports">Jellyfin Documentation Team, "Networking", Jellyfin Documentation, Accessed October 2025. https://jellyfin.org/docs/general/networking/</ref>
* Navigate to <code>http://localhost:8096</code> for local access.
* For remote access, replace <code>localhost</code> with the server's IP address.


After the rebuild is complete, Jellyfin should be running. Verify that it is with the following command.
== Configuration == <!--T:10-->
<syntaxHighlight lang=bash>$ sudo systemctl status jellyfin</syntaxHighlight>


If jellyfin is not running you should be able to start it by running <code>jellyfin</code> in your terminal.
=== Allowing access to external drives === <!--T:11-->
<syntaxHighlight lang=bash>$ jellyfin</syntaxHighlight>


After you've verified that Jellyfin is running you can start the configuration process.
<!--T:12-->
* The Jellyfin server should be running on port 8096.
Desktop environments typically mount external drives for the current user, while Jellyfin runs as the system user <code>jellyfin</code> by default. This can cause permission issues when accessing external media.
* Go to http://localhost:8096 if you are setting this up on your primary computer or want to test your build locally.
* If you're logging into a remote server, replace localhost with the ip address of the server.


=== Allow Jellyfin to read external drives ===
<!--T:13-->
The simplest solution is to change the service user:
</translate>


You might encounter permission issues when you try to access external drives if you haven't configured anything else with the server yet. If you haven't explicitly set up a mounting configuration for your drives and instead let your desktop environment (e.g. GNOME or KDE) automatically mount it when you try accessing it via their file explorers, Jellyfin won't be able to access the drive. This is because the desktop environment mounts it to your user, while Jellyfin runs by default as the "jellyfin" user.
{{code|lang=nix|line=no|1={
 
The easiest way to allow it to see these external drives is to change the service's user . Here is an example:
<syntaxhighlight lang="nix">
   services.jellyfin = {
   services.jellyfin = {
     enable = true;
     enable = true;
     openFirewall = true;
     openFirewall = true;
     user="yourusername";
     user = "yourusername";
   };
   };
</syntaxhighlight>
}
 
}}
If you have changed the user option after you have already installed Jellyfin, you have to change the ownership of the folder `/var/lib/jellyfin` to the user you set it to by doing this:
<translate>
 
<!--T:14-->
<syntaxhighlight lang="bash">
If you change the user after Jellyfin is already installed, update the ownership of the data and cache directories:
  sudo chown -R yourusername:yourusername /var/lib/jellyfin
</translate>
</syntaxhighlight>
 
Additionally, you should also change the ownership of the cache directory to avoid transcoding issues:
 
<syntaxhighlight lang="bash">
  sudo chown -R yourusername:yourusername /var/cache/jellyfin
</syntaxhighlight>
 
Finally, restart Jellyfin for the changes to take effect:
 
<syntaxhighlight lang="bash">
  systemctl restart jellyfin
</syntaxhighlight>
 
The alternative is to explicitly mount the drives via [[Filesystems]]. This takes more effort to set up and requires every new drive to be explicitly declared, but allows more control in what Jellyfin is allowed to see.
 
=== Intro Skipper plugin ===
The below no longer seems to required, and if the latest version from https://github.com/intro-skipper/intro-skipper is used, then it should just work. Tested with jellyfin web, jellyfin media player and jellyfin on Android TV.
 
<s>If you install the Intro Skipper plugin, it will not be able to display the skip button in the web interface. This is due to the plugin being unable to modify contents of files in the nix store. To get around this you can make the changes yourself with this:</s>
<syntaxhighlight lang="nix">
  nixpkgs.overlays = with pkgs; [
    (
      final: prev:
        {
          jellyfin-web = prev.jellyfin-web.overrideAttrs (finalAttrs: previousAttrs: {
            installPhase = ''
              runHook preInstall


              # this is the important line
{{code|lang=bash|line=no|$ sudo chown -R yourusername:yourusername /var/lib/jellyfin
              sed -i "s#</head>#<script src=\"configurationpage?name=skip-intro-button.js\"></script></head>#" dist/index.html
$ sudo chown -R yourusername:yourusername /var/cache/jellyfin}}
<translate>
<!--T:15-->
Then restart the service:
</translate>


              mkdir -p $out/share
{{code|lang=bash|line=no|$ sudo systemctl restart jellyfin}}
              cp -a dist $out/share/jellyfin-web
<translate>
<!--T:16-->
Alternatively, configure explicit mounts via [[Filesystems]]. This approach requires more setup and each drive must be declared, but provides finer control over what Jellyfin can access.


              runHook postInstall
=== Hardware transcoding === <!--T:17-->
            '';
          });
        }
    )
  ];


</syntaxhighlight>
<!--T:18-->
Modern hardware often includes video acceleration capabilities that can significantly reduce CPU usage during transcoding. For detailed information, see the [https://jellyfin.org/docs/general/post-install/transcoding/hardware-acceleration/ official Jellyfin documentation].<ref name="jellyfin-hw">Jellyfin Documentation Team, "Hardware acceleration", Jellyfin Documentation, Accessed October 2025. https://jellyfin.org/docs/general/post-install/transcoding/hardware-acceleration/</ref>


== Hardware transcoding ==
==== VAAPI and Intel QSV ==== <!--T:19-->
In most cases you want to make most of your hardware. Modern boards often come with a hardware accelerator, all you need to do is enable it!


Source: https://jellyfin.org/docs/general/post-install/transcoding/hardware-acceleration/
<!--T:20-->
Intel GPUs support Video Acceleration API (VAAPI) and Quick Sync Video (QSV). The required packages must be added to <code>hardware.graphics.extraPackages</code>.


=== VAAPI and Intel QSV ===
<!--T:21-->
Choose the appropriate driver based on your CPU generation:
* <code>intel-vaapi-driver</code> for pre-Broadwell CPUs
* <code>intel-media-driver</code> for Broadwell and newer
* <code>intel-compute-runtime</code> for newer processors
</translate>
{{Note|<code>intel-media-sdk</code> is deprecated and does not build on recent channels. Use VAAPI with <code>intel-media-driver</code> instead. See [https://discourse.nixos.org/t/intel-media-sdk-has-become-deprecated/66998 this discussion] for details.<ref name="intel-media-sdk">smana, "intel-media-sdk has become deprecated", NixOS Discourse, Accessed October 2025. https://discourse.nixos.org/t/intel-media-sdk-has-become-deprecated/66998</ref>}}


VAAPI and QSV is often available on platforms with Intel GPUs but need their corresponding packages in <code>hardware.graphics.extraPackages</code>.
{{code|lang=nix|line=no|1=
 
{ pkgs, lib, config, ... }:
You have to choose between <code>intel-vaapi-driver</code> (old driver for pre-Broadwell CPUs), <code>intel-compute-runtime</code> and <code>intel-media-driver</code> depending of your CPU.
{{Note|<code>intel-media-sdk</code> is deprecated and currently (as of 2025-09-05) does not build on unstable channel. Instead of QSV use VAAPI for hardware acceleration in the jellyfin settings.<br/>Source: https://discourse.nixos.org/t/intel-media-sdk-has-become-deprecated/66998}}<syntaxhighlight lang="nix">
{ pkgs, lib,config, ... }:
{
{
   # Only set this if you're using intel-vaapi-driver (see below):
   # Only set this if using intel-vaapi-driver:
   nixpkgs.config.packageOverrides = pkgs: {
   nixpkgs.config.packageOverrides = pkgs: {
     intel-vaapi-driver = pkgs.intel-vaapi-driver.override { enableHybridCodec = true; };
     intel-vaapi-driver = pkgs.intel-vaapi-driver.override { enableHybridCodec = true; };
   };
   };


   systemd.services.jellyfin.environment.LIBVA_DRIVER_NAME = "iHD"; # or i965, see below
   systemd.services.jellyfin.environment.LIBVA_DRIVER_NAME = "iHD"; # or i965 for older GPUs
   environment.sessionVariables = { LIBVA_DRIVER_NAME = "iHD"; }; # ditto
   environment.sessionVariables = { LIBVA_DRIVER_NAME = "iHD"; };
 
 
   hardware.graphics = {
   hardware.graphics = {
     enable = true;
     enable = true;


     extraPackages = with pkgs; [
     extraPackages = with pkgs; [
       intel-ocl # generic OpenCL support, for all processors
       intel-ocl # Generic OpenCL support


       # For newer processors (Broadwell and higher, ca. 2014), use this paired with `LIBVA_DRIVER_NAME=iHD`:
       # For Broadwell and newer (ca. 2014+), use with LIBVA_DRIVER_NAME=iHD:
       intel-media-driver
       intel-media-driver


       # ... while for older processors, use these paired with `LIBVA_DRIVER_NAME=i965`:
       # For older processors, use with LIBVA_DRIVER_NAME=i965:
       intel-vaapi-driver  
       intel-vaapi-driver
       libva-vdpau-driver # aka vaapiVdpau
       libva-vdpau-driver


       # In addition, for newer processors (13th gen and higher), add this as well:
       # For 13th gen and newer:
       intel-compute-runtime
       intel-compute-runtime
     
      #  ... while for older processors, add this (https://github.com/NixOS/nixpkgs/issues/356535):
      intel-compute-runtime-legacy1


       # In addition once more, for newer processors (11th gen or newer), add this:
       # For older processors:
      intel-compute-runtime-legacy1
 
      # For 11th gen and newer:
       vpl-gpu-rt
       vpl-gpu-rt


       # ... while for older processors, add this:
       # Deprecated (may not build on recent channels):
       intel-media-sdk # (note it's been deprecated since NixOS 25.11 and may not build anymore nowadays)
       # intel-media-sdk
     ];
     ];
   };
   };


  # Of course, do not forget to enable Jellyfin:
   services.jellyfin.enable = true;
   services.jellyfin.enable = true;
}
}
</syntaxhighlight>
}}
<translate>
==== Troubleshooting VAAPI and Intel QSV ==== <!--T:22-->


==== Troubleshooting VAAPI and Intel QSV ====
<!--T:23-->
You can check supported vaapi profile supported by your CPU / driver with : <code>nix-shell -p libva-utils --run vainfo</code>.
Check supported VAAPI profiles:
</translate>


You can check the OpenCL properties and devices available on the system with : <code>nix-shell -p clinfo --run clinfo</code>. If clinfo shows <code>Number of platforms 0</code> on the first line, OpenCL is not enabled or available.
{{code|lang=bash|line=no|$ nix-shell -p libva-utils --run vainfo}}
<translate>
<!--T:24-->
Verify OpenCL availability:
</translate>


The command <code>intel_gpu_top</code>, provided by the <code>intel-gpu-tools</code> package is also useful to check the status of your intel GPU: <code>nix-shell -p intel-gpu-tools --run intel_gpu_top</code>.
{{code|lang=bash|line=no|$ nix-shell -p clinfo --run clinfo}}
<translate>
<!--T:25-->
If <code>clinfo</code> shows <code>Number of platforms 0</code>, OpenCL is not enabled or available.


At least on Intel N100 CPU, you will need the option <code>hardware.enableAllFirmware = true;</code> otherwise GuC formware will not load properly. Here is the type of error you will get without it : <syntaxhighlight lang="dmesg">
<!--T:26-->
[    4.174843] i915 0000:00:10.0: [drm] *ERROR* GT0: GuC firmware i915/tgl_guc_70.bin: fetch failed -ENOENT
Monitor Intel GPU status:
</translate>
 
{{code|lang=bash|line=no|$ nix-shell -p intel-gpu-tools --run intel_gpu_top}}
<translate>
<!--T:27-->
On Intel N100 CPUs, enable firmware loading to prevent GuC errors:
</translate>
 
{{code|lang=nix|line=no|1={
  hardware.enableAllFirmware = true;
}
}}
<translate>
<!--T:28-->
Without this option, you may see errors like:
</translate>
 
{{code|lang=text|line=no|[    4.174843] i915 0000:00:10.0: [drm] *ERROR* GT0: GuC firmware i915/tgl_guc_70.bin: fetch failed -ENOENT
[    4.175621] i915 0000:00:10.0: [drm] GT0: GuC firmware(s) can be downloaded from https://git.kernel.org/pub/scm/linux/kernel/git/firmware/linux-firmware.git/tree/i915
[    4.175621] i915 0000:00:10.0: [drm] GT0: GuC firmware(s) can be downloaded from https://git.kernel.org/pub/scm/linux/kernel/git/firmware/linux-firmware.git/tree/i915
[    4.176286] i915 0000:00:10.0: [drm] GT0: GuC firmware i915/tgl_guc_70.bin version 0.0.0
[    4.176350] i915 0000:00:10.0: [drm] *ERROR* GT0: GuC initialization failed -ENOENT
[    4.176350] i915 0000:00:10.0: [drm] *ERROR* GT0: GuC initialization failed -ENOENT
[    4.176977] i915 0000:00:10.0: [drm] *ERROR* GT0: Enabling uc failed (-5)
[    4.176977] i915 0000:00:10.0: [drm] *ERROR* GT0: Enabling uc failed (-5)
[    4.177502] i915 0000:00:10.0: [drm] *ERROR* GT0: Failed to initialize GPU, declaring it wedged!
[    4.177502] i915 0000:00:10.0: [drm] *ERROR* GT0: Failed to initialize GPU, declaring it wedged!}}
</syntaxhighlight>
<translate>
==== VAAPI and Intel QSV on Arc GPU ==== <!--T:29-->


==== VAAPI and Intel QSV on Arc GPU ====
<!--T:30-->
Arc GPUs require Jellyfin to use FFmpeg compiled with <code>vpl</code> support. Use [[Overlays|an overlay]] to override the FFmpeg configuration:
</translate>


If you want to use an Arc GPU for transcoding, you may need to override the ffmpeg version used by jellyfin to ensure that it is compiled with <code>vpl</code> and, potentially, <code>unfree</code>. An example to achieve this through [[Overlays|an overlay]]:<syntaxhighlight lang="nix">
{{code|lang=nix|line=no|1=
{ pkgs, ... }:
{ pkgs, ... }:
let
let
   jellyfin-ffmpeg-overlay = (
   jellyfin-ffmpeg-overlay = (final: prev: {
    _ prev: {
    jellyfin-ffmpeg = prev.jellyfin-ffmpeg.override {
      jellyfin-ffmpeg = prev.jellyfin-ffmpeg.override {
      # Exact version depends on jellyfin-ffmpeg package
        # Exact version of ffmpeg_* depends on what jellyfin-ffmpeg package is using.
      # In 24.11 it's ffmpeg_7-full
        # In 24.11 it's ffmpeg_7-full.
      ffmpeg_7-full = prev.ffmpeg_7-full.override {
        # See jellyfin-ffmpeg package source for details
        withMfx = false; # Older media driver
        ffmpeg_7-full = prev.ffmpeg_7-full.override {
        withVpl = true; # New driver for Arc GPUs
          withMfx = false; # This corresponds to the older media driver
        withUnfree = true;
          withVpl = true; # This is the new driver
          withUnfree = true;
        };
       };
       };
     }
     };
   );
   });
in
in
{
{
   nixpkgs.overlays = [ jellyfin-ffmpeg-overlay ];
   nixpkgs.overlays = [ jellyfin-ffmpeg-overlay ];
}
}
</syntaxhighlight>This will trigger a rebuild of Jellyfin package, but the end result is that if you select "Intel QuickSync (QSV)" you should see little to no CPU load when transcoding.
}}
 
<translate>
Note that if your system has an integrated GPU (one built into the CPU) and a discrete GPU, you may need to select the QSV device in the "Playback" settings. Otherwise the device may be picked at random and produce random results. You can use <code>intel_gpu_top -L</code> to identify the devices.
<!--T:31-->
 
This triggers a rebuild of the Jellyfin package. After applying, select "Intel QuickSync (QSV)" in the Jellyfin settings for hardware-accelerated transcoding with minimal CPU load.
Related: [[Accelerated Video Playback]] and [[Intel Graphics]]


==== VAAPI with Jellyfin in a NixOS Container ====
<!--T:32-->
If your system has both integrated and discrete GPUs, manually select the QSV device in the Playback settings to avoid random device selection. Use <code>intel_gpu_top -L</code> to list available devices.


Containers don't inherit graphic drivers from their root system, so if you run Jellyfin in a NixOS container, you have to copy the <code>hardware.graphics</code> block from the main configuration into your container's configuration.
==== VAAPI with Jellyfin in a NixOS container ==== <!--T:33-->


You have to passthrough the graphics card device as well - usually it's located under <code>/dev/dri/card0</code> and/or <code>/dev/dri/renderD128</code>:
<!--T:34-->
Containers do not inherit graphics drivers from the host system. When running Jellyfin in a NixOS container, replicate the <code>hardware.graphics</code> configuration and pass through the GPU devices (typically <code>/dev/dri/card0</code> and <code>/dev/dri/renderD128</code>):
</translate>


<syntaxHighlight lang="nix">
{{code|lang=nix|line=no|1=
{
{
   allowedDevices = [
   allowedDevices = [
     {
     { node = "/dev/dri/card0"; modifier = "rw"; }
      node = "/dev/dri/card0";
     { node = "/dev/dri/renderD128"; modifier = "rw"; }
      modifier = "rw";
    }
     {
      node = "/dev/dri/renderD128";
      modifier = "rw";
    }
   ];
   ];


Line 224: Line 258:
       isReadOnly = false;
       isReadOnly = false;
     };
     };
     "/dev/dri/renderD128" = {
     "/dev/dri/renderD128" = {
       hostPath = "/dev/dri/renderD128";
       hostPath = "/dev/dri/renderD128";
Line 231: Line 264:
   };
   };


   config =
   config = {
  # ... your container's configuration, including the hardware.graphics part!
    # Include hardware.graphics and services.jellyfin configuration
  };
}
}
</syntaxHighlight>
}}
<translate>
<!--T:35-->
Verify the configuration by adding <code>libva-utils</code> to the container's <code>environment.systemPackages</code>, logging in with <code>machinectl shell container-name</code>, and running <code>vainfo</code>. Successful output looks like:
</translate>
 
{{code|lang=text|line=no|Trying display: drm
libva info: VA-API version 1.22.0
libva info: Trying to open /run/opengl-driver/lib/dri/iHD_drv_video.so
libva info: Found init function __vaDriverInit_1_22
libva info: va_openDriver() returns 0
vainfo: VA-API version: 1.22 (libva 2.22.0)
vainfo: Driver version: Intel iHD driver for Intel(R) Gen Graphics - 25.2.6 ()
vainfo: Supported profile and entrypoints
      VAProfileNone                  : VAEntrypointVideoProc
      VAProfileNone                  : VAEntrypointStats
      /* Additional profiles depend on your hardware */}}
<translate>
<!--T:36-->
With correct configuration, FFmpeg and Jellyfin can use hardware transcoding.
 
== Tips and tricks == <!--T:37-->
 
=== Intro Skipper plugin === <!--T:38-->
 
<!--T:39-->
The latest version of the Intro Skipper plugin from [https://github.com/intro-skipper/intro-skipper GitHub]<ref name="intro-skipper">Intro Skipper contributors, "Intro Skipper Jellyfin plugin", GitHub, Accessed October 2025. https://github.com/intro-skipper/intro-skipper</ref> works without manual patches on Jellyfin web, Jellyfin Media Player, and Android TV clients.
 
<!--T:40-->
If you need to manually patch the web interface for older versions, use an overlay:
</translate>
 
{{code|lang=nix|line=no|1=
nixpkgs.overlays = [
  (final: prev: {
    jellyfin-web = prev.jellyfin-web.overrideAttrs (finalAttrs: previousAttrs: {
      installPhase = ''
        runHook preInstall
        sed -i "s#</head>#<script src=\"configurationpage?name=skip-intro-button.js\"></script></head>#" dist/index.html
        mkdir -p $out/share
        cp -a dist $out/share/jellyfin-web
        runHook postInstall
      '';
    });
  })
];
}
}}
<translate>
== Troubleshooting == <!--T:41-->
 
=== Service not starting === <!--T:42-->
 
<!--T:43-->
If Jellyfin fails to start, check the service status:
 
{{code|lang=bash|line=no|$ sudo systemctl status jellyfin}}
 
<!--T:44-->
Review the service logs for error messages:
</translate>
 
{{code|lang=bash|line=no|$ sudo journalctl -u jellyfin -n 50}}
<translate>
=== Cannot access media files === <!--T:45-->
 
<!--T:46-->
Verify that the Jellyfin user has read permissions for your media directories. Check file ownership and permissions:
</translate>
 
{{code|lang=bash|line=no|$ ls -la /path/to/media}}
<translate>
<!--T:47-->
If using a custom user for the Jellyfin service, ensure the data directories have correct ownership as described in the configuration section.
 
== See also == <!--T:48-->


You can check if you got the configuration correct by adding <code>libva-utils</code> to the container's <code>environment.systemPackages</code>, logging into the container (<code>machinectl shell container-name</code>), and running <code>vainfo</code> - if you got everything right, you should see something akin to:
<!--T:49-->
* [[Filesystems]] – Declarative filesystem mounting on NixOS
* [[Accelerated Video Playback]] – GPU acceleration configuration
* [[Intel Graphics]] – Intel GPU driver setup
* [[Overlays]] – Customizing packages with overlays
* [https://search.nixos.org/options?query=jellyfin NixOS options search] – Jellyfin module options
* [https://jellyfin.org/docs/ Jellyfin documentation] – Official Jellyfin documentation


<syntaxHighlight>
== References == <!--T:50-->
Trying display: drm                                                                                                                                                                             
</translate>
libva info: VA-API version 1.22.0                                                                                                                                                               
libva info: Trying to open /run/opengl-driver/lib/dri/iHD_drv_video.so                                                                                                                           
libva info: Found init function __vaDriverInit_1_22                                                                                                                                             
libva info: va_openDriver() returns 0                                                                                                                                                           
vainfo: VA-API version: 1.22 (libva 2.22.0)                                                                                                                                                     
vainfo: Driver version: Intel iHD driver for Intel(R) Gen Graphics - 25.2.6 ()                                                                                                                   
vainfo: Supported profile and entrypoints                                                                                                                                                       
      VAProfileNone                  : VAEntrypointVideoProc                                                                                                                                   
      VAProfileNone                  : VAEntrypointStats     
      /* and many more, the list depends on your specific hardware */                                                                                                                                 
</syntaxHighlight>


With that, ffmpeg (and thus Jellyfin) should be able to use hardware transcoding.
<references/>


[[Category:Server]]
[[Category:Server]]
[[Category:Applications]]
[[Category:Applications]]
[[Category:Web Applications]]
[[Category:Web Applications]]
Retrieved from "https://wiki.nixos.org/wiki/Jellyfin"