AutoGineer
Generated banner for Jetson Video Setup
Generated logo for Jetson Video Setup

Jetson Video Setup

NVIDIAOfficialCreated by Vinit BansalDistributed by NVIDIA

  • Skill
  • Workflow
  • Software development
  • Apache-2.0
  • Medium risk
Download ZIP

From the author

Use when installing, repairing, reusing, inspecting, or verifying readiness of the native NVIDIA Video Codec SDK or PyNvVideoCodec on Jetson, including the one-frame encode/decode smoke test with official samples, and when interpreting what those readiness results, including CPU-buffer and device-memory sample modes, do and do not establish.
— the description by Vinit Bansal

AutoGineer summary

Written by AutoGineer from the skill’s own files, not by the author

This skill provides a structured workflow for managing the lifecycle of NVIDIA video codec software on Jetson platforms. It handles inspection, installation, and verification of both the native Video Codec SDK and the PyNvVideoCodec Python interface. The skill enforces strict safety protocols for system mutations, ensures independent verification of components, and provides a standardized readiness report based on official one-frame encode/decode smoke tests.

What it does

  • Inspects installed NVIDIA Video Codec SDK and PyNvVideoCodec versions on Jetson.
  • Performs safe, non-interactive installations of missing prerequisites using standard package managers.
  • Executes official one-frame encode/decode smoke tests to verify component readiness.
  • Reports detailed status including package paths, interpreter locations, and validation results.
  • Maintains strict separation between native and Python environment configurations.
  • Provides standardized readiness status: ready, installed, blocked, or failed.

When to use it

  • When you need to verify if the video codec environment is correctly configured on a Jetson.
  • When installing or repairing the native NVIDIA Video Codec SDK or PyNvVideoCodec.
  • When you need to confirm that the codec samples are functional before running complex pipelines.
  • When troubleshooting environment-related failures in video processing tasks.

Advantages

  • Ensures consistent and reproducible environment verification.
  • Prevents system instability by enforcing safe, simulated package management.
  • Provides clear, actionable status reports for both native and Python components.
  • Reduces ambiguity by requiring explicit product selection.

Usage examples

“Check if the native Video Codec SDK is ready on my Jetson.”
The agent inspects the installed packages, runs the official one-frame encode/decode smoke test, and reports whether the SDK is ready or requires repair.
“Install PyNvVideoCodec in a new environment.”
The agent creates the requested Python environment, installs the necessary dependencies, verifies the installation, and confirms readiness via the smoke test.

Install

  1. Download the skill as a ZIP:

    https://mp-staging.autogineer.com/agent-skills/nvidia/jetson-video-setup/download

  2. Unzip it into the cross-client skills folder of your project:

    mkdir -p .agents/skills && unzip jetson-video-setup.zip -d .agents/skills

Documentation by Vinit Bansal

Jetson Video Setup

Purpose

Inspect, install, and verify the native NVIDIA Video Codec SDK and PyNvVideoCodec on a live Jetson. Setup owns product installation and readiness. Use the sibling video skills for codec support, encoder configuration, performance measurement, and application pipelines.

Use the standard package manager, Python environment tools, and installed NVIDIA samples directly, then return a concise readiness result.

Read before acting

Select the product

Resolve the requested product before touching the target:

  • “Video Codec SDK”, “VC SDK”, “native SDK”, or nvidia-video-codec-sdk selects the native product.

  • “PyNvVideoCodec”, “PyNv”, “PySDK”, “Python SDK”, or an explicitly Python interface selects PyNvVideoCodec.

  • Select both only when the user asks for both.

A genuinely bare “video SDK” setup or readiness request is ambiguous. Ask whether the user wants native Video Codec SDK, PyNvVideoCodec, or both, then stop. The word “report” does not resolve that ambiguity.

Keep native and Python work independent. A failure on one surface must not erase a successful result from the other.

Workflow

  1. Confirm commands would run on a Jetson. Inspect /etc/nv_tegra_release, /etc/os-release, and the requested GPU ordinal. On another host, provide guidance only and make no readiness claim.

  2. Inspect only the selected product with the direct commands in setup-workflow.md. For native, identify the installed package, package-owned Samples tree, CUDA toolkit, and build tools. For Python, use the exact interpreter supplied by the user or created during this request and inspect its installed distribution and loaded module. Never scan the filesystem for virtual environments.

  3. If inspection is all the user requested, report what is installed and stop. Package or import presence is installed, not ready.

  4. If the selected product is missing and the user asked to install or repair it, follow that install reference. Show the exact package or pip commands before mutation. Install and verify system prerequisites before creating a final Python environment path. Change only the selected product and its missing prerequisites.

  5. After installation, repeat the direct inspection. Then run the installed release's official one-frame encode followed by independent decode as described in setup-workflow.md.

  6. Report each selected product separately. Use ready only after its official encode and independent decode pass all observable checks. Otherwise report installed, blocked, or failed, name the failing command or missing prerequisite, and give one concrete next action.

