Skip to main content

VPU Encoding with NETINT Quadra

This guide walks you through deploying a virtual machine with a NETINT Quadra VPU, installing the NETINT software stack, and running hardware-accelerated video encoding with FFmpeg. By the end, you will have a working VPU-powered transcoding pipeline.

Why VPU Over CPU Encoding?​

Software-based video encoding on CPUs is compute-intensive and does not scale efficiently. A single 4K HEVC transcode can saturate multiple CPU cores. VPUs are purpose-built ASICs that handle encoding and decoding in dedicated hardware, providing:

  • Higher throughput — a single Quadra T1A card can encode 64 simultaneous 1080p30 streams or 16 4Kp30 streams
  • Lower cost — offloading video processing frees CPU cores for application logic
  • Lower power — VPUs consume a fraction of the power required by equivalent CPU encoding

Prerequisites​

  • A NetActuate account with access to VPU-enabled locations
  • Familiarity with Linux command-line administration
  • Basic knowledge of FFmpeg

Step 1: Deploy a VM with a NETINT Quadra VPU​

Follow the standard VM deployment wizard at Infrastructure → Virtual Machines → + Add, with these accelerator-specific steps:

  1. On the CPU Type tab, toggle Include Accelerators and select VPU from the Category dropdown.
  2. Select a region and location that has VPU availability, then click Next.
  3. On the Billing tab, under Select Accelerator:
    • Set Type to NETINT Quadra T1A.
    • Set Attachment Type to Virtual Function (recommended for most workloads).
    • Select a Firmware version and click Add.

Note: If you plan to use NETINT's Bitstreams management software, Physical attachment is recommended for best performance and compatibility.

  1. Configure your server size (CPU, RAM, disk) as needed.
  2. Under Operating System, select Ubuntu → Ubuntu 24.04 LTS (recommended for VPU workloads).
  3. Complete the remaining wizard steps (networking, SSH key, FQDN) and click Submit.

The VM typically builds in under 15 seconds. For the full deployment walkthrough, see Deploying a Virtual Machine.

Step 2: Verify VPU Hardware​

Once the VM is running, SSH in and verify the Quadra card is visible:

ni_rsrc_mon

The output shows all detected VPU devices with their serial numbers, firmware versions, temperature, power draw, and utilization metrics for decoder, encoder, scaler, and AI engine. You should see at least one Quadra device listed.

Note: If ni_rsrc_mon is not available, you need to install the NETINT software stack first (Step 3).

Step 3: Install the NETINT Software Stack​

The NETINT software stack has three components that must be installed in order: system prerequisites, the libxcoder codec library, and FFmpeg with Quadra support. Libxcoder provides the low-level interface between FFmpeg and the Quadra hardware — FFmpeg will not build correctly without it.

Install prerequisites​

sudo apt-get update
sudo apt-get install -y pkg-config git gcc make g++ yasm nvme-cli

Install libxcoder​

Libxcoder is NETINT's codec library that provides the driver, resource manager, and hardware abstraction layer for Quadra VPUs. It must be installed before building FFmpeg.

git clone https://github.com/NETINT-Technologies/netint_libxcoder
cd netint_libxcoder
bash build.sh

Note: Use bash build.sh -h to see available build options. By default, libxcoder installs to /usr/local/lib, /usr/local/include, and /usr/local/bin. For custom paths, use bash configure --libdir=... --bindir=... --includedir=... followed by make && sudo make install. See the libxcoder installation guide for details.

Build FFmpeg with Quadra support​

Once libxcoder is installed, build FFmpeg with NETINT encoder/decoder support. Install libx264 and libx265 development libraries first so the NETINT FFmpeg build includes CPU encoders alongside the VPU encoders in a single binary:

sudo apt-get install -y libx264-dev libx265-dev

Then build FFmpeg:

cd ..
git clone https://github.com/NETINT-Technologies/netint_ffmpeg
cd netint_ffmpeg
./configure --enable-ni_quadra --enable-libx264 --enable-libx265 --enable-gpl
make -j$(nproc)
sudo make install
sudo ldconfig

Note: The NETINT FFmpeg repository is based on FFmpeg 7.1, which may differ from the version available through apt. Use ./configure -h to see all available build options. The configure step automatically detects the installed libxcoder. For the complete installation guide, including alternative methods, see the NETINT Quadra Installation Guide.

Initialize VPU devices​

After installation, initialize the Quadra cards:

init_rsrc

⚠️ VPU cards must be re-initialized after every reboot. To automate this, create a systemd service that runs init_rsrc at boot:

sudo tee /etc/systemd/system/netint-init.service > /dev/null <<'EOF'
[Unit]
Description=Initialize NETINT Quadra VPU
After=network.target

[Service]
Type=oneshot
ExecStart=/usr/local/bin/init_rsrc
RemainAfterExit=yes

[Install]
WantedBy=multi-user.target
EOF

sudo systemctl enable netint-init.service

Step 4: Verify FFmpeg Encoders​

Confirm that the Quadra encoders are available in your FFmpeg build:

ffmpeg -encoders 2>/dev/null | grep ni_quadra

