You have a collection of ripped movies and TV shows sitting on a NAS, but getting them to play smoothly on every device in your home feels like a constant battle. Your smart TV might handle one format, but your tablet chokes on another. The solution is a media server like Jellyfin, but building one that can handle the heavy lifting of video transcoding without breaking the bank is a puzzle many people face. After hearing good things about the Intel N100 processor, I decided to turn a sub-$200 system into a dedicated Jellyfin server. The result? A setup that handles multiple 4K streams with ease, thanks to the jellyfin intel quick sync combination. There is one small catch, but for the price, it is a fantastic compromise.
Why Hardware Transcoding Matters for Your Media Server
Unlike typical lightweight FOSS tools, a media server demands specific hardware to function well. You need terabytes of storage for your library, and you need processing power to convert video formats on the fly. This conversion process is called transcoding. Not every device in your household supports every codec. Your new phone might play HEVC files beautifully, but your older laptop might only handle H.264. Transcoding bridges that gap by converting the video into a format the client device can play.
Relying entirely on your CPU for transcoding is a recipe for frustration. When the processor gets overloaded, you will see frame drops, stuttering, and buffering. The video stream becomes unwatchable. This is where hardware-aided transcoding steps in. A dedicated graphics card or an integrated GPU with specific encoding features takes over the heavy lifting. It frees up the CPU for other tasks and delivers smooth playback across multiple streams simultaneously.
The Problem with Dedicated Graphics Cards
But here is the problem. PC hardware prices have been climbing. Finding a dedicated graphics card at a reasonable, non-scalped price is difficult. Even if you find one, you might already have your existing GPU dedicated to other tasks. In my case, I was already using my old graphics card for virtual machine experiments. I did not want to run Jellyfin inside that development VM, and I certainly did not want to buy another GPU just for transcoding.
That is when I looked into integrated graphics solutions. Modern Intel processors come with a feature called Quick Sync Video, which is a dedicated media processing core built right into the CPU die alongside the integrated GPU. It is designed specifically for encoding and decoding video. For a household that typically streams no more than three 4K videos at the same time, Quick Sync is the perfect alternative to a bulky, power-hungry graphics card. It handles moderate transcoding loads efficiently without the extra cost or space requirements.
Step 2: Setting Up Proxmox and the Jellyfin LXC
Switching gears to the practical side, I installed Proxmox Virtual Environment on the LattePanda Mu. Proxmox is a hypervisor that lets you run virtual machines and containers. I chose to run Jellyfin inside an LXC container rather than a full virtual machine. Containers are lightweight and share the host kernel, which makes GPU passthrough simpler.
Setting up the Jellyfin LXC was straightforward. I opened the Proxmox web interface, navigated to the Shell section of my PVE node, and executed a simple bash command. The command was:
bash -c "$(curl -fsSL https://raw.githubusercontent.com/community-scripts/ProxmoxVE/main/ct/jellyfin.sh)"
This script from the PVE Helper Scripts community downloads and configures Jellyfin automatically. Since I planned to pair this LXC with my NAS shares, I chose the default storage settings during the script prompts. I did not allocate extra storage space inside the container because all the media files would be mounted from the network.
Detecting the Intel iGPU
Better yet, the script immediately detected the Intel integrated GPU during installation. It began installing the necessary drivers alongside the Jellyfin packages. This automatic detection saved me from manually hunting down drivers and configuring kernel modules. After the script finished, the container was up and running with the iGPU ready for use.
Step 3: Enabling Intel Quick Sync in Jellyfin
Once the container was running, I signed into the Jellyfin web interface. The first task was to enable the hardware transcoding feature. I navigated to the Dashboard, then to the Playback section, and opened the Transcoding tab.
In the Transcoding settings, there is a dropdown menu labeled “Hardware acceleration.” I selected “Intel Quick Sync (QSV)” from the list. Below that, I checked the boxes for the codecs I wanted to accelerate: H.264, HEVC, and VC-1 encoding and decoding. I also enabled hardware encoding and decoding for MPEG-2. These settings tell Jellyfin to use the jellyfin intel quick sync pipeline whenever a transcode is needed.
After saving the settings, the server was configured to offload transcoding tasks to the iGPU. No additional driver installation or manual configuration was required inside the LXC. The PVE Helper Script had already handled the heavy lifting during the container creation process.
Step 4: Connecting to Network Shares with Bind Mounts
Here is where things got a little tricky. Proxmox has specific UID and GID mapping rules for unprivileged containers. An unprivileged LXC runs with a non-root user mapped to a high-numbered ID on the host. This security feature prevents the container from accessing host resources, but it also complicates mounting network shares.
My NAS uses SMB shares with standard user permissions. The Jellyfin LXC, being unprivileged, could not directly authenticate with the NAS using those credentials. The bind mount workaround solves this problem by connecting the underlying Proxmox host directly to the SMB share, then passing that mount point into the container.
Creating the Bind Mount
First, I mounted the SMB share on the Proxmox host. I created a directory at /mnt/nas-media and added the mount command to the host’s /etc/fstab file so it would persist across reboots. The fstab entry looked something like this:
//192.168.1.100/media /mnt/nas-media cifs credentials=/root/.smbcredentials,uid=100000,gid=100000,iocharset=utf8,noexec 0 0
The UID and GID values of 100000 correspond to the mapped root user inside an unprivileged container. This mapping ensures the container can read and write to the mounted files.
You may also enjoy reading: FreeCAD Tutorial for Beginners: 5 Clear Steps You’ll Like.
Next, I used the pct set command to add a bind mount to the Jellyfin LXC. The command was:
pct set 100 -mp0 /mnt/nas-media,mp=/media
This tells Proxmox to mount the host directory /mnt/nas-media inside the container at the path /media. After running this command, I restarted the container. Sure enough, the media files appeared inside the directory, and Jellyfin could access them.
Step 5: Adding Libraries and Testing Transcoding
With the network share accessible, I moved to the Jellyfin web interface. I went to the Library section and clicked “Add Media Library.” I selected the content type (Movies, TV Shows, etc.) and pointed the folder path to the mounted directory inside the container. For movies, I set the path to /media/Movies. For TV shows, it was /media/TV Shows.
Jellyfin began scanning the files and downloading metadata. The process took a while for a large library, but it ran smoothly in the background. Once the scan finished, I had a fully populated media library ready to stream.
Putting the Transcoding to the Test
Since I wanted to confirm whether the iGPU was actually handling the transcoding, I played a 4K HEVC video on a device that does not support that codec natively. I opened the playback settings and checked the “Play Method” indicator. Sure enough, modifying some playback settings resulted in the method switching to “Transcoding,” without causing any stuttering or dropped frames.
I then pushed the system harder. I started streaming three different 4K videos simultaneously to three separate devices. Each stream required transcoding because the target devices had different codec support. The N100 handled all three streams without breaking a sweat. The CPU usage remained low, and the iGPU handled the encoding workload efficiently. My budget-friendly setup is enough to drive several 4K streams at once.
The One Catch: Missing AV1 Decoding
There is one limitation to this setup. The Intel N100 processor supports hardware decoding for H.264, HEVC, VP9, and AV1. However, the Quick Sync unit on the N100 does not support hardware encoding for AV1. It can decode AV1 files, but it cannot re-encode them into another format using hardware acceleration. If you have a library of AV1-encoded videos and need to transcode them to a different format, the CPU will have to handle that task.
For most people, this is not a dealbreaker. AV1 is still relatively new, and most media libraries are still dominated by H.264 and HEVC. If your collection is mostly older codecs, the N100 will handle everything you throw at it. But if you are an early adopter with a large AV1 library, you might want to look at Intel’s 12th generation or newer processors, which include AV1 encoding support in their Quick Sync units.
Is the N100 Worth It for a Jellyfin Server?
Absolutely. For under $200, you get a system that can handle multiple 4K transcodes simultaneously. The power consumption is minimal, the noise level is nonexistent (fanless cases are an option), and the setup process is straightforward thanks to community scripts. The jellyfin intel quick sync pairing delivers performance that rivals a dedicated graphics card for a fraction of the cost and power draw.
The only real consideration is future-proofing. If you plan to build a library entirely in AV1, you might want to spend a little more on a newer processor. But for the vast majority of home media server users, the N100 is more than enough. It is a practical, affordable solution that brings the convenience of a commercial streaming service to your own media collection.