When another video skill asks only for readiness, perform steps 1 and 2 and return the exact package/Samples root or Python interpreter/package path. Do not run the setup smoke test if that consumer will immediately run its own authenticated operation.

PyNvVideoCodec environment selection

Use this interpreter precedence: an explicit user path, an exact path already established in the current conversation, then the conventional profile path. The conventional smoke interpreter is $HOME/.venvs/nvcodec/bin/python; the full-samples interpreter is $HOME/.venvs/nvcodec-full/bin/python. Checking one of these exact paths is not a filesystem scan. Never select a venv by directory order or fall back to system Python.

For a new environment, use the applicable conventional path when it is absent, or an explicit new absolute path in a durable user-owned location. If the conventional path exists, inspect it first. Reuse it when valid; otherwise report its exact defect, leave it untouched, and ask for a different new path. Return the selected interpreter path so downstream skills can use it directly.

Use pynvc-smoke for the setup smoke proof, decode-performance work, and a conventional interface-availability check. That availability check inspects only the exact smoke path and reports not_ready when it is absent or invalid. Any consumer encode operation, including a capability availability proof, and work using advanced raw decode, segmentation, or encode-performance samples selects the separate full-samples environment and dependencies described in the install guide. A media-free capability inventory may use either conventional profile: inspect smoke first, then full-samples when smoke is absent, and report the exact interpreter that answered. Apply that either-profile allowance only when the entire request is a media-free inventory. When a request also seeks an operation or a capability availability proof, use the profile that request binds; if that profile is not ready, report not_ready and do not query the other conventional profile. The interface-availability check above remains bound to the smoke path.

Readiness proof

Both products use one generated 640×360 8-bit NV12 frame (345,600 bytes), H.264 encode, and an independent decode of the fresh bitstream.

ProductRequired evidence
NativePackage-owned AppEncCuda reports one encoded frame; package-owned AppDec consumes that exact nonempty bitstream, reports one decoded frame, and writes a 345,600-byte NV12 output.
PyNv full-samplesWheel-owned basic/encode.py reports one encoded CPU-buffer frame; wheel-owned advanced/decode.py consumes the exact bitstream, reports one frame, and writes a 345,600-byte output.
PyNv pynvc-smokeThe same encoder proof; wheel-owned advanced/decode_perf.py reports one requested decoded frame and a total of one, with no worker error, warning, or traceback. It does not claim a raw decoded file.

Exit zero or file creation alone is insufficient. Require the expected marker and count, a newly created nonempty bitstream, and the independent consumer. Do not require decoded bytes to equal the input because H.264 is lossy.

CPU-buffer and device-memory sample modes establish only the exact readiness operation. They do not establish external buffer sharing, zero copy, or a synchronization primitive for another process or pipeline stage. For a request to confirm an in-process or cross-stage buffer contract, invoke jetson-video-pipeline; require an authenticated operation of the actual downstream stage that proves the sharing handle, format and layout, ownership and lifetime, signal and wait behavior, and safe buffer reuse. Do not answer that request from setup evidence alone.

Compose requested sibling work

For a request that also asks about support, encoder configuration, throughput, or an application workflow, invoke only the matching public skill:

  • jetson-video-capability

  • jetson-video-recipe

  • jetson-video-benchmark

  • jetson-video-pipeline

Pass the selected product and exact local paths as data. Do not read or import a sibling skill's private files. If a required sibling is unavailable, preserve completed setup results and name the missing skill.

Safety

  • For a report-only request, perform direct read-only inspection only; never build samples, create a workspace or venv, launch a codec operation, or mutate packages or an existing Python environment.

  • Use only already configured, signature-authenticated package repositories. NVIDIA SDK and CUDA packages must come from the public Jetson repository for the installed release. Never add or edit a source, key, or trust bypass.

  • Before APT installation, inspect the candidate and origin, run the exact apt-get -s simulation, and reject removals, downgrades, or unexpected packages. Apply the reviewed command with noninteractive sudo -n; if that authorization is unavailable, stop rather than using a password prompt, su, or another escalation path.

  • Run dpkg --audit after an APT mutation and stop if it is nonempty or fails.

  • Keep native and Python acquisition separate. A Python-only request must not install nvidia-video-codec-sdk; a native-only request must not create a venv.

  • Keep credentials out of commands, logs, and reports. Reject symlinked or unexpected install targets and use fresh build/output paths.

  • Local installation and smoke results do not establish product support or that the release is the newest compatible release. Use current official NVIDIA documentation for those claims.

