[{"data":1,"prerenderedAt":-1},["ShallowReactive",2],{"similar-NVIDIA--nvvl":3,"tool-NVIDIA--nvvl":61},[4,18,26,36,44,53],{"id":5,"name":6,"github_repo":7,"description_zh":8,"stars":9,"difficulty_score":10,"last_commit_at":11,"category_tags":12,"status":17},4358,"openclaw","openclaw\u002Fopenclaw","OpenClaw 是一款专为个人打造的本地化 AI 助手，旨在让你在自己的设备上拥有完全可控的智能伙伴。它打破了传统 AI 助手局限于特定网页或应用的束缚，能够直接接入你日常使用的各类通讯渠道，包括微信、WhatsApp、Telegram、Discord、iMessage 等数十种平台。无论你在哪个聊天软件中发送消息，OpenClaw 都能即时响应，甚至支持在 macOS、iOS 和 Android 设备上进行语音交互，并提供实时的画布渲染功能供你操控。\n\n这款工具主要解决了用户对数据隐私、响应速度以及“始终在线”体验的需求。通过将 AI 部署在本地，用户无需依赖云端服务即可享受快速、私密的智能辅助，真正实现了“你的数据，你做主”。其独特的技术亮点在于强大的网关架构，将控制平面与核心助手分离，确保跨平台通信的流畅性与扩展性。\n\nOpenClaw 非常适合希望构建个性化工作流的技术爱好者、开发者，以及注重隐私保护且不愿被单一生态绑定的普通用户。只要具备基础的终端操作能力（支持 macOS、Linux 及 Windows WSL2），即可通过简单的命令行引导完成部署。如果你渴望拥有一个懂你",349277,3,"2026-04-06T06:32:30",[13,14,15,16],"Agent","开发框架","图像","数据工具","ready",{"id":19,"name":20,"github_repo":21,"description_zh":22,"stars":23,"difficulty_score":10,"last_commit_at":24,"category_tags":25,"status":17},3808,"stable-diffusion-webui","AUTOMATIC1111\u002Fstable-diffusion-webui","stable-diffusion-webui 是一个基于 Gradio 构建的网页版操作界面，旨在让用户能够轻松地在本地运行和使用强大的 Stable Diffusion 图像生成模型。它解决了原始模型依赖命令行、操作门槛高且功能分散的痛点，将复杂的 AI 绘图流程整合进一个直观易用的图形化平台。\n\n无论是希望快速上手的普通创作者、需要精细控制画面细节的设计师，还是想要深入探索模型潜力的开发者与研究人员，都能从中获益。其核心亮点在于极高的功能丰富度：不仅支持文生图、图生图、局部重绘（Inpainting）和外绘（Outpainting）等基础模式，还独创了注意力机制调整、提示词矩阵、负向提示词以及“高清修复”等高级功能。此外，它内置了 GFPGAN 和 CodeFormer 等人脸修复工具，支持多种神经网络放大算法，并允许用户通过插件系统无限扩展能力。即使是显存有限的设备，stable-diffusion-webui 也提供了相应的优化选项，让高质量的 AI 艺术创作变得触手可及。",162132,"2026-04-05T11:01:52",[14,15,13],{"id":27,"name":28,"github_repo":29,"description_zh":30,"stars":31,"difficulty_score":32,"last_commit_at":33,"category_tags":34,"status":17},1381,"everything-claude-code","affaan-m\u002Feverything-claude-code","everything-claude-code 是一套专为 AI 编程助手（如 Claude Code、Codex、Cursor 等）打造的高性能优化系统。它不仅仅是一组配置文件，而是一个经过长期实战打磨的完整框架，旨在解决 AI 代理在实际开发中面临的效率低下、记忆丢失、安全隐患及缺乏持续学习能力等核心痛点。\n\n通过引入技能模块化、直觉增强、记忆持久化机制以及内置的安全扫描功能，everything-claude-code 能显著提升 AI 在复杂任务中的表现，帮助开发者构建更稳定、更智能的生产级 AI 代理。其独特的“研究优先”开发理念和针对 Token 消耗的优化策略，使得模型响应更快、成本更低，同时有效防御潜在的攻击向量。\n\n这套工具特别适合软件开发者、AI 研究人员以及希望深度定制 AI 工作流的技术团队使用。无论您是在构建大型代码库，还是需要 AI 协助进行安全审计与自动化测试，everything-claude-code 都能提供强大的底层支持。作为一个曾荣获 Anthropic 黑客大奖的开源项目，它融合了多语言支持与丰富的实战钩子（hooks），让 AI 真正成长为懂上",159267,2,"2026-04-17T11:29:14",[14,13,35],"语言模型",{"id":37,"name":38,"github_repo":39,"description_zh":40,"stars":41,"difficulty_score":32,"last_commit_at":42,"category_tags":43,"status":17},2271,"ComfyUI","Comfy-Org\u002FComfyUI","ComfyUI 是一款功能强大且高度模块化的视觉 AI 引擎，专为设计和执行复杂的 Stable Diffusion 图像生成流程而打造。它摒弃了传统的代码编写模式，采用直观的节点式流程图界面，让用户通过连接不同的功能模块即可构建个性化的生成管线。\n\n这一设计巧妙解决了高级 AI 绘图工作流配置复杂、灵活性不足的痛点。用户无需具备编程背景，也能自由组合模型、调整参数并实时预览效果，轻松实现从基础文生图到多步骤高清修复等各类复杂任务。ComfyUI 拥有极佳的兼容性，不仅支持 Windows、macOS 和 Linux 全平台，还广泛适配 NVIDIA、AMD、Intel 及苹果 Silicon 等多种硬件架构，并率先支持 SDXL、Flux、SD3 等前沿模型。\n\n无论是希望深入探索算法潜力的研究人员和开发者，还是追求极致创作自由度的设计师与资深 AI 绘画爱好者，ComfyUI 都能提供强大的支持。其独特的模块化架构允许社区不断扩展新功能，使其成为当前最灵活、生态最丰富的开源扩散模型工具之一，帮助用户将创意高效转化为现实。",108322,"2026-04-10T11:39:34",[14,15,13],{"id":45,"name":46,"github_repo":47,"description_zh":48,"stars":49,"difficulty_score":32,"last_commit_at":50,"category_tags":51,"status":17},6121,"gemini-cli","google-gemini\u002Fgemini-cli","gemini-cli 是一款由谷歌推出的开源 AI 命令行工具，它将强大的 Gemini 大模型能力直接集成到用户的终端环境中。对于习惯在命令行工作的开发者而言，它提供了一条从输入提示词到获取模型响应的最短路径，无需切换窗口即可享受智能辅助。\n\n这款工具主要解决了开发过程中频繁上下文切换的痛点，让用户能在熟悉的终端界面内直接完成代码理解、生成、调试以及自动化运维任务。无论是查询大型代码库、根据草图生成应用，还是执行复杂的 Git 操作，gemini-cli 都能通过自然语言指令高效处理。\n\n它特别适合广大软件工程师、DevOps 人员及技术研究人员使用。其核心亮点包括支持高达 100 万 token 的超长上下文窗口，具备出色的逻辑推理能力；内置 Google 搜索、文件操作及 Shell 命令执行等实用工具；更独特的是，它支持 MCP（模型上下文协议），允许用户灵活扩展自定义集成，连接如图像生成等外部能力。此外，个人谷歌账号即可享受免费的额度支持，且项目基于 Apache 2.0 协议完全开源，是提升终端工作效率的理想助手。",100752,"2026-04-10T01:20:03",[52,13,15,14],"插件",{"id":54,"name":55,"github_repo":56,"description_zh":57,"stars":58,"difficulty_score":32,"last_commit_at":59,"category_tags":60,"status":17},4721,"markitdown","microsoft\u002Fmarkitdown","MarkItDown 是一款由微软 AutoGen 团队打造的轻量级 Python 工具，专为将各类文件高效转换为 Markdown 格式而设计。它支持 PDF、Word、Excel、PPT、图片（含 OCR）、音频（含语音转录）、HTML 乃至 YouTube 链接等多种格式的解析，能够精准提取文档中的标题、列表、表格和链接等关键结构信息。\n\n在人工智能应用日益普及的今天，大语言模型（LLM）虽擅长处理文本，却难以直接读取复杂的二进制办公文档。MarkItDown 恰好解决了这一痛点，它将非结构化或半结构化的文件转化为模型“原生理解”且 Token 效率极高的 Markdown 格式，成为连接本地文件与 AI 分析 pipeline 的理想桥梁。此外，它还提供了 MCP（模型上下文协议）服务器，可无缝集成到 Claude Desktop 等 LLM 应用中。\n\n这款工具特别适合开发者、数据科学家及 AI 研究人员使用，尤其是那些需要构建文档检索增强生成（RAG）系统、进行批量文本分析或希望让 AI 助手直接“阅读”本地文件的用户。虽然生成的内容也具备一定可读性，但其核心优势在于为机器",93400,"2026-04-06T19:52:38",[52,14],{"id":62,"github_repo":63,"name":64,"description_en":65,"description_zh":66,"ai_summary_zh":67,"readme_en":68,"readme_zh":69,"quickstart_zh":70,"use_case_zh":71,"hero_image_url":72,"owner_login":73,"owner_name":74,"owner_avatar_url":75,"owner_bio":76,"owner_company":77,"owner_location":77,"owner_email":77,"owner_twitter":77,"owner_website":78,"owner_url":79,"languages":80,"stars":111,"forks":112,"last_commit_at":113,"license":114,"difficulty_score":115,"env_os":116,"env_gpu":117,"env_ram":118,"env_deps":119,"category_tags":128,"github_topics":77,"view_count":32,"oss_zip_url":77,"oss_zip_packed_at":77,"status":17,"created_at":130,"updated_at":131,"faqs":132,"releases":133},8549,"NVIDIA\u002Fnvvl","nvvl","A library that uses hardware acceleration to load sequences of video frames to facilitate machine learning training","NVVL（NVIDIA Video Loader）是一款专为机器学习训练设计的开源库，旨在利用 NVIDIA GPU 的硬件加速能力，高效地从压缩视频文件中加载随机帧序列。它通过调用 FFmpeg 解析视频流，并将繁重的解码任务卸载到 GPU 上，直接生成可用于训练的张量数据，同时支持在加载过程中进行缩放、裁剪和翻转等数据增强操作。\n\n在深度学习训练中，传统方式通常需要将视频拆解为大量单帧图片存储，这不仅占用巨大的磁盘空间，还导致严重的 I\u002FO 瓶颈和 CPU 过载。NVVL 直接使用压缩视频文件（如 MP4），能将数据存储需求降低一个数量级，并显著减少 CPU 占用，从而让数据加载不再成为制约 GPU 性能的短板。例如在特定场景下，其 CPU 负载仅为传统图片加载方式的一半左右。\n\n该工具主要适合从事计算机视觉研究的开发者与算法工程师，特别是使用 PyTorch 框架的用户。虽然 NVVL 功能强大且提供了便捷的框架封装，但需注意该项目目前已停止独立维护，官方建议新用户迁移至功能更全面且持续更新的 DALI（NVIDIA Data Loading Library）库，以获取更稳定的支","NVVL（NVIDIA Video Loader）是一款专为机器学习训练设计的开源库，旨在利用 NVIDIA GPU 的硬件加速能力，高效地从压缩视频文件中加载随机帧序列。它通过调用 FFmpeg 解析视频流，并将繁重的解码任务卸载到 GPU 上，直接生成可用于训练的张量数据，同时支持在加载过程中进行缩放、裁剪和翻转等数据增强操作。\n\n在深度学习训练中，传统方式通常需要将视频拆解为大量单帧图片存储，这不仅占用巨大的磁盘空间，还导致严重的 I\u002FO 瓶颈和 CPU 过载。NVVL 直接使用压缩视频文件（如 MP4），能将数据存储需求降低一个数量级，并显著减少 CPU 占用，从而让数据加载不再成为制约 GPU 性能的短板。例如在特定场景下，其 CPU 负载仅为传统图片加载方式的一半左右。\n\n该工具主要适合从事计算机视觉研究的开发者与算法工程师，特别是使用 PyTorch 框架的用户。虽然 NVVL 功能强大且提供了便捷的框架封装，但需注意该项目目前已停止独立维护，官方建议新用户迁移至功能更全面且持续更新的 DALI（NVIDIA Data Loading Library）库，以获取更稳定的支持和更多样化的数据处理能力。","# NVVL is part of DALI!\n[DALI (Nvidia Data Loading Library)](https:\u002F\u002Fdeveloper.nvidia.com\u002Fdali) incorporates NVVL functionality and offers much more than that, so it is recommended to switch to it.\nDALI source code is also open source and available on the [GitHub](https:\u002F\u002Fgithub.com\u002FNVIDIA\u002FDALI).\nUp to date documentation can be found [here](https:\u002F\u002Fdocs.nvidia.com\u002Fdeeplearning\u002Fsdk\u002Fdali-developer-guide\u002Fdocs\u002Findex.html).\nNVVL project will still be available on the GitHub but it won't be maintained. All issues and request for the future please [submit in the DALI repository](https:\u002F\u002Fgithub.com\u002FNVIDIA\u002FDALI\u002Fissues).\n\n# NVVL\nNVVL (**NV**IDIA **V**ideo **L**oader) is a library to load random\nsequences of video frames from compressed video files to facilitate\nmachine learning training. It uses FFmpeg's libraries to parse and\nread the compressed packets from video files and the video decoding\nhardware available on NVIDIA GPUs to off-load and accelerate the\ndecoding of those packets, providing a ready-for-training tensor in\nGPU device memory. NVVL can additionally perform data augmentation\nwhile loading the frames. Frames can be scaled, cropped, and flipped\nhorizontally using the GPUs dedicated texture mapping units. Output\ncan be in RGB or YCbCr color space, normalized to [0, 1] or [0, 255],\nand in `float`, `half`, or `uint8` tensors.\n\n**Note that, while we hope you find NVVL useful, it is example code\nfrom a research project performed by a small group of NVIDIA researchers.\nWe will do our best to answer questions and fix small bugs as they come\nup, but it is not a supported NVIDIA product and is for the most part\nprovided as-is.**\n\nUsing compressed video files instead of individual frame image files\nsignificantly reduces the demands on the storage and I\u002FO systems\nduring training. Storing video datasets as video files consumes an\norder of magnitude less disk space, allowing for larger datasets to\nboth fit in system RAM as well as local SSDs for fast access. During\nloading fewer bytes must be read from disk. Fitting on smaller, faster\nstorage and reading fewer bytes at load time allievates the bottleneck\nof retrieving data from disks, which will only get worse as GPUs get\nfaster. For the dataset used in our example project, H.264 compressed\n`.mp4` files were nearly 40x smaller than storing frames as `.png`\nfiles.\n\nUsing the hardware decoder on NVIDIA GPUs to decode images\nsignificantly reduces the demands on the host CPU. This means fewer\nCPU cores need to be dedicated to data loading during training. This\nis especially important in servers with a large number of GPUs per\nCPU, such as the in the NVIDIA DGX-2 server, but also provides\nbenefits for other platforms. When training our example project on a\nNVIDIA DGX-1, the CPU load when using NVVL was 50-60% of the load seen\nwhen using a normal dataloader for `.png` files.\n\nMeasurements that quantify the performance advantages of using NVVL\nare detailed in our [super resolution example\nproject](\u002Fexamples\u002Fpytorch_superres).\n\nMost users will want to use the deep learning framework wrappers\nprovided rather than using the library directly. Currently a wrapper\nfor PyTorch is provided (PR's for other frameworks are welcome). See\nthe [PyTorch wrapper README](\u002Fpytorch\u002FREADME.md) for documentation on\nusing the PyTorch wrapper. Note that it is not required to build or\ninstall the C++ library before building the PyTorch wrapper (its\nsetup scripts will do so for you).\n\n# Building and Installing\n\nNVVL depends on the following:\n- CUDA Toolkit. We have tested versions 8.0 and later but earlier\n  versions may work. NVVL will perform better with CUDA 9.0 or\n  later\u003Csup id=\"a1\">[1](#f1)\u003C\u002Fsup>.\n- FFmpeg's libavformat, libavcodec, libavfilter, and libavutil. These\n  can be installed from source as in the [example\n  Dockerfiles](\u002Fdocker) or from the Ubuntu 16.04 packages\n  `libavcodec-dev libavfilter-dev libavformat-dev\n  libavutil-dev`. Other distributions should have similar packages.\n\nAdditionally, building from source requires CMake version 3.8 or above\nand some examples optionally make use of some libraries from OpenCV if\nthey are installed.\n\nThe [docker](docker) directory contains Dockerfiles that can be used\nas a starting point for creating an image to build or use the NVVL\nlibrary. The [example's docker directory](examples\u002Fpytorch\u002Fdocker) has\nan example Dockerfile that actually builds and installs the NVVL\nlibrary.\n\nCMake 3.8 and above provides builtin CUDA language support that NVVL's\nbuild system uses. Since CMake 3.8 is relatively new and not yet in\nwidely used Linux distribution, it may be required to install a new\nversion of CMake.  The easiest way to do so is to make use of their\npackage on PyPI:\n\n```\npip install cmake\n```\n\nAlternatively, or if `pip` isn't available, you can install to\n`\u002Fusr\u002Flocal` from a binary distribution:\n\n```sh\nwget https:\u002F\u002Fcmake.org\u002Ffiles\u002Fv3.10\u002Fcmake-3.10.2-Linux-x86_64.sh\n\u002Fbin\u002Fsh cmake-3.10.2-Linux-x86_64.sh --prefix=\u002Fusr\u002Flocal\n```\n\nSee https:\u002F\u002Fcmake.org\u002Fdownload\u002F for more options.\n\nBuilding and installing NVVL follows the typical CMake pattern:\n\n```sh\nmkdir build && cd build\ncmake ..\nmake -j\nsudo make install\n```\n\nThis will install `libnvvl.so` and development headers into\nappropriate subdirectores under `\u002Fusr\u002Flocal`. CMake can be passed the\nfollowing options using `cmake .. -DOPTION=Value`:\n\n- `CUDA_ARCH` - Name of a CUDA architecture to generate device code\n  for, seperated via a semicolon. Valid options are `Kepler`,\n  `Maxwell`, `Pascal`, and `Volta`. You can also use specific\n  architecture names such as `sm_61`. Default is\n  `Maxwell;Pascal;Volta`.\n\n- `CMAKE_CUDA_FLAGS` - A string of arguments to pass to `nvcc`. In\n  particular, you can decide to link against the static or shared\n  runtime library using `-cudart shared` or `-cudart static`. You can\n  also use this for finer control of code generation than `CUDA_ARCH`,\n  see the `nvcc` documentation. Default is `-cudart shared`.\n\n- `WITH_OPENCV` - Set this to 1 to build the examples with the\n  optional OpenCV functionality.\n\n- `CMAKE_INSTALL_PREFIX` - Install directory. Default is\n  `\u002Fusr\u002Flocal`.\n\n- `CMAKE_BUILD_TYPE` - `Debug` or `Release` build.\n\nSee the [CMake documentation](https:\u002F\u002Fcmake.org\u002Fcmake\u002Fhelp\u002Fv3.8\u002F) for\nmore options.\n\nThe examples in `doc\u002Fexamples` can be built using the `examples` target:\n```\nmake examples\n```\n\nFinally, if Doxygen is installed, API documentation can be built using\nthe `doc` target:\n```\nmake doc\n```\nThis will build html files in `doc\u002Fhtml`.\n\n# Preparing Data\n\nNVVL supports the H.264 and HEVC (H.265) video codecs in any container\nformat that FFmpeg is able to parse.  Video codecs only store certain\nframes, called keyframes or intra-frames, as a complete image in the\ndata stream. All other frames require data from other frames, either\nbefore or after it in time, to be decoded. In order to decode a\nsequence of frames, it is necessary to start decoding at the keyframe\nbefore the sequence, and continue past the sequence to the next\nkeyframe after it. This isn't a problem when streaming sequentially\nthrough a video; however, when decoding small sequences of frames\nrandomly throughout the video, a large gap between keyframes results in\nreading and decoding a large amount of frames that are never used.\n\nThus, to get good performance when randomly reading short sequences\nfrom a video file, it is necessary to encode the file with frequent\nkey frames. We've found setting the keyframe interval to the length of\nthe sequences you will be reading provides a good compromise between\nfilesize and loading performance. Also, NVVL's seeking logic doesn't\nsupport open GOPs in HEVC streams. To set the keyframe interval to `X`\nwhen using `ffmpeg`:\n\n- For `libx264` use `-g X`\n- For `libx265` use `-x265-params \"keyint=X:no-open-gop=1\"`\n\nThe pixel format of the video must also be yuv420p to be supported by\nthe hardware decoder. This is done by passing `-pix_fmt yuv420p` to\n`ffmpeg`. You should also remove any extra audio or video streams from\nthe video file by passing `-map v:0` to ffmpeg after the input but\nbefore the output.\n\nFor example to transcode to H.264:\n```\nffmpeg -i original.mp4 -map v:0 -c:v libx264 -crf 18 -pix_fmt yuv420p -g 5 -profile:v high prepared.mp4\n```\n\n# Basic Usage\nThis section describes the usage of the base C\u002FC++ library, for usage\nof the PyTorch wrapper, see the [README](\u002Fpytorch\u002FREADME.md) in the\npytorch directory.\n\nThe library provides both a C++ and C interface. See the examples in\n[doc\u002Fexamples](doc\u002Fexamples) for brief example code on how to use the\nlibrary. [extract_frames.cpp](doc\u002Fexamples\u002Fextract_frames.cpp)\ndemonstrates the C++ interface and\n[extract_frames_c.c](doc\u002Fexamples\u002Fextract_frames_c.c) the C\ninterface. The API documentation built with `make doc` is the\ncanonical reference for the API.\n\nThe basic flow is to create a `VideoLoader` object, tell it which\nframe sequences to read, and then give it buffers in device memory to\nput the decoded sequences into. In C++, creating a video loader is\nstraight forward:\n\n```C++\nauto loader = NVVL::VideoLoader{device_id};\n```\n\nYou can then tell it which sequences to read via `read_sequence`:\n\n```C++\nloader.read_sequence(filename, frame_num, sequence_length);\n\n```\n\nTo receive the frames from the decoder, it is necessary to create a\n`PictureSequence` to tell it how and where you want the decoded frames\nprovided. First, create a `PictureSequence`, providing a count of the\nnumber of frames to receive from the decoder. Note that the count here\ndoes not need to be the same as the sequence_length provided to\n`read_sequence`; you can read a large sequence of frames and receive\nthem as multiple tensors, or read multiple smaller sequences and\nreceive them concatenated as a single tensor.\n\n```C++\nauto seq = PictureSequence{sequence_count};\n```\n\nYou now create \"Layers\" in the sequence to provide the destination for\nthe frames. Each layer can be a different type, have different\nprocessing, and contain different frames from the received\nsequence. First, create a `PictureSequence::Layer` of the desired\ntype:\n\n```C++\nauto pixels = PictureSequence::Layer\u003Cfloat>{};\n```\n\nNext, fill in the pointer to the data and other details. See the\ndocumentation in [PictureSequence.h](include\u002FPictureSequence.h) for a\ndescription of all the available options.\n\n```C++\nfloat* data = nullptr;\nsize_t pitch = 0;\ncudaMallocPitch(&data, &pitch,\n                crop_width * sizeof(float),\n                crop_height * sequence_count * 3);\npixels.data = data;\npixels.desc.count = sequence_count;\npixels.desc.channels = 3;\npixels.desc.width = crop_width;\npixels.desc.height = crop_height;\npixels.desc.scale_width = scale_width;\npixels.desc.scale_height = scale_height;\npixels.desc.horiz_flip = false;\npixels.desc.normalized = true;\npixels.desc.color_space = ColorSpace_RGB;\npixels.desc.stride.x = 1;\npixels.desc.stride.y = pitch \u002F sizeof(float);\npixels.desc.stride.c = pixels.desc.stride.y * crop_height;\npixels.desc.stride.n = pixels.desc.stride.c * 3;\n```\n\nNote that here we have set the strides such that the dimensions are\n\"nchw\", we could have done \"nhwc\" or any other dimension order by\nsetting the strides appropriately. Also note that the strides in the\nlayer description are number of elements, not number of bytes.\n\nWe now add this layer to our `PictureSequence`, and send it to the loader:\n\n```C++\nseq.set_layer(\"pixels\", pixels);\nloader.receive_frames(seq);\n```\n\nThis call to `receive_frames` will be\nasynchronous. `receive_frames_sync` can be used if synchronous reading\nis desired. When we are ready to use the frames we can insert a wait\nevent into the CUDA stream we are using for our computation:\n\n```C++\nseq.wait(stream);\n```\n\nThis will insert a wait event into the stream `stream`, causing any\nfurther kernels launched on `stream` to wait until the data is\nready.\n\nThe C interface follows a very similar pattern, see\n[doc\u002Fexamples\u002Fextract_frames_c.c](doc\u002Fexamples\u002Fextract_frames_c.c)\nfor an example.\n\n# Reference\nIf you find this library useful in your work, please cite it in your\npublications using the following BibTeX entry:\n\n```\n@misc{nvvl,\n  author = {Jared Casper and Jon Barker and Bryan Catanzaro},\n  title = {NVVL: NVIDIA Video Loader},\n  year = {2018},\n  publisher = {GitHub},\n  journal = {GitHub repository},\n  howpublished = {\\url{https:\u002F\u002Fgithub.com\u002FNVIDIA\u002Fnvvl}}\n}\n```\n\n# Footnotes\n\n\u003Cb id=\"f1\">[1]\u003C\u002Fb> Specifically, with nvidia kernel modules version\n384 and later, which come with CUDA 9.0+, CUDA kernels launched by\nNVVL will run asynchronously on a separate stream. With earlier kernel\nmodules, all CUDA kernels are launched on the default stream. [↩](#a1)\n","# NVVL 是 DALI 的一部分！\n[DALI（Nvidia 数据加载库）](https:\u002F\u002Fdeveloper.nvidia.com\u002Fdali) 集成了 NVVL 的功能，并且提供了更多特性，因此建议切换到 DALI。\nDALI 的源代码也是开源的，可在 [GitHub](https:\u002F\u002Fgithub.com\u002FNVIDIA\u002FDALI) 上获取。\n最新的文档可以在这里找到：[DALI 开发者指南](https:\u002F\u002Fdocs.nvidia.com\u002Fdeeplearning\u002Fsdk\u002Fdali-developer-guide\u002Fdocs\u002Findex.html)。\nNVVL 项目仍将在 GitHub 上提供，但将不再维护。所有问题和未来的需求请在 [DALI 仓库](https:\u002F\u002Fgithub.com\u002FNVIDIA\u002FDALI\u002Fissues) 中提交。\n\n# NVVL\nNVVL（**NV**IDIA **V**ideo **L**oader）是一个用于从压缩视频文件中加载随机视频帧序列的库，以方便机器学习训练。它利用 FFmpeg 的库来解析和读取视频文件中的压缩数据包，并借助 NVIDIA GPU 上可用的视频解码硬件来卸载并加速这些数据包的解码过程，从而在 GPU 设备内存中生成可以直接用于训练的张量。NVVL 还可以在加载帧的同时进行数据增强。通过 GPU 专用的纹理映射单元，可以对帧进行缩放、裁剪和水平翻转。输出可以是 RGB 或 YCbCr 色彩空间，归一化到 [0, 1] 或 [0, 255]，并且可以是 `float`、`half` 或 `uint8` 类型的张量。\n\n**请注意，虽然我们希望您觉得 NVVL 很有用，但它实际上是 NVIDIA 一小群研究人员在一个研究项目中编写的示例代码。我们会尽力回答问题并修复出现的小 bug，但这并不是 NVIDIA 的正式支持产品，大部分情况下是以“原样”提供的。**\n\n与单独的帧图像文件相比，使用压缩视频文件可以显著降低训练过程中对存储和 I\u002FO 系统的要求。将视频数据集以视频文件形式存储，所需的磁盘空间会减少一个数量级，这样不仅可以让更大的数据集同时容纳在系统内存中，还可以存放在本地 SSD 上以便快速访问。在加载时，需要从磁盘读取的数据量也更少。将数据放置在更小、更快的存储设备上，并在加载时减少读取的数据量，可以缓解从磁盘获取数据的瓶颈问题——而随着 GPU 不断提速，这一瓶颈只会越来越严重。在我们的示例项目中使用的数据集里，H.264 压缩的 `.mp4` 文件比以 `.png` 格式存储帧要小近 40 倍。\n\n利用 NVIDIA GPU 上的硬件解码器来解码图像，可以显著减轻主机 CPU 的负担。这意味着在训练过程中，不需要分配那么多 CPU 核心来专门负责数据加载。这一点在每颗 CPU 对应大量 GPU 的服务器中尤为重要，例如 NVIDIA DGX-2 服务器，但对于其他平台也同样有益。当我们在 NVIDIA DGX-1 上训练示例项目时，使用 NVVL 时的 CPU 负载仅为使用常规 `.png` 文件数据加载器时负载的 50% 到 60%。\n\n量化使用 NVVL 性能优势的测量结果详细记录在我们的 [超分辨率示例项目](\u002Fexamples\u002Fpytorch_superres) 中。\n\n大多数用户会选择使用深度学习框架提供的封装接口，而不是直接使用该库。目前提供了 PyTorch 的封装接口（欢迎为其他框架贡献 PR）。有关如何使用 PyTorch 封装接口的文档，请参阅 [PyTorch 封装 README](\u002Fpytorch\u002FREADME.md)。需要注意的是，在构建 PyTorch 封装之前，无需手动构建或安装 C++ 库——其安装脚本会自动完成这些步骤。\n\n# 构建与安装\n\nNVVL 依赖于以下内容：\n- CUDA 工具包。我们已测试过 8.0 及更高版本，但早期版本也可能适用。使用 CUDA 9.0 或更高版本时，NVVL 的性能会更好\u003Csup id=\"a1\">[1](#f1)\u003C\u002Fsup>。\n- FFmpeg 的 libavformat、libavcodec、libavfilter 和 libavutil。这些库可以从源码安装，如 [示例 Dockerfile](\u002Fdocker) 所示，也可以从 Ubuntu 16.04 的软件包 `libavcodec-dev libavfilter-dev libavformat-dev libavutil-dev` 中获取。其他发行版也应有类似的软件包。\n\n此外，从源码构建还需要 CMake 3.8 或更高版本，某些示例可选地使用 OpenCV 的部分库（如果已安装）。\n\n[docker](docker) 目录包含可用于构建或使用 NVVL 库的 Dockerfile 示例。[示例项目的 docker 目录](examples\u002Fpytorch\u002Fdocker) 中有一个实际构建并安装 NVVL 库的 Dockerfile 示例。\n\nCMake 3.8 及以上版本内置了 CUDA 语言支持，NVVL 的构建系统正是利用这一特性。由于 CMake 3.8 较新，尚未广泛集成到主流 Linux 发行版中，可能需要安装新版本的 CMake。最简单的方法是通过 PyPI 安装：\n\n```\npip install cmake\n```\n\n或者，如果无法使用 `pip`，也可以从二进制分发包中安装到 `\u002Fusr\u002Flocal`：\n\n```sh\nwget https:\u002F\u002Fcmake.org\u002Ffiles\u002Fv3.10\u002Fcmake-3.10.2-Linux-x86_64.sh\n\u002Fbin\u002Fsh cmake-3.10.2-Linux-x86_64.sh --prefix=\u002Fusr\u002Flocal\n```\n\n更多选项请参见 https:\u002F\u002Fcmake.org\u002Fdownload\u002F。\n\nNVVL 的构建和安装遵循典型的 CMake 模式：\n\n```sh\nmkdir build && cd build\ncmake ..\nmake -j\nsudo make install\n```\n\n这将会把 `libnvvl.so` 和开发头文件安装到 `\u002Fusr\u002Flocal` 下的相应子目录中。可以通过 `cmake .. -DOPTION=Value` 向 CMake 传递以下选项：\n\n- `CUDA_ARCH` - 用于生成设备代码的 CUDA 架构名称，用分号分隔。有效选项包括 `Kepler`、`Maxwell`、`Pascal` 和 `Volta`。也可以指定具体的架构名称，如 `sm_61`。默认值为 `Maxwell;Pascal;Volta`。\n- `CMAKE_CUDA_FLAGS` - 传递给 `nvcc` 的编译参数字符串。例如，可以通过 `-cudart shared` 或 `-cudart static` 来选择链接静态或共享运行时库。还可以通过此选项对代码生成进行更精细的控制，具体请参考 `nvcc` 文档。默认值为 `-cudart shared`。\n- `WITH_OPENCV` - 设置为 1 以构建包含可选 OpenCV 功能的示例。\n- `CMAKE_INSTALL_PREFIX` - 安装目录。默认值为 `\u002Fusr\u002Flocal`。\n- `CMAKE_BUILD_TYPE` - 构建类型，可以是 `Debug` 或 `Release`。\n\n更多选项请参阅 [CMake 文档](https:\u002F\u002Fcmake.org\u002Fcmake\u002Fhelp\u002Fv3.8\u002F)。\n\n`doc\u002Fexamples` 目录下的示例可以通过 `examples` 目标进行构建：\n\n```sh\nmake examples\n```\n\n最后，如果已安装 Doxygen，可以通过 `doc` 目标构建 API 文档：\n\n```sh\nmake doc\n```\n\n这将会在 `doc\u002Fhtml` 目录下生成 HTML 文件。\n\n# 准备数据\n\nNVVL 支持 FFmpeg 能够解析的任何容器格式中的 H.264 和 HEVC（H.265）视频编解码器。视频编解码器在数据流中仅将某些帧（称为关键帧或 I 帧）存储为完整图像。其他所有帧都需要借助时间上在其之前或之后的其他帧的数据才能被解码。为了能够解码一串连续的帧，必须从该序列之前的关键帧开始解码，并一直持续到该序列之后的下一个关键帧。在顺序播放视频时，这通常不是问题；然而，当随机解码视频中分散的小段帧序列时，如果关键帧之间的间隔较大，则会导致读取和解码大量实际上并不会用到的帧。\n\n因此，为了在随机读取视频文件中的短序列时获得良好的性能，有必要以较频繁的关键帧间隔对视频进行编码。我们发现，将关键帧间隔设置为你计划读取的序列长度，可以在文件大小和加载性能之间取得较好的平衡。此外，NVVL 的查找逻辑不支持 HEVC 流中的开放 GOP 结构。使用 `ffmpeg` 时，要将关键帧间隔设置为 `X`：\n\n- 对于 `libx264`，使用 `-g X`\n- 对于 `libx265`，使用 `-x265-params \"keyint=X:no-open-gop=1\"`\n\n视频的像素格式还必须是 yuv420p，才能被硬件解码器支持。这可以通过向 `ffmpeg` 传递 `-pix_fmt yuv420p` 来实现。此外，你还应该通过在输入之后、输出之前向 `ffmpeg` 传递 `-map v:0`，来移除视频文件中多余的音频或视频流。\n\n例如，要转码为 H.264：\n```\nffmpeg -i original.mp4 -map v:0 -c:v libx264 -crf 18 -pix_fmt yuv420p -g 5 -profile:v high prepared.mp4\n```\n\n# 基本用法\n本节介绍基础 C\u002FC++ 库的用法。有关 PyTorch 封装库的使用，请参阅 pytorch 目录下的 [README](\u002Fpytorch\u002FREADME.md)。\n\n该库同时提供了 C++ 和 C 接口。有关如何使用该库的简要示例代码，请参阅 [doc\u002Fexamples](doc\u002Fexamples) 中的示例。[extract_frames.cpp](doc\u002Fexamples\u002Fextract_frames.cpp) 展示了 C++ 接口，而 [extract_frames_c.c](doc\u002Fexamples\u002Fextract_frames_c.c) 则展示了 C 接口。通过运行 `make doc` 构建的 API 文档是该 API 的权威参考。\n\n基本流程是创建一个 `VideoLoader` 对象，告知它要读取哪些帧序列，然后为其提供设备内存中的缓冲区，用于存放解码后的序列。在 C++ 中，创建视频加载器非常简单：\n\n```C++\nauto loader = NVVL::VideoLoader{device_id};\n```\n\n随后，你可以通过调用 `read_sequence` 来指定要读取的序列：\n\n```C++\nloader.read_sequence(filename, frame_num, sequence_length);\n```\n\n要接收解码器输出的帧，你需要创建一个 `PictureSequence` 对象，以指定你希望如何以及在哪里接收这些解码后的帧。首先，创建一个 `PictureSequence`，并指定要从解码器接收的帧数。请注意，此处指定的帧数不必与传递给 `read_sequence` 的序列长度相同；你可以读取一大段帧序列，并将其拆分为多个张量接收，或者读取多个较小的序列，然后将它们拼接成一个单一的张量接收。\n\n```C++\nauto seq = PictureSequence{sequence_count};\n```\n\n接下来，你需要在序列中创建“层”，以指定帧的存放目标。每层可以是不同的类型，具有不同的处理方式，并包含来自接收序列的不同帧。首先，创建所需类型的 `PictureSequence::Layer`：\n\n```C++\nauto pixels = PictureSequence::Layer\u003Cfloat>{};\n```\n\n然后，填写数据指针和其他详细信息。有关所有可用选项的描述，请参阅 [PictureSequence.h](include\u002FPictureSequence.h) 中的文档。\n\n```C++\nfloat* data = nullptr;\nsize_t pitch = 0;\ncudaMallocPitch(&data, &pitch,\n                crop_width * sizeof(float),\n                crop_height * sequence_count * 3);\npixels.data = data;\npixels.desc.count = sequence_count;\npixels.desc.channels = 3;\npixels.desc.width = crop_width;\npixels.desc.height = crop_height;\npixels.desc.scale_width = scale_width;\npixels.desc.scale_height = scale_height;\npixels.desc.horiz_flip = false;\npixels.desc.normalized = true;\npixels.desc.color_space = ColorSpace_RGB;\npixels.desc.stride.x = 1;\npixels.desc.stride.y = pitch \u002F sizeof(float);\npixels.desc.stride.c = pixels.desc.stride.y * crop_height;\npixels.desc.stride.n = pixels.desc.stride.c * 3;\n```\n\n请注意，这里我们设置了步幅，使得维度顺序为 “nchw”。通过适当设置步幅，也可以选择 “nhwc” 或其他任意维度顺序。另外，需要注意的是，层描述中的步幅是指元素的数量，而非字节数。\n\n现在，我们将这一层添加到我们的 `PictureSequence` 中，并将其发送给加载器：\n\n```C++\nseq.set_layer(\"pixels\", pixels);\nloader.receive_frames(seq);\n```\n\n调用 `receive_frames` 是异步操作。如果需要同步读取，可以使用 `receive_frames_sync`。当我们准备好使用这些帧时，可以在我们用于计算的 CUDA 流中插入一个等待事件：\n\n```C++\nseq.wait(stream);\n```\n\n这会在流 `stream` 中插入一个等待事件，导致在该流上启动的后续内核都会等待数据准备就绪。\n\nC 接口遵循非常相似的模式，具体示例请参阅 [doc\u002Fexamples\u002Fextract_frames_c.c](doc\u002Fexamples\u002Fextract_frames_c.c)。\n\n# 参考文献\n如果你在工作中觉得本库很有用，请在你的出版物中使用以下 BibTeX 条目引用本库：\n\n```\n@misc{nvvl,\n  author = {Jared Casper and Jon Barker and Bryan Catanzaro},\n  title = {NVVL: NVIDIA Video Loader},\n  year = {2018},\n  publisher = {GitHub},\n  journal = {GitHub repository},\n  howpublished = {\\url{https:\u002F\u002Fgithub.com\u002FNVIDIA\u002Fnvvl}}\n}\n```\n\n# 注释\n\n\u003Cb id=\"f1\">[1]\u003C\u002Fb> 具体来说，使用版本 384 及更高版本的 NVIDIA 内核模块（随 CUDA 9.0+ 提供）时，由 NVVL 启动的 CUDA 内核将在独立的流上异步执行。而在更早的内核模块中，所有 CUDA 内核都会在默认流上启动。[↩](#a1)","# NVVL 快速上手指南\n\n> **重要提示**：NVVL 项目已停止维护，其功能已完整集成至 **NVIDIA DALI** 库中。官方强烈建议新用户直接迁移至 [DALI](https:\u002F\u002Fdeveloper.nvidia.com\u002Fdali)。本指南仅适用于需要直接使用旧版 NVVL 源码的特定场景。\n\nNVVL (NVIDIA Video Loader) 是一个利用 NVIDIA GPU 硬件解码器加速视频加载的库，专为机器学习训练设计。它能直接从压缩视频文件（如 MP4）中读取随机帧序列，显著降低存储占用和 CPU 负载。\n\n## 环境准备\n\n### 系统要求\n- **操作系统**：Linux (推荐 Ubuntu 16.04+)\n- **GPU**：支持硬件解码的 NVIDIA GPU (Kepler, Maxwell, Pascal, Volta 架构及以上)\n- **CUDA Toolkit**：版本 8.0+ (推荐 9.0+ 以获得更佳性能)\n\n### 前置依赖\n安装 FFmpeg 开发库和构建工具。\n\n**Ubuntu\u002FDebian:**\n```bash\nsudo apt-get update\nsudo apt-get install -y libavcodec-dev libavfilter-dev libavformat-dev libavutil-dev cmake build-essential\n```\n\n**安装 CMake (若源中版本低于 3.8):**\n```bash\npip install cmake\n# 或者手动安装二进制包\n# wget https:\u002F\u002Fcmake.org\u002Ffiles\u002Fv3.10\u002Fcmake-3.10.2-Linux-x86_64.sh\n# \u002Fbin\u002Fsh cmake-3.10.2-Linux-x86_64.sh --prefix=\u002Fusr\u002Flocal\n```\n\n## 安装步骤\n\n从源码编译并安装 NVVL：\n\n```bash\n# 克隆仓库 (假设已下载或 git clone)\n# cd nvvl\n\nmkdir build && cd build\ncmake .. -DCUDA_ARCH=\"Maxwell;Pascal;Volta\"\nmake -j\nsudo make install\n```\n\n**可选配置参数：**\n- `CUDA_ARCH`: 指定生成的 CUDA 架构代码 (默认: `Maxwell;Pascal;Volta`)\n- `WITH_OPENCV`: 设为 `1` 以构建包含 OpenCV 功能的示例\n- `CMAKE_BUILD_TYPE`: 设为 `Debug` 或 `Release`\n\n## 数据准备 (关键)\n\n为了在随机读取短序列时获得最佳性能，视频必须编码为**频繁的关键帧 (Keyframes)**，且像素格式必须为 `yuv420p`。\n\n使用 FFmpeg 转码示例 (设置关键帧间隔为 5)：\n\n**H.264 编码:**\n```bash\nffmpeg -i original.mp4 -map v:0 -c:v libx264 -crf 18 -pix_fmt yuv420p -g 5 -profile:v high prepared.mp4\n```\n\n**HEVC (H.265) 编码:**\n```bash\nffmpeg -i original.mp4 -map v:0 -c:v libx265 -crf 18 -pix_fmt yuv420p -x265-params \"keyint=5:no-open-gop=1\" prepared.mp4\n```\n\n## 基本使用\n\n大多数用户建议使用 PyTorch 封装器（见 `\u002Fpytorch\u002FREADME.md`）。以下是直接使用 C++ 接口的核心流程：\n\n1. 创建 `VideoLoader`。\n2. 调用 `read_sequence` 指定要读取的文件和帧范围。\n3. 创建 `PictureSequence` 并配置输出层（Layer），包括显存指针、尺寸、缩放、归一化等。\n4. 调用 `receive_frames` 异步获取数据。\n\n**C++ 代码示例:**\n\n```cpp\n#include \u003Cnvvl\u002Fvideo_loader.h>\n#include \u003Cnvvl\u002Fpicture_sequence.h>\n#include \u003Ccuda_runtime.h>\n\n\u002F\u002F 1. 初始化加载器 (device_id 为 GPU ID)\nauto loader = NVVL::VideoLoader{0};\n\n\u002F\u002F 2. 请求读取序列 (文件路径，起始帧号，序列长度)\nloader.read_sequence(\"prepared.mp4\", 10, 5);\n\n\u002F\u002F 3. 配置接收缓冲区\nint sequence_count = 5;\nint crop_width = 224;\nint crop_height = 224;\n\nauto seq = PictureSequence{sequence_count};\nauto pixels = PictureSequence::Layer\u003Cfloat>{};\n\n\u002F\u002F 分配显存\nfloat* data = nullptr;\nsize_t pitch = 0;\ncudaMallocPitch(&data, &pitch,\n                crop_width * sizeof(float),\n                crop_height * sequence_count * 3);\n\n\u002F\u002F 配置 Layer 描述\npixels.data = data;\npixels.desc.count = sequence_count;\npixels.desc.channels = 3;\npixels.desc.width = crop_width;\npixels.desc.height = crop_height;\npixels.desc.scale_width = crop_width;   \u002F\u002F 如需缩放可修改此处\npixels.desc.scale_height = crop_height;\npixels.desc.horiz_flip = false;         \u002F\u002F 是否水平翻转\npixels.desc.normalized = true;          \u002F\u002F 归一化到 [0, 1]\npixels.desc.color_space = ColorSpace_RGB;\n\n\u002F\u002F 设置步长 (Stride)，此处示例为 NCHW 格式\npixels.desc.stride.x = 1;\npixels.desc.stride.y = pitch \u002F sizeof(float);\npixels.desc.stride.c = pixels.desc.stride.y * crop_height;\npixels.desc.stride.n = pixels.desc.stride.c * 3;\n\n\u002F\u002F 将 Layer 添加到序列\nseq.set_layer(\"pixels\", pixels);\n\n\u002F\u002F 4. 异步接收帧数据\nloader.receive_frames(seq);\n\n\u002F\u002F 5. 同步等待 (在 CUDA stream 中插入事件，确保数据就绪后再进行计算)\ncudaStream_t stream; \u002F\u002F 假设已创建流\nseq.wait(stream);\n\n\u002F\u002F ... 后续进行模型训练推理 ...\n```\n\n*注：完整的 C 和 C++ 示例代码请参考源码目录 `doc\u002Fexamples\u002F` 下的 `extract_frames.cpp` 和 `extract_frames_c.c`。*","某计算机视觉团队正在利用大规模监控视频数据集训练动作识别模型，面临海量视频数据加载的效率瓶颈。\n\n### 没有 nvvl 时\n- **存储压力巨大**：团队需将视频拆解为数百万张 PNG 图片，导致数据集体积膨胀近 40 倍，本地 SSD 迅速爆满，难以容纳更多样本。\n- **I\u002FO 成为瓶颈**：训练过程中磁盘需频繁读取大量小文件，数据传输速度远跟不上 GPU 计算速度，导致显卡长期处于空闲等待状态。\n- **CPU 负载过高**：软件解码极度消耗主机 CPU 资源，在单 CPU 多卡服务器上，数据预处理占用了大部分算力，严重挤占了模型训练资源。\n- **流程繁琐复杂**：预处理阶段需额外花费数天时间进行视频抽帧和格式转换，且无法在训练中灵活调整增强策略。\n\n### 使用 nvvl 后\n- **存储空间释放**：直接读取压缩的 MP4 视频文件，数据集占用空间缩小至原来的 1\u002F40，轻松将更大规模数据集载入高速存储。\n- **消除 I\u002FO 瓶颈**：nvvl 仅读取少量压缩字节，大幅降低磁盘读写需求，确保数据供给速度匹配高端 GPU 的吞吐能力。\n- **CPU 负载减半**：利用 NVIDIA GPU 硬件解码器卸载解码任务，CPU 占用率降低约 50%，释放出更多核心用于其他系统任务。\n- **实时增强加速**：在加载帧的同时直接通过 GPU 纹理单元完成缩放、裁剪和翻转等增强操作，省去了独立的预处理环节。\n\nnvvl 通过硬件加速解码与压缩流直接读取，彻底解决了视频深度学习中的存储与算力浪费问题，让训练效率提升数倍。","https:\u002F\u002Foss.gittoolsai.com\u002Fimages\u002FNVIDIA_nvvl_3d866b3c.png","NVIDIA","NVIDIA Corporation","https:\u002F\u002Foss.gittoolsai.com\u002Favatars\u002FNVIDIA_7dcf6000.png","",null,"https:\u002F\u002Fnvidia.com","https:\u002F\u002Fgithub.com\u002FNVIDIA",[81,85,89,93,97,101,104,107],{"name":82,"color":83,"percentage":84},"C++","#f34b7d",98,{"name":86,"color":87,"percentage":88},"Python","#3572A5",1,{"name":90,"color":91,"percentage":92},"Shell","#89e051",0.5,{"name":94,"color":95,"percentage":96},"C","#555555",0.3,{"name":98,"color":99,"percentage":100},"CMake","#DA3434",0.1,{"name":102,"color":103,"percentage":100},"Cuda","#3A4E3A",{"name":105,"color":106,"percentage":100},"Dockerfile","#384d54",{"name":108,"color":109,"percentage":110},"Makefile","#427819",0,694,84,"2025-12-21T16:02:49","NOASSERTION",4,"Linux","必需 NVIDIA GPU（支持 Kepler, Maxwell, Pascal, Volta 架构或更新），需安装 CUDA Toolkit（测试过 8.0+，推荐 9.0+ 以获得更好性能），利用硬件解码器加速","未说明（文中提及视频压缩可让数据集更适配系统 RAM，但未给出具体数值）",{"notes":120,"python":121,"dependencies":122},"1. 该项目已停止维护，功能已合并至 DALI (Nvidia Data Loading Library)，建议用户迁移至 DALI。2. 视频文件必须编码为 H.264 或 HEVC (H.265)，像素格式必须为 yuv420p 才能被硬件解码器支持。3. 为了随机读取短序列时的性能，编码时需设置频繁的关键帧（keyframe interval）。4. HEVC 流不支持 open GOPs。5. 默认安装路径为 \u002Fusr\u002Flocal。","未说明（主要提供 C\u002FC++ 接口，PyTorch 封装通过 setup 脚本自动构建，未指定具体 Python 版本）",[123,124,125,126,127],"CUDA Toolkit >= 8.0","FFmpeg (libavformat, libavcodec, libavfilter, libavutil)","CMake >= 3.8","PyTorch (可选，用于使用封装器)","OpenCV (可选，用于构建示例)",[129,14],"视频","2026-03-27T02:49:30.150509","2026-04-18T00:47:17.456545",[],[]]