You should see output similar to:

 V..... h264_ni_quadra_enc       H.264 NetInt Quadra encoder (codec h264)
 V..... h265_ni_quadra_enc       H.265 NetInt Quadra encoder (codec hevc)
 V..... av1_ni_quadra_enc        AV1 NetInt Quadra encoder (codec av1)
 V..... jpeg_ni_quadra_enc       JPEG NetInt Quadra encoder (codec mjpeg)

You can also verify decoders and filters:

ffmpeg -decoders 2>/dev/null | grep ni_quadra
ffmpeg -filters 2>/dev/null | grep ni_quadra

Step 5: Encoding Examples​

The following examples demonstrate common encoding workflows using the Quadra VPU. Replace input.mp4 with your source file.

Note: The Quadra VPU does not support interlaced content for encoding or decoding. Source files must be progressive scan. If your input is interlaced, deinterlace it before encoding with the VPU (for example, using yadif in FFmpeg: -vf yadif). Bitstreams handles deinterlacing automatically through its built-in weave filter.

H.264 encoding​

ffmpeg -i input.mp4 -c:v h264_ni_quadra_enc -b:v 5M output_h264.mp4

H.265/HEVC encoding​

ffmpeg -i input.mp4 -c:v h265_ni_quadra_enc -b:v 3M output_hevc.mp4

AV1 encoding​

ffmpeg -i input.mp4 -c:v av1_ni_quadra_enc -b:v 2M output_av1.mp4

Full VPU transcode (decode + re-encode)​

Decode the input on the VPU and re-encode to a different codec, keeping the entire pipeline on the card:

ffmpeg -c:v h264_ni_quadra_dec -i input.mp4 -c:v h265_ni_quadra_enc -b:v 3M output_transcoded.mp4

Note: For the full parameter reference and advanced encoding options (CRF mode, scaling, overlay, multi-stream), see the NETINT Programming Guide.

Step 6: Monitor VPU Performance​

From the portal​

Navigate to Infrastructure → Virtual Machines, click your VM, and expand the Accelerators section in the sidebar. You can monitor real-time graphs for Utilization (AI, Decoder, Encoder, Scaler, Uploader), Memory, Instances, Temperature, and Shared Memory with selectable time windows.

From the command line​

Run ni_rsrc_mon on the VM to see live VPU utilization, temperature, and instance counts directly from the terminal. This is useful for scripting and headless monitoring.

Bitstreams Encoding Management​

Bitstreams is NETINT's web-based encoding management software. It provides a dashboard and REST API for managing encoding templates and live streaming sessions without writing FFmpeg commands. Bitstreams is installed automatically when you provision a VPU VM through the Ansible playbook.

Install Bitstreams manually​

If you deployed your VM without the playbook, install Bitstreams with:

Install Docker Engine with the Compose plugin following Docker's official Ubuntu instructions, then:

sudo apt-get install -y unzip sysfsutils
wget https://releases.netint.com/edge/4G6C3K1I7SI6N5R/Bitstreams_Edge_v2.11.0_x86.zip
unzip Bitstreams_Edge_v2.11.0_x86.zip
cd Bitstreams_Edge_v2.11.0_x86
python3 ./edge_quick_install.py $(hostname -I | awk '{print $1}') http

After installation, open your browser to http://<vm-ip> to access the Bitstreams dashboard. Log in with the default credentials and change the password immediately.

What Bitstreams provides​

  • Templates for reusable encoding configurations (codec, resolution, bitrate, lookahead, overlays)
  • Live sessions with SRT and RTMP input, DASH/HLS/CMAF/SRT output
  • Offline sessions for file-to-file transcoding
  • Dashboard with real-time VPU utilization, temperature, and stream health monitoring
  • REST API for programmatic control of all encoding workflows
  • Interlace handling through built-in deinterlace filters (weave filter with auto/tff/bff parity)

Bitstreams handles interlaced input automatically, unlike raw FFmpeg VPU encoding which requires progressive-scan sources.

For the full Bitstreams documentation, see docs.netint.com/bitstreams.

Automated Deployment with Ansible​

The entire workflow above — provisioning, software installation, and encoding verification — can be automated with a single Ansible playbook. The playbook provisions the VM with the VPU attached, waits for SSH, installs the full NETINT stack, and runs H.264, H.265, and AV1 encoding tests.

git clone https://github.com/netactuate/netactuate-ansible-vpu-encoding
cd netactuate-ansible-vpu-encoding
export NETACTUATE_API_KEY="your-api-key"
ansible-playbook netint-vpu-deploy.yml -e vpu_ssh_key_id=YOUR_KEY_ID

The playbook accepts variables for location, plan, hostname, SSH key ID, and firmware version. See the repository README for the full variable reference and usage examples.

Firmware Updates​

You can update the Quadra firmware from the portal under the VM's Accelerators section. Click Update Firmware, select a new version, review the release notes, and confirm the update.

⚠️ Firmware updates require a brief interruption to the accelerator. Active encoding sessions will be affected. Schedule updates during a maintenance window when no encoding jobs are running.

Need Help?​

  • NETINT documentation — docs.netint.com for driver installation, API references, and codec guides
  • NETINT product information — netint.com for VPU specifications and product details
  • NetActuate support — contact support@netactuate.com or open a ticket from the portal