Raspberry Pi and Netflix: Building a 1080p60 Media Center with GPIO Control

Getting Netflix to run smoothly on a Raspberry Pi used to be a frustrating exercise in DRM bypasses and software decoding. In 2026, the landscape has changed. Thanks to native Widevine L3 DRM support in 64-bit Raspberry Pi OS and the hardware decoding capabilities of the Pi 5, you can now build a dedicated, 1080p60 Netflix media center that actually works. However, bridging the gap between a headless Linux box and a living room appliance requires precise hardware selection and GPIO integration for physical media controls.

The Verdict: Which Raspberry Pi for Netflix?

Do not waste time trying to force 1080p60 Netflix playback on older hardware. The decision comes down to memory headroom for Chromium and the RP1 southbridge's video pipeline. Here is the decision matrix to terminate your hardware search:

The Concrete Pick: Buy the Raspberry Pi 5 8GB. Netflix's web player in Chromium is notoriously memory-hungry. When you combine the 64-bit OS overhead, the Wayland compositor, and the browser's DRM decryption buffers, the 4GB models will eventually hit swap memory during long binge sessions, causing audio desync. The 8GB model eliminates this failure mode entirely.

Parts List and GPIO Pin Mapping

To make this feel like a real media center rather than a desktop PC, we are adding physical media controls (Play/Pause, Volume Up, Volume Down) using tactile switches wired directly to the Pi 5's GPIO header. The Pi 5 routes GPIO through the RP1 chip, but the physical pinout remains identical to the Pi 4.

Bill of Materials