For PSNR, SSIM, DRM playback, capture, inference, or display work, state that setup does not own that workflow and route only an explicitly requested video codec portion.

Files

references/setup-install.md

Direct installation guide

Use this guide only when the user explicitly asks to install, set up, repair, or create a fresh environment. A readiness or report-only request is read-only. Inspect the live candidate, show the exact command, and use the standard package or Python tool directly.

Product boundaries

ProductAcquisitionVerification
Native Video Codec SDKnvidia-video-codec-sdk from the configured public Jetson APT releasePackage-owned AppEncCuda followed by package-owned AppDec
PyNvVideoCodecPublic PyNvVideoCodec wheel and dependencies in one isolated venvWheel-owned basic/encode.py followed by advanced/decode_perf.py or advanced/decode.py

The products are independent. Do not install the native SDK for a Python-only request or create a Python environment for a native-only request. CUDA, driver, compiler, SDK, and Python package versions are separate facts.

APT safety

Before any APT change:

  1. Inspect /etc/nv_tegra_release and the configured source files.

  2. Run apt-cache policy for every proposed package and record the exact candidate and origin.

  3. For NVIDIA SDK or CUDA packages, require the configured, signature-authenticated public Jetson source at https://repo.download.nvidia.com/jetson/common or https://repo.download.nvidia.com/jetson/som, with the rNN.N/main suite for the installed release. Never add or modify a source or signing key.

  4. Pin each explicitly requested package to its reviewed candidate and run the exact apt-get -s install --no-remove command. Review every dependency and origin in the simulated transaction, but do not copy the transitive closure into the apply command. Stop on a removal, downgrade, unauthenticated package, changed candidate, or unrelated package set.

  5. Apply the same top-level package specs using noninteractive sudo -n. Recheck their candidates immediately before applying, and do not retype or otherwise change a successfully simulated package spec. If passwordless authorization is unavailable, stop and report it; never switch to an interactive password prompt, su, or another escalation method.

  6. Run /usr/bin/dpkg --audit after the mutation. A nonzero exit or any output blocks further setup until the package state is repaired by the operator.

Refresh package metadata once with sudo -n apt-get update only when the configured source is correct and local metadata has no usable candidate or the user explicitly requested a refresh. Reinspect candidates after the refresh; do not apply a command based on the old result.

Install the native Video Codec SDK

Inspect these packages and select only missing prerequisites:

  • nvidia-video-codec-sdk

  • cmake, g++, and either ninja-build or an available CMake generator

  • pkg-config

  • libavcodec-dev, libavformat-dev, libavutil-dev, and libswresample-dev for AppDec

Use the APT safety sequence above. A typical reviewed pair is shown below; replace each VERSION with the exact live candidate and do not copy the placeholder literally:

sudo -n env DEBIAN_FRONTEND=noninteractive \
  apt-get -s install -y --no-remove -- PACKAGE=VERSION
sudo -n env DEBIAN_FRONTEND=noninteractive \
  apt-get install -y --no-remove -- PACKAGE=VERSION
/usr/bin/dpkg --audit

Install one complete reviewed package set rather than repeatedly reacting to compiler errors. For an explicitly requested reinstall, use --reinstall with the same current candidate; do not uninstall the working package or base dependencies first.

After APT succeeds, repeat package ownership, build-tool, CUDA, and pkg-config checks, then perform the official native proof in setup-workflow.md. An installed package that cannot build or run its samples is not ready.

Reuse an existing PyNvVideoCodec environment

Use the interpreter precedence in SKILL.md: an explicit path, a path established in the current conversation, then the applicable conventional profile path. Inspect it with the commands in setup-workflow.md. If the expected distribution, loaded module, dependencies, and samples are present, make no package change and run the official proof directly.

Never scan for another venv, infer one from shell activation, or reinstall a valid environment. If the conventional path exists but is invalid, report its specific defect, leave it untouched, and ask for a different new absolute path.

Create a PyNvVideoCodec environment

Under the user home directory, use .venvs/nvcodec for a new default smoke environment and .venvs/nvcodec-full for a new full-samples environment when the user does not supply a path. An explicit alternative must be absolute and in a durable user-owned location. The path and every parent component must be non-symlinked; the final path must not exist. Do not delete or repair an existing directory.