• Compute: Raspberry Pi 5 (8GB)
• Power: Official Raspberry Pi 27W USB-C PD Power Supply (Do not use a generic phone charger; the Pi 5 will throttle USB current if it doesn't detect the 5A PD handshake)
• Thermal: Raspberry Pi Active Cooler
• Storage: 32GB+ MicroSD (A2 rated, e.g., SanDisk Extreme) or NVMe SSD via M.2 HAT
• Switches: 3x 12mm Tactile Pushbuttons
• Wiring: Female-to-female jumper wires

GPIO Pin Mapping Table

Software Configuration and IR Control Code

Flash Raspberry Pi OS (64-bit, Bookworm or newer) using the Raspberry Pi Imager. You must select the 64-bit version; Widevine DRM binaries are not provided for 32-bit ARM architectures by Google. Boot into the desktop environment (Wayland is default on Bookworm).

Install the required dependencies. Open a terminal and run:

sudo apt update
sudo apt install python3-gpiozero python3-rpi-lgpio python3-pynput chromium-browser
sudo apt install libwidevinecdm0

Note: python3-rpi-lgpio is mandatory for the Pi 5. The older RPi.GPIO library cannot communicate with the RP1 southbridge.

Complete GPIO Media Controller Script

This Python script listens for button presses on the GPIO pins and injects media key events into the OS, which Chromium will intercept to control Netflix. Save this as media_control.py.

import signal
import sys
from gpiozero import Button
from pynput.keyboard import Controller, Key
import logging

# Configure logging to track button presses and errors
logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(message)s')
keyboard = Controller()

# Pin definitions mapping to physical header
PIN_PLAY_PAUSE = 17
PIN_VOL_UP = 27
PIN_VOL_DOWN = 22

# Initialize buttons with internal pull-ups and hardware debounce
# bounce_time=0.02 prevents a single press from registering as multiple clicks
btn_play = Button(PIN_PLAY_PAUSE, pull_up=True, bounce_time=0.02)
btn_vol_up = Button(PIN_VOL_UP, pull_up=True, bounce_time=0.02)
btn_vol_down = Button(PIN_VOL_DOWN, pull_up=True, bounce_time=0.02)

def on_play_pause():
    logging.info('Play/Pause triggered')
    keyboard.press(Key.media_play_pause)
    keyboard.release(Key.media_play_pause)

def on_vol_up():
    logging.info('Volume Up triggered')
    keyboard.press(Key.media_volume_up)
    keyboard.release(Key.media_volume_up)

def on_vol_down():
    logging.info('Volume Down triggered')
    keyboard.press(Key.media_volume_down)
    keyboard.release(Key.media_volume_down)

# Assign hardware interrupt callbacks
btn_play.when_pressed = on_play_pause
btn_vol_up.when_pressed = on_vol_up
btn_vol_down.when_pressed = on_vol_down

def signal_handler(sig, frame):
    logging.info('Shutting down media controller gracefully...')
    sys.exit(0)

# Catch Ctrl+C to prevent orphaned processes
signal.signal(signal.SIGINT, signal_handler)

if __name__ == '__main__':
    logging.info('Raspberry Pi Netflix Media Controller Active. Awaiting input...')
    # Keep the main thread alive without consuming CPU cycles
    signal.pause()

Run the script in the background: python3 media_control.py &. Open Chromium, navigate to Netflix, log in, and start a stream. Your physical buttons will now control playback.

Debugging DRM and Playback Errors

When building a Raspberry Pi and Netflix setup, you will likely hit one of three specific errors. Here is the exact troubleshooting path.

1. The DRM Failure

Exact Error String: Netflix is not supported on this device. (Error Code: F7355) or Widevine DRM plugin missing or unsupported.

• Cause A (Most Likely): You flashed the 32-bit version of Raspberry Pi OS. Widevine L3 is only compiled for aarch64.
• Cause B: The libwidevinecdm0 package failed to install or is outdated.
• Fix: Re-flash the SD card with the 64-bit OS. If already on 64-bit, run sudo apt install --reinstall libwidevinecdm0 and restart Chromium.

2. The GPU Pipeline Crash

Exact Error String: [ERROR:gl_surface_egl.cc(804)] Failed to create EGL surface followed by a black screen or Chromium GPU process crashed.

• Cause A: Wayland compositor conflict. Chromium's Ozone platform defaults can clash with the Pi 5's VideoCore VII driver under Wayland.
• Cause B: Hardware acceleration was accidentally disabled in chrome://flags.
• Fix: Launch Chromium from the terminal with explicit Wayland flags: chromium-browser --enable-features=UseOzonePlatform --ozone-platform=wayland. Ensure 'Hardware-accelerated video decode' is Enabled in chrome://flags.

3. The GPIO Pin Factory Error

Exact Error String: gpiozero.exc.BadPinFactory: Unable to load any default pin factory!

• Cause: The script is trying to use the legacy RPi.GPIO library, which is incompatible with the Pi 5's RP1 chip.
• Fix: Install the lgpio backend: sudo apt install python3-rpi-lgpio. The gpiozero library will automatically detect and switch to the lgpio pin factory upon the next execution.

Extending and Simplifying the Build

Once the baseline GPIO media controller is stable, you have two paths depending on your tolerance for hardware tinkering versus software configuration.

How to Simplify (The No-Solder Route)

If wiring tactile switches feels like overkill, drop the GPIO script entirely. Purchase a Flirc USB IR Receiver (~$20 USD). It presents itself to the Pi as a standard USB HID keyboard. You map your existing TV remote's IR signals to media keys using the Flirc desktop app, and plug it into the Pi. It bypasses the need for Python scripts, GPIO permissions, and pynput entirely, shifting the complexity to a dedicated microcontroller inside the dongle.

How to Extend (The HDMI-CEC Route)

To make the Pi behave exactly like a Roku or Apple TV—where turning on the Pi automatically turns on your TV and switches the HDMI input—you need to implement HDMI-CEC.

1. Install the CEC utilities: sudo apt install cec-utils
2. Test the connection: echo 'scan' | cec-client -s -d 1. This will list all devices on your TV's HDMI bus.
3. Add a one-touch play command to your Python script's initialization block: os.system('echo "on 0" | cec-client -s -d 1'). This sends the CEC opcode to power on the TV (Device 0) when your Python script launches.

Building a dedicated Raspberry Pi and Netflix box requires respecting the hardware limitations of ARM-based DRM and the specific quirks of the Pi 5's RP1 I/O controller. By selecting the 8GB model, enforcing a 64-bit Wayland environment, and using lgpio for physical controls, you eliminate the software stuttering that plagues lesser configurations.