Complete this prerequisite phase before creating the final venv directory:

  • Inspect python3-venv, python3-dev, g++, and make. Install every missing item through the APT safety sequence. python3 -m venv --help is not proof that ensurepip is usable; require python3 -I -m ensurepip --version after installation.

  • Resolve an existing nvcc from PATH, /usr/local/cuda/bin/nvcc, or the release-specific /usr/local/cuda-*/bin/nvcc locations before treating it as missing. Derive CUDA_ROOT from the verified compiler and check include/curand.h under CUDA_ROOT.

  • Install the release-matched minimal CUDA build or CURAND development package only when that capability is absent from every existing toolkit. On R39.2 the packages are cuda-minimal-build-13-2 and libcurand-dev-13-2; derive their exact candidates and HTTPS Jetson origins rather than copying a version.

Do not install the full CUDA toolkit merely as a workaround when a suitable toolkit is already present. Scope CUDA include/library variables to the PyCUDA build; never add a CUDA stub directory to the runtime loader path.

Only after those checks pass, confirm the chosen final path is still absent, create it once, and inspect it with standard Python commands:

python3 -m venv "$VENV"
"$VENV/bin/python" -I -m pip --version

For the default smoke profile, review the resolver result and then install. Scope the verified toolkit paths to these PyCUDA build commands:

env PATH="$CUDA_ROOT/bin:/usr/bin:$PATH" \
  CPATH="$CUDA_ROOT/include" LIBRARY_PATH="$CUDA_ROOT/lib64" \
  "$VENV/bin/python" -I -m pip install --dry-run \
  'PyNvVideoCodec==2.1.0' 'numpy>=1.24' 'pycuda==2026.1'
env PATH="$CUDA_ROOT/bin:/usr/bin:$PATH" \
  CPATH="$CUDA_ROOT/include" LIBRARY_PATH="$CUDA_ROOT/lib64" \
  "$VENV/bin/python" -I -m pip install \
  'PyNvVideoCodec==2.1.0' 'numpy>=1.24' 'pycuda==2026.1'
"$VENV/bin/python" -I -m pip check

If the installed pip does not support --dry-run, report that limitation and show the exact install command and package sources before applying it. Do not disable TLS, signature, hash, or certificate checks, and do not put credentials in an index URL or command.

Only when the user requests samples that import Torch, create a separate full-samples venv and add the release-compatible CUDA-enabled Torch package from its official index. For the currently documented CUDA 13 profile this is:

"$VENV/bin/python" -I -m pip install --dry-run \
  --extra-index-url https://download.pytorch.org/whl/cu130 \
  'torch==2.9.1+cu130'
"$VENV/bin/python" -I -m pip install \
  --extra-index-url https://download.pytorch.org/whl/cu130 \
  'torch==2.9.1+cu130'

Confirm the version against the release-matched official PyNvVideoCodec documentation before installing if the local release differs. Do not add Torch to the default smoke profile.

Finally repeat the exact-interpreter inspection and run the wheel-owned proof in setup-workflow.md. Return the absolute interpreter path to the user and downstream skills.

Failure handling

  • Stop at the first failed mutation or inconsistent package state.

  • Do not retry an unchanged failing command more than once.

  • Preserve an independently successful product when both were requested.

  • Name the exact command, failure, selected candidate or interpreter, and one actionable remedy. Do not convert an installation failure into “codec unsupported”.

Primary sources

Requirements and compatibility

Works with: Claude Code, Claude apps, OpenAI Codex, GitHub Copilot, Cursor, Gemini CLI, Kiro, OpenCode, Goose, Amp, Roo Code, JetBrains Junie, Factory Droid, Devin (ex-Windsurf), Mistral Vibe, OpenHands, Letta

“Works with” means the tool reads the open Agent Skills format; a skill written for one tool may use features others lack.

Needs: Needs Python

Security

What our scanner noticed· Medium risk

  • Large base64-encoded blobs
  • Instructions that use the network

A static scan is not a guarantee. Skills are third-party content: review a skill before you let an agent use it.

Attribution and licence

Created by
Vinit Bansal
Publisher
NVIDIA (Official)
Distributed by
NVIDIA
Source
NVIDIA/skills · skills/jetson-video-setup · commit fce3cca
Licence
Apache License 2.0 (redistribution allowed)
  • LICENSE (added by AutoGineer from LICENSE-APACHE)
  • ATTRIBUTION.md (written by AutoGineer)
Synced

AutoGineer is not affiliated with or endorsed by Vinit Bansal or NVIDIA.

Download ZIP

The ZIP holds the skill’s files, its licence files and an ATTRIBUTION.md. Download jetson-video-setup.zip