diff --git a/.agents/docs/2026-07-18-ffmpeg-m-implementation.md b/.agents/docs/2026-07-18-ffmpeg-m-implementation.md new file mode 100644 index 0000000..40f657b --- /dev/null +++ b/.agents/docs/2026-07-18-ffmpeg-m-implementation.md @@ -0,0 +1,129 @@ +# ffmpeg-m 实现记录(v0.0.1,全功能档) + +> 日期: 2026-07-18 +> 前置: 同目录 `2026-07-18-ffmpeg-m-research-and-plan.md`(决策点按推荐执行,用户确认) +> 状态: `mcpp build` + `mcpp test`(2 passed)+ 双示例 + 模板 全绿 + +## 交付形态 + +- **全功能档一步到位**(用户要求 100% 全功能,替代原 F1 的 decode-min 档): + configure = `--disable-autodetect --disable-programs --disable-doc`,其余全默认 + → **2281 源(2124 .c + 157 .asm)**,600+ decoders / 272 encoders / 358 demuxers + / muxers / filters / v4l2·fbdev·oss 设备,LGPL-2.1+,零宿主库依赖。 +- **冷构建 ≈ 21s**(32 核,gcc 16.1.0 + nasm 3.02,均由 mcpp/xlings 解析)。 +- 模块:`ffmpeg.av`(伞,对标 PyAV `import av`)+ 7 库模块(依赖 `export import` + 镜像库拓扑)+ lib-root `ffmpeg`。**C API 全局原名重导出,用法零迁移**。 +- 导出面(生成器统计):函数 978 / struct 194 / typedef 15 / enum 76 / + 枚举常量 1450;`static inline`(内部链接,不可导出)与宏走 + `include/ffmpeg-m/macros.h` 伴随头(include **在 import 之前**)。 +- C-only 复合字面量宏的 C++ 替代:`av_err2string` / `av_ts2string` / + `av_ts2timestring` / `av_fourcc2string`(模块导出,含小型 RAII 缓冲结构)。 + +## 工具链(三个生成器,升级 FFmpeg 只需重跑) + +1. `tools/gen_config.sh` — 打包期 configure(out-of-tree)→ 快照 + `gen/linux-x86_64/`:config.h、config_components.{h,asm}、config.asm、 + avconfig.h、ffversion.h(相对路径调用 version.sh,避免非法 guard)、 + 9 个 `*_list.c`(被 allcodecs.c 等文本 include)。 +2. `tools/gen_sources.py` — 解析 `make -n` 输出(ground truth)重写 mcpp.toml + 标记区间的 sources;diff 即升级审计面。 +3. `tools/gen_exports.py` — 解析各库 Makefile `HEADERS` 块所列安装头 → + `src/gen_exports/.{inc,includes.inc,skipped.txt}`。分类:函数(排 + static)/struct·union tag/typedef/enum tag/枚举常量 → `export using`; + 排除:宏名冲突实体(如 av_alloc_size)、SDK 门控头(hwcontext_*、vdpau + 等,FFmpeg **无条件安装**它们但 hermetic 档编不了)。 + +## mcpp.toml 关键机制(0.0.95 新能力全部用上) + +- `.asm` 一等公民:157 个 NASM 文件直接进 sources;per-glob `asmflags` + 提供 `-I`(全列、带尾斜杠;NASM 无文件相对搜索)+ `-Pconfig.asm`。 +- per-glob flags:三方 `-w` 告警隔离;子目录库(libavcodec/{aac,bsf,hevc, + opus,vvc},上游 8.x 新结构)加 `-I<库根>`;每库 `BUILDING_` define + (对应 ffbuild/library.mak)。 +- `include/` 显式入 include_dirs(伴随头 ``)。 + +## 实现期踩坑(均已解决,后来者注意) + +1. mcpp.toml 的 flags 内联表**不能跨行**(严格 TOML,`[[build.flags]]` 数组表 + 报 not supported → 已提 [mcpp#227](https://github.com/mcpp-community/mcpp/issues/227)); + glob **不支持 `{a,b}` 花括号**(会警告 matched-no-source——0.0.95 的防呆 + 设计帮了忙 → 已提 [mcpp#228](https://github.com/mcpp-community/mcpp/issues/228))。 +2. 模块 TU(C++)编 FFmpeg 头需要 `-D__STDC_CONSTANT_MACROS`(上游 CXXFLAGS + 同款),否则 common.h 直接 #error。 +3. 子目录源的引号 include:**用上游同款 per-lib `-I`**;`-iquote` 在 mcpp + 0.0.95 不做项目根相对重写(只有 `-I` 会被绝对化)——避免用 + (→ 已提 bug [mcpp#226](https://github.com/mcpp-community/mcpp/issues/226))。 +4. gcc≥14 `implicit-function-declaration` 默认硬错:`-I` 全局加 + 会让 `#include ` 角括号劫持到 libavutil/time.h(nanosleep 消失), + 所以 per-lib `-I` 只能按上游范围给子目录库,不能全局。 +5. 生成器 bug 教训:带函数指针**字段**的 struct typedef(AVCodecContext、 + AVInputFormat)曾被误判为函数指针 typedef 而漏导出——fp 分支必须限定 + `not had_body`。 +6. 消费 TU 的 include 顺序:**macros.h 必须在 import 之前**(include-after- + import 在 gcc16 实测触发 av_make_q 不可见;与调研结论一致)。 +7. MOV 容器 quirk:合成 5 帧 MJPEG clip,mov demuxer 只返回 4 包(mkv 正常 + 5/5)——上游容器行为,与模块层无关;roundtrip 测试用 matroska。 + +### 复验澄清(2026-07-18,mcpp 0.0.95) + +提 issue 前逐条复验,以下两项在 0.0.95 上**已不复现**(0.0.93 时代的记录不再成立,勿再引用): + +- `[build].cxxflags` 相对 `-I` 对 `.cppm` 模块 TU:现已生效; +- sources glob 经目录软链接(含 `**`、链接到项目外):现已跟随。 + +确认为 mcpp 侧问题并已提交:[#226](https://github.com/mcpp-community/mcpp/issues/226)(bug:`-iquote` 相对路径不重写)、[#227](https://github.com/mcpp-community/mcpp/issues/227)(增强:`[[build.flags]]` 数组表)、[#228](https://github.com/mcpp-community/mcpp/issues/228)(增强:glob 花括号交替 / glob 数组)。其余踩坑属 FFmpeg 上游(MOV quirk、`__STDC_CONSTANT_MACROS`)、编译器生态(include-before-import)或本仓生成器自身(函数指针字段误判),不涉及 mcpp。 + +## 验证 + +- `mcpp test`:`api_surface_test`(版本号、全解码器集 h264/hevc/av1/vp9/aac/ + opus/flac、enum/类型可用性、宏头共存、av_err2string)+ `roundtrip_test` + (encode MJPEG→mkv→decode,逐帧亮度均值断言 63+16i±3)。 +- `examples/probe`(path-dep 消费者):输出 avutil 60.26 / avcodec 62.28 / + avformat 62.12,358 demuxers,全解码器 ok。 +- `examples/decode_frames` + `templates/decode`(imgui-m 式 template.toml + + mcpp.toml.in + src/main.cpp.in)。 + +## 后续(不阻塞发版) + +- 平台矩阵:aarch64(`.S` 走 cc 驱动,gen/ 双快照 + cfg 条件 + sources)、macOS、musl。 +- features:按档位(slim/decode-only、GPL 部件显式翻转 license、外部编解码 + 器 compat.* 依赖)= 每档一套 gen/ 快照 + 源列表;等 mcpp feature 条件 + include_dirs 或用 defines 方案定案。 +- opencv-m F2 集成:videoio `cap_ffmpeg` 依赖本包(HAVE_FFMPEG 快照翻转)。 +- mcpp-index 登记(Form-A,tag tarball)。 + +## 追记:compat 拆分(2026-07-18,用户决策) + +用户 review 后决定采用生态正统的两层拆分(imgui-m 模式),替代 vendor: + +- **compat.ffmpeg 8.1.2** 进 mcpp-index(PR #74):新形态"全源码直编"—— + configure 产物冻结为描述符 `generated_files`(15 文件 ≈240KB)+ `make -n` + 源列表(2281 TU 含 157 .asm),per-glob flags 承载 BUILDING_*/-Pconfig.asm; + NASM 的 -I 由 mcpp 从 include_dirs 自动馈送。官方 ffmpeg.org tarball + (sha256 稳定)+ CN 镜像 mcpp-res/ffmpeg(gtc,已验证字节一致)。linux-only + (compat.x11 先例);CI pin 0.0.94→0.0.95(flags 是 0.0.95 语法)。 +- **ffmpeg-m 最小化**:移除 third_party/(112MB)与 gen/,mcpp.toml 只剩模块层 + + `compat.ffmpeg = "8.1.2"` 依赖;工具重构为 fetch_upstream.sh(官方 tarball + 钉版)→ gen_config.sh(configure→描述符流水线)→ gen_descriptor.py; + gen_sources.py 删除(职责并入描述符生成)。 +- 验证:min 化后 `mcpp build`(compat.ffmpeg 从本地 index 解析编译)+ + `mcpp test` 2 passed + 双 examples 全过;157 `.asm.o`、3260 SIMD 符号进链。 +- CI 桥接:在 index artifact 发布 compat.ffmpeg 前,ci.yml 以 mcpp-index + checkout 作为 [indices] 注入(标记 TEMPORARY,发布后移除)。 + +## Addendum — post-publication slim (2026-07-18) + +mcpp-index #74 merged and the index artifact republished, so the repo was cut +down to the pure module layer: + +- CI bridge step (`[indices]` injection from a mcpp-index checkout) removed — + `compat.ffmpeg` now resolves from the published default index (verified by a + cold no-override consumer build: download 16.9 MB official tarball → full + source build → `avutil 8.1.2`). +- Descriptor pipeline (`tools/gen_config.sh`, `tools/gen_descriptor.py`) and + the macOS packaging-snapshot CI job move to mcpp-index `tools/compat-ffmpeg/` + next to the descriptor they generate. This repo keeps `fetch_upstream.sh` + + `gen_exports.py` (export-surface regeneration only). +- Stray tracked `third_party/ffmpeg/tests/ref/fate/*` leftovers from the + vendored era deleted. diff --git a/.agents/docs/2026-07-18-ffmpeg-m-research-and-plan.md b/.agents/docs/2026-07-18-ffmpeg-m-research-and-plan.md new file mode 100644 index 0000000..3c517c6 --- /dev/null +++ b/.agents/docs/2026-07-18-ffmpeg-m-research-and-plan.md @@ -0,0 +1,244 @@ +# ffmpeg-m — FFmpeg 源码构建 + C++ 模块封装:调研 + 规划文档 + +> **状态**: 待 review(决策点见 §5) +> **日期**: 2026-07-18 +> **前置**: 本项目由 opencv-m 规划派生(用户指定 FFmpeg 先行);opencv-m 侧文档见 +> `github/opencv-m/.agents/docs/2026-07-17-opencv-m-research-and-plan.md` 与同日 `mcpp-feature-requests.md`(G 清单已随 mcpp 0.0.95 全部落地) + +**Goal:** 把 FFmpeg(n8.1.2)打包为 mcpp 包 `ffmpeg`:FFmpeg 源码单独 vendor 一个目录,由 **mcpp 直接源码构建**(构建期零 `./configure`/make),含 x86 NASM 汇编;外加 C++ 模块封装层,使用者 `import ffmpeg.av;`(或按库 `import ffmpeg.avcodec;`),**C API 原名原样,不改任何使用习惯**。服务两类用户:独立音视频开发 + opencv-m videoio 的 FFmpeg 后端。 + +**Architecture:** 与 opencv-m 同构的三件套——`third_party/ffmpeg/`(上游源码原样)+ `gen//`(configure 一次性快照,纯文本)+ `src/*.cppm`(GMF `extern "C" #include` + `export using` 重导出)。源列表由 `make -n` 机械推导(工具脚本固化)。 + +**Tech Stack:** mcpp ≥ 0.0.95(汇编一等公民 / per-glob flags / features.sources / build.mcpp 依赖执行——本项目全部用得上)/ nasm 3.02(xlings)/ gcc 16.1.0 / FFmpeg n8.1.2(2026,LGPL-2.1+ 默认) + +--- + +## 1. 可行性验证(F0 POC,已全部跑通,2026-07-18) + +**两轮 spike 均端到端通过**(scratchpad `spike-ff/`): + +| 轮次 | 配置 | 源文件 | 结果 | +|---|---|---|---| +| ① 纯 C | `--disable-x86asm`,h264+mov+file 最小档 | 223 个 `.c` | `mcpp run` → `avformat=4066406 avcodec=4070502 h264_open=0` ✓ | +| ② x86 汇编 | 同上 + x86asm | 263 源(含 **27 个 `.asm`**) | 运行同 ✓;最终二进制含 **333 个 ssse3/avx2 符号**(如 `avg_h264_chroma_mc8_*_ssse3`),NASM 产物实锤进链 | + +消费端代码(验证"习惯不变"): + +```cpp +import std; +import ffmpeg.av; +int main() { + const AVCodec* dec = avcodec_find_decoder_by_name("h264"); // C API 原名 + AVCodecContext* ctx = avcodec_alloc_context3(dec); + int rc = avcodec_open2(ctx, dec, nullptr); // rc == 0 + ... +} +``` + +POC 期间确认的关键事实: + +1. **`make -n` 是可靠的源列表推导器**:configure 后 `make -n` 输出全部编译命令,正则抽取 `.c/.S/.asm` 即得精确清单(223/263 个),含生成文件的引用关系。 +2. **mcpp 0.0.95 的 `.asm` 一等公民支持工作正常**:`-f elf64` 自动按目标推导;`asmflags` 经 per-glob `flags` 传入(`-I` 与 `-Pconfig.asm`);nasm 从 xlings 解析。 +3. **汇编需要两个快照文件**:`config.asm` **和 `config_components.asm`**(后者由 `.asm` 文件自行 `%include`,漏拷会报 `CONFIG_*_DECODER not defined`——第一轮踩坑实录)。 +4. `ffversion.h` 由 `ffbuild/version.sh` 在 **make 期**生成(非 configure 期),快照时需以相对路径调用避免生成非法 include guard(POC 踩坑:绝对路径出 `GEN_AVUTIL/FFVERSION_H` 这种带 `/` 的宏名)。 +5. FFmpeg TU 编译要素:`c_standard = "c17"`、`-DHAVE_AV_CONFIG_H` + configure 的 CPPFLAGS 组(`-D_ISOC11_SOURCE -D_FILE_OFFSET_BITS=64 ...`)、`-pthread`、链接 `-lpthread -lm`。 +6. mcpp 同名基名对象(3 个库各有 `utils.c`/`version.c`)无冲突,263 TU 并行冷构建秒级(32 核)。 + +## 2. 调研:FFmpeg n8.1.2 源码与构建结构 + +### 2.1 库结构(7 个库,**libpostproc 已不存在**) + +依赖拓扑:`avutil ← {swscale, swresample, avcodec} ← avformat ← avdevice`;avfilter ← avutil(scale 滤镜额外用 swscale)。 + +| 库 | .c | .asm(NASM) | .S(GAS) | 角色 | +|---|---|---|---|---| +| libavutil | 196 | 12 | 14+ | 基础:mem/error/frame/buffer/pixfmt/opt/dict/tx | +| libavcodec | 1626 | 111 | 176 | 编解码器/parser/BSF/DSP,绝对大头 | +| libavformat | 592 | 0 | 0 | (de)muxer + protocol(avio) | +| libavfilter | 594 | 41 | 5 | 滤镜图(最小档不需要) | +| libswscale | 72 | 11 | 21 | 像素格式转换/缩放 | +| libswresample | 26 | 3 | 4 | 音频重采样 | +| libavdevice | 50 | 0 | 0 | 采集/渲染设备(不需要) | + +全树 ≈ 3156 `.c` / 1146 `.h` / **178 `.asm`** / 218 `.S`,约 170 万 LOC。组件宇宙:**607 decoders / 272 encoders / 68 parsers / 366 demuxers / 184 muxers / 54 protocols / 593 filters**——`--disable-everything` 后按需 opt-in。 + +**最小 "解码 mp4/h264 + 缩放" 档只需 4 库**:avutil + avcodec + avformat + swscale(直接用 swscale API,不必进 avfilter)。 + +### 2.2 生成文件全集(configure 产出,全部可快照) + +| 文件 | 谁需要 | 说明 | +|---|---|---| +| `config.h` / `config_components.h` | 编译 FFmpeg 自身 | 所有 TU 带 `-DHAVE_AV_CONFIG_H`;公共头对 config.h 的引用全部有 `#ifdef HAVE_AV_CONFIG_H` 门 | +| `config.asm` / `config_components.asm` | 编译 `.asm` | `-Pconfig.asm` 预включ + `.asm` 自行 `%include` 后者 | +| `libavutil/avconfig.h` | **消费者也需要**(唯一) | 被 `bswap.h/macros.h/intreadwrite.h/pixfmt.h` 无条件 include;按 arch 有差异(`AV_HAVE_BIGENDIAN`) | +| `libavutil/ffversion.h` | 编译 version.c | make 期由 version.sh 生成,快照即冻结版本串 | +| `*_list.c` ×9(codec/parser/bsf/demuxer/muxer/protocol/filter/indev/outdev) | 编译对应注册 TU | **被 `allcodecs.c` 等文本 `#include`,不单独编译**;由 configure 的 `print_enabled_components()` 生成 | +| `ffbuild/config.mak`、`config.sh`、`.pc`、`.ver` | 仅上游 make/共享库 | mcpp 构建不需要 | + +**与 OpenCV 的对应关系工整**:消费者可见的生成头 OpenCV 是 `opencv_modules.hpp`,FFmpeg 是 `avconfig.h`;编译期快照集 OpenCV 是 cvconfig.h+simd_declarations,FFmpeg 是 config.h+config_components+list.c 族。同一套 `gen/` 方法论完全复用。 + +### 2.3 源选择机制与推导 + +`lib*/Makefile` 里 `OBJS-$(CONFIG_H264_DECODER) += h264dec.o ...`、`X86ASM-OBJS-$(CONFIG_H264QPEL) += x86/h264_qpel.o`;`ffbuild/arch.mak` 按 `HAVE_X86ASM` 等收编 arch 对象;组件间 `_select` 链传递(h264 → cabac/golomb/h264dsp/...)。**推导方法定为 `make -n` 解析**(configure 后一次,ground truth,工具脚本 `tools/gen_sources.py` 固化),不做 Makefile 静态解析(要复现 `_select` 闭包,费而不稳)。 + +### 2.4 汇编机制 + +- x86:NASM 语法 `.asm`,共享基建 `libavutil/x86/{x86inc.asm,x86util.asm}`,上游 flags = `-f elf64 -I/ -I<文件所在目录>/ -Pconfig.asm`(`ffbuild/common.mak:55`)。**注意 NASM 不做文件相对搜索**,`-I` 必须给全(root、各库 `x86/` 目录),目录要带尾斜杠。 +- ARM/AArch64/RISC-V:GAS 语法 `.S`(带 C 预处理),由 C 编译器驱动直接汇编——mcpp 0.0.95 的 `.S` 支持覆盖,后续做 aarch64 时启用。 +- **纯 C 兜底是上游一等机制**:`HAVE_X86ASM=0` 时 `x86/*_init.c` 根本不编译,DSP 函数指针保持 C 实现——`--disable-x86asm` 即得 100% 纯 C 构建,这是我们跨平台/降级的正确性基线。 + +### 2.5 对 C++ 模块封装的地形 + +- **C17**,C11 起步(stdatomic/_Generic/复合字面量);Linux/glibc 下 `COMPAT_OBJS` 为空。 +- **公共头大多没有 `extern "C"` 守卫**(仅 8 个头有 `__cplusplus` 块)——封装层 GMF 里必须自套 `extern "C" { #include ... }`(POC 已如此,工作正常)。 +- **C-only 复合字面量宏**(C++ 下连传统 `#include` 都不能用,模块层反而是改善机会):`av_err2str`、`av_ts2str`、`av_ts2timestr`、`av_fourcc2str`——封装层导出 inline C++ 等价物(如 `av_err2string() -> std::string`)。`AV_TIME_BASE_Q` 上游已有 `__cplusplus` 分支,安全。 +- **C++ 安全的常用宏**:`AVERROR(e)`、`MKTAG`、`AV_VERSION_INT`、`AVERROR_*`、`av_q2d` 等(rational 族是 static inline 函数)→ 常量宏转 `inline constexpr` 导出 + 函数式宏放伴随头 `ffmpeg-m/macros.h`。 +- 符号全带 `av_/avcodec_/avformat_/sws_/swr_` 前缀,无命名空间冲突压力 → **全局原名重导出**成立。 + +### 2.6 许可证(LGPL 合规) + +默认 **LGPL v2.1+**(不传 `--enable-gpl/version3/nonfree`);最小解码档(h264/hevc/aac + mov/mkv/mpegts + file + swscale)全部 LGPL 干净。**源码分发形态天然满足 LGPL 静态链接的"可重链接"要求**(消费者本来就从源码构建)。GPL 部件(个别 asm、滤镜)未来若做 feature 必须显式翻转 license 标注,默认永不启用。 + +## 3. 设计 + +### 3.1 仓库布局 + +```text +ffmpeg-m/ +├── mcpp.toml # 单包: name = "ffmpeg" +├── third_party/ffmpeg/ # n8.1.2 源码, 原封不动 (git subtree) +├── gen/ +│ └── linux-x86_64/ # 每 (os,arch) 一份快照 +│ ├── config.h config_components.h config.asm config_components.asm +│ ├── libavutil/{avconfig.h, ffversion.h} +│ ├── libavcodec/{codec_list.c, parser_list.c, bsf_list.c} +│ └── libavformat/{demuxer_list.c, muxer_list.c, protocol_list.c} +├── sources.lock/ # tools/gen_sources.py 产物: 每档位每平台的精确源列表 +│ └── linux-x86_64.toml # (mcpp.toml include 或生成进 [build].sources) +├── src/ +│ ├── ffmpeg.cppm # lib-root: export import ffmpeg.av; +│ ├── av.cppm # 汇总模块 ffmpeg.av (= export import 各库模块) +│ ├── avutil.cppm avcodec.cppm avformat.cppm swscale.cppm +│ └── */exports.inc # 生成 + 人工白名单叠加的导出清单 +├── include/ffmpeg-m/macros.h # AVERROR 等函数式宏伴随头 (可选 include) +├── tools/ +│ ├── gen_config.sh # 打包期一次性: configure → 快照 gen/ (含 ffversion.h 正确生成) +│ └── gen_sources.py # make -n 解析 → 源列表 +├── patches/ # 目前为空 +├── examples/ tests/ docs/ .agents/docs/ +``` + +### 3.2 模块命名(对标 Python 生态的 `import av` / PyAV) + +- 按库:`ffmpeg.avutil` / `ffmpeg.avcodec` / `ffmpeg.avformat` / `ffmpeg.swscale`(后续 `ffmpeg.avfilter`、`ffmpeg.swresample`、`ffmpeg.avdevice`) +- 汇总:**`ffmpeg.av`**(`export import` 全部启用库)——消费者默认入口 +- lib-root:`src/ffmpeg.cppm`(mcpp 惯例,`export import ffmpeg.av;`) + +### 3.3 导出策略:全局原名重导出 + +```cpp +module; +extern "C" { +#include +} +export module ffmpeg.avformat; +export using ::AVFormatContext; +export using ::avformat_open_input; // 原名, 零迁移 +... +``` + +C API 无重载/模板/命名空间,`export using` 全兼容。**枚举常量**(`AV_CODEC_ID_*` 等,无链接的 enumerator)是唯一需要验证的角落——P1 里实测 gcc 对 `export using ::AV_CODEC_ID_H264` 的处理,不行则退 `inline constexpr`(imgui-m 已有先例)。导出清单由脚本从公共头枚举生成(头面小:avformat 4 个头、avcodec 25、swscale 3;avutil 99 个头按需白名单),人工段叠加。 + +### 3.4 mcpp.toml 关键机制(0.0.95 能力全用上) + +```toml +[package] +name = "ffmpeg" + +[build] +c_standard = "c17" +include_dirs = ["gen/linux-x86_64", "gen/linux-x86_64/libavcodec", + "gen/linux-x86_64/libavformat", "third_party/ffmpeg"] +cflags = ["-DHAVE_AV_CONFIG_H", "-D_ISOC11_SOURCE", "-D_FILE_OFFSET_BITS=64", + "-D_LARGEFILE_SOURCE", "-D_POSIX_C_SOURCE=200112", "-D_XOPEN_SOURCE=600", + "-DPIC", "-fomit-frame-pointer", "-fno-math-errno", "-fno-signed-zeros", "-pthread"] +ldflags = ["-lpthread", "-lm"] +flags = [ + { glob = "third_party/ffmpeg/**", cflags = ["-w"] }, # 三方告警隔离, 封装层保持告警 + { glob = "third_party/ffmpeg/**/*.asm", + asmflags = ["-Igen/linux-x86_64/", "-Ithird_party/ffmpeg/", + "-Ithird_party/ffmpeg/libavcodec/x86/", "-Ithird_party/ffmpeg/libavutil/x86/", + "-Pconfig.asm"] }, +] +# sources = 显式清单(sources.lock 生成), 汇编 .asm 仅 x86 目标(cfg 条件 sources 门控) +``` + +平台矩阵靠 cfg 条件 sources / `[target.'cfg(...)']`(0.0.95)选择 `gen//` 与对应源列表;v0.1 只做 linux-x86_64。 + +### 3.5 组件档位与 features + +配置快照是**冻结的**——任意组件组合意味着任意 config_components.h,无法用 additive features 表达。因此: + +- **v0.1 固定一个档位 `decode-min`**:decoders h264/hevc/aac(+mpeg4 待定)、parsers 同名、demuxers mov/matroska/mpegts、protocol file、swscale。全 LGPL、零外部依赖(`--disable-autodetect --disable-zlib`,pthread 保留)。 +- 后续档位(decode-full / +encoders / +network...)= **成套快照 + 成套源列表**,以 feature 选择整档(feature gate sources + include_dirs 无法按 feature 切换 → 档位间 config 差异用 `gen/-/` + 档位专属 defines 解决;具体机制 F3 再定,可能需要 mcpp 支持 feature 条件 include_dirs——潜在新 G 项)。 +- zlib:v0.1 禁用(mov/mkv 极少数压缩头场景不支持);后续档位经 `compat.zlib` 依赖启用。 + +### 3.6 与 opencv-m 的集成(F2) + +opencv videoio 的 `cap_ffmpeg` 后端需要 avformat/avcodec/swscale(+音频场景 swresample)。opencv-m 依赖 `ffmpeg = { version = "...", visibility = "private" }`,include_dirs 自动传播,opencv 的 `cvconfig.h` 快照翻 `HAVE_FFMPEG`。两包各自独立发版,互不 vendor。 + +## 4. 风险与未决 + +- **枚举常量导出**(§3.3)——P1 首个验证项,有成熟退路。 +- **decode 正确性验证需要真实样本**:tests 里放一个自生成的微型 mp4(可用上游 make fate 的最小样本或十几 KB 手工样本入库),端到端 decode 首帧断言像素校验和。 +- **档位×平台快照矩阵的维护成本**:每格 = configure 一次 + 两个产物目录,`tools/` 全自动化;CI 矩阵逐步铺。 +- **上游升级**:pin n8.1.2;升级 = subtree pull + 重跑 gen_config/gen_sources + diff 审查(sources.lock 的 diff 即变更审计面)。 +- aarch64 的 `.S` 走 cc 驱动理论无碍但未实测(F3 验证)。 + +## 5. 待 review 决策点 + +1. **汇总模块名 `ffmpeg.av`**(对标 PyAV 的 `import av`)+ lib-root `ffmpeg` 转发——OK? +2. **v0.1 档位内容**:h264/hevc/aac 解码 + mov/mkv/mpegts + file + swscale;**要不要 +mpeg4/mjpeg 解码器、+swresample**(opencv 音频路径与更广样本兼容,代价源列表 +几十文件)? +3. **全局原名重导出**(`avformat_open_input` 直接可用,零迁移)vs 命名空间化(`ffmpeg::avformat_open_input`,更"现代"但破坏习惯)——我建议前者,与 opencv-m 的"不改用法"原则一致。 +4. **C-only 宏的 C++ 替代物命名**:`av_err2str` → `av_err2string()`(返回 `std::string`)这类命名规则确认。 +5. **版本 pin n8.1.2**(当前最新点版本)——OK? +6. **仓库归属**:`mcpplibs/ffmpeg-m` 已建,按 Form-A 模式(仓库内 mcpp.toml,index 只登记 tag)——OK? + +## 6. 路线图 + +| 阶段 | 交付物 | 验证 | +|---|---|---| +| F0 ✅ | 双轮 POC(纯 C + NASM) | 已过(§1) | +| F1a 骨架 | vendor n8.1.2(subtree);`tools/gen_config.sh`+`gen_sources.py`;`gen/linux-x86_64` + `sources.lock` 入库 | `mcpp build` 全源直编绿(=POC 在仓库内复现) | +| F1b 模块层 | `ffmpeg.{avutil,avcodec,avformat,swscale}` + `ffmpeg.av` + 导出清单生成脚本 + `macros.h`;枚举常量导出验证 | `mcpp test`:API 面编译 + 真实 mp4 解码首帧校验和 | +| F1c 收尾 | examples(decode_frames / extract_thumbnail)、README、docs | 新工程 5 行代码解出首帧 | +| F2 opencv 集成 | opencv-m 依赖 ffmpeg 包,videoio `cap_ffmpeg` 启用 | `VideoCapture("x.mp4")` 端到端 | +| F3 扩展 | aarch64(.S)、macOS 快照、档位机制(decode-full)、clang 验证、登记 mcpp-index | CI 矩阵绿 | + +--- + +## 附录 A:F0 POC 复现要点 + +```bash +# 1) configure (打包期一次, /usr/bin/gcc 即可 — 只为生成配置, 不产二进制) +./configure --disable-everything --disable-programs --disable-doc --disable-autodetect \ + --disable-avdevice --disable-avfilter --disable-swresample --disable-swscale \ + --disable-network \ + --enable-decoder=h264 --enable-parser=h264 --enable-demuxer=mov --enable-protocol=file +# (纯 C 轮加 --disable-x86asm) + +# 2) 源列表推导 +make -n | grep -oE '[a-zA-Z0-9_/.-]+\.(c|S|asm)\b' | sort -u # → 223 / 263 项 + +# 3) 快照: config.h config_components.h config.asm config_components.asm +# libavutil/{avconfig.h,ffversion.h} libavcodec/{codec,parser,bsf}_list.c +# libavformat/{demuxer,muxer,protocol}_list.c +# ffversion.h: cd && sh /ffbuild/version.sh libavutil/ffversion.h (相对路径!) +``` + +POC mcpp.toml 核心段见 §3.4(实测通过);踩坑记录见 §1(config_components.asm、ffversion.h guard、NASM -I 全列)。 + +## 附录 B:参考 + +- 本地:opencv-m 两份文档(方法论同源);`mcpp/docs/05`(0.0.95 per-glob flags/asm/features.sources/generated_files)、`docs/07`(build.mcpp 环境契约);FFmpeg 树内 `ffbuild/common.mak:55`(X86ASMFLAGS)、`configure:8515-8838`(生成文件全集)、`LICENSE.md` +- 先例:[allyourcodebase/ffmpeg](https://github.com/andrewrk/ffmpeg)(build.zig 替换构建系统)、[dmorn/ffmpeg.zig](https://github.com/dmorn/ffmpeg.zig)、Rust [ffmpeg-sys-next](https://crates.io/crates/ffmpeg-sys-next) vendored build、[PyAV](https://github.com/PyAV-Org/PyAV)(`import av` 命名参照) diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml new file mode 100644 index 0000000..a3f2cd8 --- /dev/null +++ b/.github/workflows/ci.yml @@ -0,0 +1,64 @@ +name: CI + +on: + push: + branches: [main, master] + pull_request: + branches: [main, master] + workflow_dispatch: + +permissions: + contents: read + +concurrency: + group: ci-${{ github.ref }} + cancel-in-progress: true + +jobs: + linux: + name: mcpp (ubuntu-latest, required) + runs-on: ubuntu-latest + timeout-minutes: 60 + steps: + - name: Checkout + uses: actions/checkout@v4 + + # mcpp resolves nasm PATH-first; ubuntu-24.04 ships nasm >= 2.16. + - name: Install nasm + run: sudo apt-get update && sudo apt-get install -y nasm && nasm --version + + - name: Install Xlings + env: + XLINGS_NON_INTERACTIVE: 1 + run: | + curl -fsSL https://raw.githubusercontent.com/openxlings/xlings/refs/heads/main/tools/other/quick_install.sh | bash + echo "$HOME/.xlings/subos/current/bin" >> "$GITHUB_PATH" + + - name: Install project tools + run: | + xlings update + xlings install + + # Same transition step as imgui-m: pin the glibc gcc toolchain explicitly + # until mcpp's bootstrap default settles. + - name: Set default toolchain + run: | + mcpp toolchain install gcc 16.1.0 + mcpp toolchain default gcc@16.1.0 + mcpp --version + + - name: Build library (via compat.ffmpeg source build) + run: mcpp build + + - name: Run tests (API surface + encode/decode roundtrip) + run: mcpp test + + - name: Run probe example (path-dep consumer) + run: | + cd examples/probe + mcpp run + + - name: Build decode_frames example + run: | + cd examples/decode_frames + mcpp build diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml new file mode 100644 index 0000000..7693727 --- /dev/null +++ b/.github/workflows/release.yml @@ -0,0 +1,58 @@ +name: Release + +on: + push: + tags: ["v*"] + +permissions: + contents: write + +jobs: + verify-and-release: + name: verify (linux) + GitHub Release + runs-on: ubuntu-latest + timeout-minutes: 60 + steps: + - name: Checkout + uses: actions/checkout@v4 + + - name: Install nasm + run: sudo apt-get update && sudo apt-get install -y nasm + + - name: Install Xlings + env: + XLINGS_NON_INTERACTIVE: 1 + run: | + curl -fsSL https://raw.githubusercontent.com/openxlings/xlings/refs/heads/main/tools/other/quick_install.sh | bash + echo "$HOME/.xlings/subos/current/bin" >> "$GITHUB_PATH" + + - name: Install project tools + run: | + xlings update + xlings install + + - name: Set default toolchain + run: | + mcpp toolchain install gcc 16.1.0 + mcpp toolchain default gcc@16.1.0 + mcpp --version + + - name: Build + test at the tagged revision + run: | + mcpp build + mcpp test + + - name: Verify tag matches package version + run: | + pkg_ver="$(sed -n 's/^version *= *"\(.*\)"/\1/p' mcpp.toml | head -1)" + tag="${GITHUB_REF_NAME#v}" + test "$pkg_ver" = "$tag" || { echo "tag $GITHUB_REF_NAME != package version $pkg_ver"; exit 1; } + + - name: Create GitHub Release + env: + GH_TOKEN: ${{ github.token }} + run: | + gh release create "$GITHUB_REF_NAME" \ + --title "ffmpeg-m $GITHUB_REF_NAME" \ + --generate-notes \ + --verify-tag diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..5e39bbc --- /dev/null +++ b/.gitignore @@ -0,0 +1,6 @@ +target/ +compile_commands.json +mcpp.lock +.mcpp/ +.xlings/ +doctor.log diff --git a/.xlings.json b/.xlings.json new file mode 100644 index 0000000..8ccd038 --- /dev/null +++ b/.xlings.json @@ -0,0 +1,5 @@ +{ + "workspace": { + "xim:mcpp": "0.0.95" + } +} diff --git a/LICENSE b/LICENSE new file mode 100644 index 0000000..d711ede --- /dev/null +++ b/LICENSE @@ -0,0 +1,21 @@ +MIT License + +Copyright (c) 2026 ffmpeg-m module contributors + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. diff --git a/README.md b/README.md index e57d44b..29f6797 100644 --- a/README.md +++ b/README.md @@ -1 +1,95 @@ -# ffmpeg-m \ No newline at end of file +# ffmpeg-m + +> FFmpeg as C++ modules for mcpp — built entirely from source, API unchanged. + +```cpp +import std; +import ffmpeg.av; // the whole FFmpeg surface, Python `import av` style + +int main() { + AVFormatContext* fmt { nullptr }; + avformat_open_input(&fmt, "video.mp4", nullptr, nullptr); + // ... the exact same C API you already know — just no #include +} +``` + +- **Source build, no CMake/configure at build time.** The + [`compat.ffmpeg`](https://github.com/mcpplibs/mcpp-index) index package + carries the frozen configure snapshot + exact source list; mcpp compiles all + of FFmpeg 8.1.2 (2124 `.c` + 157 NASM `.asm`, x86 SIMD included) directly — + cold build ≈ 21 s on 32 cores. This repo is only the thin module layer. +- **API and habits unchanged.** Every public function, type, enum, and enum + constant is re-exported under its upstream global name (`avcodec_open2`, + `AVFrame`, `AV_CODEC_ID_H264`, …). +- **Full-feature profile.** All internal components are on: 600+ decoders, + 350+ demuxers, encoders, muxers, filters, swscale/swresample — hermetic + (no host libraries probed), LGPL-2.1+ clean. + +## Modules + +| import | contents | +|---|---| +| `ffmpeg.av` | everything below (recommended default) | +| `ffmpeg.avutil` / `ffmpeg.avcodec` / `ffmpeg.avformat` / `ffmpeg.avfilter` / `ffmpeg.avdevice` / `ffmpeg.swscale` / `ffmpeg.swresample` | one library each; dependencies are re-exported (`import ffmpeg.avformat;` brings avcodec + avutil) | +| `ffmpeg` | lib-root alias of `ffmpeg.av` | + +## Macros and header-only helpers + +Named modules cannot export macros or `static inline` helpers. Everything +with linkage comes from the import; for the macro spellings (`AVERROR`, +`AV_NOPTS_VALUE`, `AVIO_FLAG_WRITE`, `MKTAG`, …) and inline utilities +(`av_q2d`, `av_clip`, …) add the optional side header **before** the import: + +```cpp +#include +import ffmpeg.av; +``` + +C-only compound-literal macros get C++ replacements exported from the +module: `av_err2str` → `av_err2string(err).c_str()`, `av_ts2str` → +`av_ts2string`, `av_ts2timestr` → `av_ts2timestring`, `av_fourcc2str` → +`av_fourcc2string`. + +## Using + +```toml +[dependencies] +ffmpeg = "0.0.1" +``` + +Or start from the template: `mcpp new myplayer --template ffmpeg` (decode +skeleton). Examples: [`examples/probe`](examples/probe) (no input needed), +[`examples/decode_frames`](examples/decode_frames). + +Validate the package: `mcpp build && mcpp test` (self-contained +encode→decode roundtrip + API-surface tests). + +## Layout + +```text +src/*.cppm module layer (GMF include + export using) +src/gen_exports/ generated export lists + skip reports +include/ffmpeg-m/ optional macros side header +tools/ fetch_upstream.sh (pinned official tarball), + gen_exports.py (headers → export lists) +templates/ examples/ project template + runnable consumers +``` + +Upstream sources are NOT vendored: they reach consumers through the +`compat.ffmpeg` mcpp-index package (official ffmpeg.org tarball, GLOBAL + CN +mirror, sha256-pinned). Its descriptor — config snapshot inlined as +`generated_files` plus the `make -n` source list — is maintained in +mcpp-index (`tools/compat-ffmpeg/`). FFmpeg bump: bump `compat.ffmpeg` +there first, then update the pin in `tools/fetch_upstream.sh`, run +`python3 tools/gen_exports.py`, and review the export-list diffs. + +## Notes + +- Hardware-acceleration headers that need external SDKs + (`libavutil/hwcontext_cuda.h`, VAAPI, …) are not part of the module export + surface; with the SDK present, include them textually next to the import. +- Optional variants (external codecs, GPL components, slim profiles) are + planned as mcpp features backed by per-profile config snapshots. +- License: this wrapper repo is MIT; the upstream sources arrive via + `compat.ffmpeg` under **LGPL-2.1-or-later** (no `--enable-gpl`/`nonfree` + components); source distribution satisfies LGPL relinking by construction. diff --git a/examples/decode_frames/mcpp.toml b/examples/decode_frames/mcpp.toml new file mode 100644 index 0000000..7313ab1 --- /dev/null +++ b/examples/decode_frames/mcpp.toml @@ -0,0 +1,8 @@ +[package] +name = "decode-frames" +version = "0.1.0" +description = "Decode every frame of a video file via import ffmpeg.av" +license = "LGPL-2.1-or-later" + +[dependencies] +ffmpeg = { path = "../.." } diff --git a/examples/decode_frames/src/main.cpp b/examples/decode_frames/src/main.cpp new file mode 100644 index 0000000..327f2f8 --- /dev/null +++ b/examples/decode_frames/src/main.cpp @@ -0,0 +1,42 @@ +// Decode every video frame of the given file — plain FFmpeg C API, no headers. +import std; +import ffmpeg.av; + +int main(int argc, char** argv) { + if (argc < 2) { + std::println("usage: {} ", argv[0]); + return 64; + } + + AVFormatContext* fmt { nullptr }; + if (avformat_open_input(&fmt, argv[1], nullptr, nullptr) < 0) { + std::println("cannot open {}", argv[1]); + return 1; + } + avformat_find_stream_info(fmt, nullptr); + + int video { av_find_best_stream(fmt, AVMEDIA_TYPE_VIDEO, -1, -1, nullptr, 0) }; + const AVCodec* codec { avcodec_find_decoder(fmt->streams[video]->codecpar->codec_id) }; + AVCodecContext* dec { avcodec_alloc_context3(codec) }; + avcodec_parameters_to_context(dec, fmt->streams[video]->codecpar); + avcodec_open2(dec, codec, nullptr); + + AVPacket* packet { av_packet_alloc() }; + AVFrame* frame { av_frame_alloc() }; + long frames { 0 }; + while (av_read_frame(fmt, packet) >= 0) { + if (packet->stream_index == video && avcodec_send_packet(dec, packet) >= 0) + while (avcodec_receive_frame(dec, frame) >= 0) ++frames; + av_packet_unref(packet); + } + avcodec_send_packet(dec, nullptr); + while (avcodec_receive_frame(dec, frame) >= 0) ++frames; + + std::println("{}: {} ({}x{}), {} frames decoded", + argv[1], codec->name, dec->width, dec->height, frames); + + av_frame_free(&frame); + av_packet_free(&packet); + avcodec_free_context(&dec); + avformat_close_input(&fmt); +} diff --git a/examples/probe/mcpp.toml b/examples/probe/mcpp.toml new file mode 100644 index 0000000..dc77bc0 --- /dev/null +++ b/examples/probe/mcpp.toml @@ -0,0 +1,8 @@ +[package] +name = "ffmpeg-probe" +version = "0.1.0" +description = "List the FFmpeg build surface through import ffmpeg.av" +license = "LGPL-2.1-or-later" + +[dependencies] +ffmpeg = { path = "../.." } diff --git a/examples/probe/src/main.cpp b/examples/probe/src/main.cpp new file mode 100644 index 0000000..a64da6f --- /dev/null +++ b/examples/probe/src/main.cpp @@ -0,0 +1,19 @@ +// Show what the vendored FFmpeg exposes — versions and a few codecs/formats. +import std; +import ffmpeg.av; + +int main() { + std::println("libavutil {}.{}", avutil_version() >> 16, (avutil_version() >> 8) & 0xff); + std::println("libavcodec {}.{}", avcodec_version() >> 16, (avcodec_version() >> 8) & 0xff); + std::println("libavformat {}.{}", avformat_version() >> 16, (avformat_version() >> 8) & 0xff); + + for (auto name : { "h264", "hevc", "av1", "vp9", "aac", "opus", "flac" }) { + const AVCodec* dec { avcodec_find_decoder_by_name(name) }; + std::println("decoder {:8} {}", name, dec ? "ok" : "MISSING"); + } + + void* it { nullptr }; + long demuxers { 0 }; + while (av_demuxer_iterate(&it)) ++demuxers; + std::println("{} demuxers registered", demuxers); +} diff --git a/include/ffmpeg-m/macros.h b/include/ffmpeg-m/macros.h new file mode 100644 index 0000000..587d50d --- /dev/null +++ b/include/ffmpeg-m/macros.h @@ -0,0 +1,34 @@ +// ffmpeg-m/macros.h — optional side header for FFmpeg's preprocessor surface. +// +// C++ named modules cannot export macros or static-inline helpers. Everything +// with linkage comes from `import ffmpeg.av;`; consumers who also want the +// macro spellings (AVERROR, MKTAG, AV_NOPTS_VALUE, AV_TIME_BASE_Q, AV_RL32, +// LIBAV*_VERSION_*) or the header-only inline utilities (av_q2d, av_make_q, +// av_clip family, av_rescale_q) textually include THIS header next to the +// import: +// +// import ffmpeg.av; +// #include // optional, macro habits only +// +// The declarations herein denote the same global-module entities the modules +// re-export, so mixing include and import this way is well-formed. Include +// further upstream headers directly (they are on the include path) for +// SDK-gated surfaces such as libavutil/hwcontext_cuda.h. +#ifndef FFMPEG_M_MACROS_H +#define FFMPEG_M_MACROS_H + +extern "C" { +#include // AV_NOPTS_VALUE, AV_TIME_BASE(_Q), av_q2d/av_clip inlines, AVERROR family, MKTAG, versions +#include // AV_RL32 / AV_WB16 … byte-access macros +#include +#include // AV_OPT_* flags +#include // av_ts_make_string / av_ts_make_time_string (the av_ts2str macro itself stays C-only — use av_ts2string from the module) +#include // AV_INPUT_BUFFER_PADDING_SIZE, AV_PKT_FLAG_*, AV_CODEC_FLAG_*, AV_GET_BUFFER_FLAG_* +#include // AVIO_FLAG_*, AVSEEK_*, AVFMT_* flags +#include // AVFILTER_FLAG_* +#include +#include // SWS_* flags +#include +} + +#endif // FFMPEG_M_MACROS_H diff --git a/mcpp.toml b/mcpp.toml new file mode 100644 index 0000000..d440588 --- /dev/null +++ b/mcpp.toml @@ -0,0 +1,26 @@ +[package] +name = "ffmpeg" +version = "0.0.1" +description = "FFmpeg C++ modules for mcpp (import ffmpeg.av;) on top of the compat.ffmpeg source build" +license = "MIT" +repo = "https://github.com/mcpplibs/ffmpeg-m" +platforms = ["linux"] + +[targets.ffmpeg] +kind = "lib" + +[build] +sources = ["src/**/*.cppm"] +include_dirs = ["include"] +# FFmpeg's own CXXFLAGS carry this; common.h #errors without it in C++ TUs +# (the module wrappers include the upstream headers in their GMF). +cxxflags = ["-D__STDC_CONSTANT_MACROS"] + +[dependencies] +# Upstream sources, config snapshot, and the full source-build recipe live in +# the compat.ffmpeg index package (2281 TUs incl. NASM asm, built by mcpp). +compat.ffmpeg = "8.1.2" + +[dev-dependencies] +compat.gtest = "1.15.2" + diff --git a/src/av.cppm b/src/av.cppm new file mode 100644 index 0000000..b464287 --- /dev/null +++ b/src/av.cppm @@ -0,0 +1,10 @@ +// ffmpeg.av — the whole FFmpeg surface in one import (Python `import av` analog). +export module ffmpeg.av; + +export import ffmpeg.avutil; +export import ffmpeg.avcodec; +export import ffmpeg.avformat; +export import ffmpeg.avfilter; +export import ffmpeg.avdevice; +export import ffmpeg.swscale; +export import ffmpeg.swresample; diff --git a/src/avcodec.cppm b/src/avcodec.cppm new file mode 100644 index 0000000..d5baed4 --- /dev/null +++ b/src/avcodec.cppm @@ -0,0 +1,12 @@ +// ffmpeg.avcodec — libavcodec re-exported as a C++ module (C API unchanged). +module; + +extern "C" { +#include "gen_exports/avcodec.includes.inc" +} + +export module ffmpeg.avcodec; + +export import ffmpeg.avutil; + +#include "gen_exports/avcodec.inc" diff --git a/src/avdevice.cppm b/src/avdevice.cppm new file mode 100644 index 0000000..33317fb --- /dev/null +++ b/src/avdevice.cppm @@ -0,0 +1,12 @@ +// ffmpeg.avdevice — libavdevice re-exported as a C++ module (C API unchanged). +module; + +extern "C" { +#include "gen_exports/avdevice.includes.inc" +} + +export module ffmpeg.avdevice; + +export import ffmpeg.avformat; + +#include "gen_exports/avdevice.inc" diff --git a/src/avfilter.cppm b/src/avfilter.cppm new file mode 100644 index 0000000..b39fdf5 --- /dev/null +++ b/src/avfilter.cppm @@ -0,0 +1,12 @@ +// ffmpeg.avfilter — libavfilter re-exported as a C++ module (C API unchanged). +module; + +extern "C" { +#include "gen_exports/avfilter.includes.inc" +} + +export module ffmpeg.avfilter; + +export import ffmpeg.avutil; + +#include "gen_exports/avfilter.inc" diff --git a/src/avformat.cppm b/src/avformat.cppm new file mode 100644 index 0000000..8ffc6fe --- /dev/null +++ b/src/avformat.cppm @@ -0,0 +1,12 @@ +// ffmpeg.avformat — libavformat re-exported as a C++ module (C API unchanged). +module; + +extern "C" { +#include "gen_exports/avformat.includes.inc" +} + +export module ffmpeg.avformat; + +export import ffmpeg.avcodec; + +#include "gen_exports/avformat.inc" diff --git a/src/avutil.cppm b/src/avutil.cppm new file mode 100644 index 0000000..edbd675 --- /dev/null +++ b/src/avutil.cppm @@ -0,0 +1,66 @@ +// ffmpeg.avutil — libavutil re-exported as a C++ module. +// The C API is unchanged: every exported name below is the upstream global. +module; + +extern "C" { +#include "gen_exports/avutil.includes.inc" +} + +export module ffmpeg.avutil; + +#include "gen_exports/avutil.inc" + +// --------------------------------------------------------------------------- +// C++ replacements for upstream compound-literal macros (av_err2str family). +// Those macros are C-only — they do not compile in C++ even with a textual +// #include — so the module layer is strictly an improvement here. Naming per +// design doc: 2str → 2string. +// --------------------------------------------------------------------------- + +export struct AvErrorString { + char text[AV_ERROR_MAX_STRING_SIZE] {}; + const char* c_str() const { return text; } +}; + +// av_err2str(errnum) +export inline AvErrorString av_err2string(int errnum) { + AvErrorString s {}; + ::av_strerror(errnum, s.text, sizeof s.text); + return s; +} + +export struct AvTsString { + char text[AV_TS_MAX_STRING_SIZE] {}; + const char* c_str() const { return text; } +}; + +// av_ts2str(ts) +export inline AvTsString av_ts2string(int64_t ts) { + AvTsString s {}; + ::av_ts_make_string(s.text, ts); + return s; +} + +// av_ts2timestr(ts, tb) +export inline AvTsString av_ts2timestring(int64_t ts, AVRational timeBase) { + AvTsString s {}; + ::av_ts_make_time_string(s.text, ts, &timeBase); + return s; +} + +export struct AvFourccString { + char text[AV_FOURCC_MAX_STRING_SIZE] {}; + const char* c_str() const { return text; } +}; + +// av_fourcc2str(fourcc) +export inline AvFourccString av_fourcc2string(uint32_t fourcc) { + AvFourccString s {}; + ::av_fourcc_make_string(s.text, fourcc); + return s; +} + +// AV_TIME_BASE_Q / AV_NOPTS_VALUE are macros (side header covers the macro +// spelling); constants are also usable directly: +export inline constexpr int64_t AV_NOPTS = INT64_C(0x8000000000000000); +export inline AVRational av_time_base_q() { return ::av_make_q(1, AV_TIME_BASE); } diff --git a/src/ffmpeg.cppm b/src/ffmpeg.cppm new file mode 100644 index 0000000..a2edb6d --- /dev/null +++ b/src/ffmpeg.cppm @@ -0,0 +1,4 @@ +// ffmpeg — package lib-root module; forwards to the ffmpeg.av umbrella. +export module ffmpeg; + +export import ffmpeg.av; diff --git a/src/gen_exports/avcodec.inc b/src/gen_exports/avcodec.inc new file mode 100644 index 0000000..923c5fa --- /dev/null +++ b/src/gen_exports/avcodec.inc @@ -0,0 +1,866 @@ +// Auto-generated by tools/gen_exports.py from libavcodec +// public headers (17 files) — do not edit by hand. + +// structs (30) +export using ::AVBSFContext; +export using ::AVBSFList; +export using ::AVBitStreamFilter; +export using ::AVCPBProperties; +export using ::AVCodec; +export using ::AVCodecContext; +export using ::AVCodecDescriptor; +export using ::AVCodecHWConfig; +export using ::AVCodecParameters; +export using ::AVCodecParser; +export using ::AVCodecParserContext; +export using ::AVContainerFifo; +export using ::AVDCT; +export using ::AVDVProfile; +export using ::AVDiracSeqHeader; +export using ::AVExifEntry; +export using ::AVExifMetadata; +export using ::AVFrameSideData; +export using ::AVHWAccel; +export using ::AVPacket; +export using ::AVPacketSideData; +export using ::AVPanScan; +export using ::AVProducerReferenceTime; +export using ::AVProfile; +export using ::AVRTCPSenderReport; +export using ::AVSmpte291mAnc8bit; +export using ::AVSmpte436mAncIterator; +export using ::AVSmpte436mCodedAnc; +export using ::AVSubtitle; +export using ::AVSubtitleRect; + +// enums (13) +export using ::AVAudioServiceType; +export using ::AVCodecConfig; +export using ::AVCodecID; +export using ::AVDiscard; +export using ::AVExifHeaderMode; +export using ::AVFieldOrder; +export using ::AVPacketSideDataType; +export using ::AVPictureStructure; +export using ::AVSideDataParamChangeFlags; +export using ::AVSmpte436mPayloadSampleCoding; +export using ::AVSmpte436mWrappingType; +export using ::AVSubtitleType; +export using ::AVTiffDataType; + +// enumerators (671) +export using ::AVDISCARD_ALL; +export using ::AVDISCARD_BIDIR; +export using ::AVDISCARD_DEFAULT; +export using ::AVDISCARD_NONE; +export using ::AVDISCARD_NONINTRA; +export using ::AVDISCARD_NONKEY; +export using ::AVDISCARD_NONREF; +export using ::AV_AUDIO_SERVICE_TYPE_COMMENTARY; +export using ::AV_AUDIO_SERVICE_TYPE_DIALOGUE; +export using ::AV_AUDIO_SERVICE_TYPE_EFFECTS; +export using ::AV_AUDIO_SERVICE_TYPE_EMERGENCY; +export using ::AV_AUDIO_SERVICE_TYPE_HEARING_IMPAIRED; +export using ::AV_AUDIO_SERVICE_TYPE_KARAOKE; +export using ::AV_AUDIO_SERVICE_TYPE_MAIN; +export using ::AV_AUDIO_SERVICE_TYPE_NB; +export using ::AV_AUDIO_SERVICE_TYPE_VISUALLY_IMPAIRED; +export using ::AV_AUDIO_SERVICE_TYPE_VOICE_OVER; +export using ::AV_CODEC_CONFIG_ALPHA_MODE; +export using ::AV_CODEC_CONFIG_CHANNEL_LAYOUT; +export using ::AV_CODEC_CONFIG_COLOR_RANGE; +export using ::AV_CODEC_CONFIG_COLOR_SPACE; +export using ::AV_CODEC_CONFIG_FRAME_RATE; +export using ::AV_CODEC_CONFIG_PIX_FORMAT; +export using ::AV_CODEC_CONFIG_SAMPLE_FORMAT; +export using ::AV_CODEC_CONFIG_SAMPLE_RATE; +export using ::AV_CODEC_HW_CONFIG_METHOD_AD_HOC; +export using ::AV_CODEC_HW_CONFIG_METHOD_HW_DEVICE_CTX; +export using ::AV_CODEC_HW_CONFIG_METHOD_HW_FRAMES_CTX; +export using ::AV_CODEC_HW_CONFIG_METHOD_INTERNAL; +export using ::AV_CODEC_ID_012V; +export using ::AV_CODEC_ID_4GV; +export using ::AV_CODEC_ID_4XM; +export using ::AV_CODEC_ID_8BPS; +export using ::AV_CODEC_ID_8SVX_EXP; +export using ::AV_CODEC_ID_8SVX_FIB; +export using ::AV_CODEC_ID_A64_MULTI; +export using ::AV_CODEC_ID_A64_MULTI5; +export using ::AV_CODEC_ID_AAC; +export using ::AV_CODEC_ID_AAC_LATM; +export using ::AV_CODEC_ID_AASC; +export using ::AV_CODEC_ID_AC3; +export using ::AV_CODEC_ID_AC4; +export using ::AV_CODEC_ID_ACELP_KELVIN; +export using ::AV_CODEC_ID_ADPCM_4XM; +export using ::AV_CODEC_ID_ADPCM_ADX; +export using ::AV_CODEC_ID_ADPCM_AFC; +export using ::AV_CODEC_ID_ADPCM_AGM; +export using ::AV_CODEC_ID_ADPCM_AICA; +export using ::AV_CODEC_ID_ADPCM_ARGO; +export using ::AV_CODEC_ID_ADPCM_CIRCUS; +export using ::AV_CODEC_ID_ADPCM_CT; +export using ::AV_CODEC_ID_ADPCM_DTK; +export using ::AV_CODEC_ID_ADPCM_EA; +export using ::AV_CODEC_ID_ADPCM_EA_MAXIS_XA; +export using ::AV_CODEC_ID_ADPCM_EA_R1; +export using ::AV_CODEC_ID_ADPCM_EA_R2; +export using ::AV_CODEC_ID_ADPCM_EA_R3; +export using ::AV_CODEC_ID_ADPCM_EA_XAS; +export using ::AV_CODEC_ID_ADPCM_G722; +export using ::AV_CODEC_ID_ADPCM_G726; +export using ::AV_CODEC_ID_ADPCM_G726LE; +export using ::AV_CODEC_ID_ADPCM_IMA_ACORN; +export using ::AV_CODEC_ID_ADPCM_IMA_ALP; +export using ::AV_CODEC_ID_ADPCM_IMA_AMV; +export using ::AV_CODEC_ID_ADPCM_IMA_APC; +export using ::AV_CODEC_ID_ADPCM_IMA_APM; +export using ::AV_CODEC_ID_ADPCM_IMA_CUNNING; +export using ::AV_CODEC_ID_ADPCM_IMA_DAT4; +export using ::AV_CODEC_ID_ADPCM_IMA_DK3; +export using ::AV_CODEC_ID_ADPCM_IMA_DK4; +export using ::AV_CODEC_ID_ADPCM_IMA_EA_EACS; +export using ::AV_CODEC_ID_ADPCM_IMA_EA_SEAD; +export using ::AV_CODEC_ID_ADPCM_IMA_ESCAPE; +export using ::AV_CODEC_ID_ADPCM_IMA_HVQM2; +export using ::AV_CODEC_ID_ADPCM_IMA_HVQM4; +export using ::AV_CODEC_ID_ADPCM_IMA_ISS; +export using ::AV_CODEC_ID_ADPCM_IMA_MAGIX; +export using ::AV_CODEC_ID_ADPCM_IMA_MOFLEX; +export using ::AV_CODEC_ID_ADPCM_IMA_MTF; +export using ::AV_CODEC_ID_ADPCM_IMA_OKI; +export using ::AV_CODEC_ID_ADPCM_IMA_PDA; +export using ::AV_CODEC_ID_ADPCM_IMA_QT; +export using ::AV_CODEC_ID_ADPCM_IMA_RAD; +export using ::AV_CODEC_ID_ADPCM_IMA_SMJPEG; +export using ::AV_CODEC_ID_ADPCM_IMA_SSI; +export using ::AV_CODEC_ID_ADPCM_IMA_WAV; +export using ::AV_CODEC_ID_ADPCM_IMA_WS; +export using ::AV_CODEC_ID_ADPCM_IMA_XBOX; +export using ::AV_CODEC_ID_ADPCM_MS; +export using ::AV_CODEC_ID_ADPCM_MTAF; +export using ::AV_CODEC_ID_ADPCM_N64; +export using ::AV_CODEC_ID_ADPCM_PSX; +export using ::AV_CODEC_ID_ADPCM_PSXC; +export using ::AV_CODEC_ID_ADPCM_SANYO; +export using ::AV_CODEC_ID_ADPCM_SBPRO_2; +export using ::AV_CODEC_ID_ADPCM_SBPRO_3; +export using ::AV_CODEC_ID_ADPCM_SBPRO_4; +export using ::AV_CODEC_ID_ADPCM_SWF; +export using ::AV_CODEC_ID_ADPCM_THP; +export using ::AV_CODEC_ID_ADPCM_THP_LE; +export using ::AV_CODEC_ID_ADPCM_VIMA; +export using ::AV_CODEC_ID_ADPCM_XA; +export using ::AV_CODEC_ID_ADPCM_XMD; +export using ::AV_CODEC_ID_ADPCM_YAMAHA; +export using ::AV_CODEC_ID_ADPCM_ZORK; +export using ::AV_CODEC_ID_AGM; +export using ::AV_CODEC_ID_AHX; +export using ::AV_CODEC_ID_AIC; +export using ::AV_CODEC_ID_ALAC; +export using ::AV_CODEC_ID_ALIAS_PIX; +export using ::AV_CODEC_ID_AMR_NB; +export using ::AV_CODEC_ID_AMR_WB; +export using ::AV_CODEC_ID_AMV; +export using ::AV_CODEC_ID_ANM; +export using ::AV_CODEC_ID_ANSI; +export using ::AV_CODEC_ID_ANULL; +export using ::AV_CODEC_ID_APAC; +export using ::AV_CODEC_ID_APE; +export using ::AV_CODEC_ID_APNG; +export using ::AV_CODEC_ID_APTX; +export using ::AV_CODEC_ID_APTX_HD; +export using ::AV_CODEC_ID_APV; +export using ::AV_CODEC_ID_ARBC; +export using ::AV_CODEC_ID_ARGO; +export using ::AV_CODEC_ID_ARIB_CAPTION; +export using ::AV_CODEC_ID_ASS; +export using ::AV_CODEC_ID_ASV1; +export using ::AV_CODEC_ID_ASV2; +export using ::AV_CODEC_ID_ATRAC1; +export using ::AV_CODEC_ID_ATRAC3; +export using ::AV_CODEC_ID_ATRAC3AL; +export using ::AV_CODEC_ID_ATRAC3P; +export using ::AV_CODEC_ID_ATRAC3PAL; +export using ::AV_CODEC_ID_ATRAC9; +export using ::AV_CODEC_ID_AURA; +export using ::AV_CODEC_ID_AURA2; +export using ::AV_CODEC_ID_AV1; +export using ::AV_CODEC_ID_AVRN; +export using ::AV_CODEC_ID_AVRP; +export using ::AV_CODEC_ID_AVS; +export using ::AV_CODEC_ID_AVS2; +export using ::AV_CODEC_ID_AVS3; +export using ::AV_CODEC_ID_AVUI; +export using ::AV_CODEC_ID_BETHSOFTVID; +export using ::AV_CODEC_ID_BFI; +export using ::AV_CODEC_ID_BINKAUDIO_DCT; +export using ::AV_CODEC_ID_BINKAUDIO_RDFT; +export using ::AV_CODEC_ID_BINKVIDEO; +export using ::AV_CODEC_ID_BINTEXT; +export using ::AV_CODEC_ID_BIN_DATA; +export using ::AV_CODEC_ID_BITPACKED; +export using ::AV_CODEC_ID_BMP; +export using ::AV_CODEC_ID_BMV_AUDIO; +export using ::AV_CODEC_ID_BMV_VIDEO; +export using ::AV_CODEC_ID_BONK; +export using ::AV_CODEC_ID_BRENDER_PIX; +export using ::AV_CODEC_ID_C93; +export using ::AV_CODEC_ID_CAVS; +export using ::AV_CODEC_ID_CBD2_DPCM; +export using ::AV_CODEC_ID_CDGRAPHICS; +export using ::AV_CODEC_ID_CDTOONS; +export using ::AV_CODEC_ID_CDXL; +export using ::AV_CODEC_ID_CELT; +export using ::AV_CODEC_ID_CFHD; +export using ::AV_CODEC_ID_CINEPAK; +export using ::AV_CODEC_ID_CLEARVIDEO; +export using ::AV_CODEC_ID_CLJR; +export using ::AV_CODEC_ID_CLLC; +export using ::AV_CODEC_ID_CMV; +export using ::AV_CODEC_ID_CODEC2; +export using ::AV_CODEC_ID_COMFORT_NOISE; +export using ::AV_CODEC_ID_COOK; +export using ::AV_CODEC_ID_CPIA; +export using ::AV_CODEC_ID_CRI; +export using ::AV_CODEC_ID_CSCD; +export using ::AV_CODEC_ID_CYUV; +export using ::AV_CODEC_ID_DAALA; +export using ::AV_CODEC_ID_DDS; +export using ::AV_CODEC_ID_DERF_DPCM; +export using ::AV_CODEC_ID_DFA; +export using ::AV_CODEC_ID_DFPWM; +export using ::AV_CODEC_ID_DIRAC; +export using ::AV_CODEC_ID_DNXHD; +export using ::AV_CODEC_ID_DNXUC; +export using ::AV_CODEC_ID_DOLBY_E; +export using ::AV_CODEC_ID_DPX; +export using ::AV_CODEC_ID_DSD_LSBF; +export using ::AV_CODEC_ID_DSD_LSBF_PLANAR; +export using ::AV_CODEC_ID_DSD_MSBF; +export using ::AV_CODEC_ID_DSD_MSBF_PLANAR; +export using ::AV_CODEC_ID_DSICINAUDIO; +export using ::AV_CODEC_ID_DSICINVIDEO; +export using ::AV_CODEC_ID_DSS_SP; +export using ::AV_CODEC_ID_DST; +export using ::AV_CODEC_ID_DTS; +export using ::AV_CODEC_ID_DVAUDIO; +export using ::AV_CODEC_ID_DVB_SUBTITLE; +export using ::AV_CODEC_ID_DVB_TELETEXT; +export using ::AV_CODEC_ID_DVD_NAV; +export using ::AV_CODEC_ID_DVD_SUBTITLE; +export using ::AV_CODEC_ID_DVVIDEO; +export using ::AV_CODEC_ID_DXA; +export using ::AV_CODEC_ID_DXTORY; +export using ::AV_CODEC_ID_DXV; +export using ::AV_CODEC_ID_EAC3; +export using ::AV_CODEC_ID_EIA_608; +export using ::AV_CODEC_ID_EPG; +export using ::AV_CODEC_ID_ESCAPE124; +export using ::AV_CODEC_ID_ESCAPE130; +export using ::AV_CODEC_ID_EVC; +export using ::AV_CODEC_ID_EVRC; +export using ::AV_CODEC_ID_EXR; +export using ::AV_CODEC_ID_FASTAUDIO; +export using ::AV_CODEC_ID_FFMETADATA; +export using ::AV_CODEC_ID_FFV1; +export using ::AV_CODEC_ID_FFVHUFF; +export using ::AV_CODEC_ID_FFWAVESYNTH; +export using ::AV_CODEC_ID_FIC; +export using ::AV_CODEC_ID_FIRST_AUDIO; +export using ::AV_CODEC_ID_FIRST_SUBTITLE; +export using ::AV_CODEC_ID_FIRST_UNKNOWN; +export using ::AV_CODEC_ID_FITS; +export using ::AV_CODEC_ID_FLAC; +export using ::AV_CODEC_ID_FLASHSV; +export using ::AV_CODEC_ID_FLASHSV2; +export using ::AV_CODEC_ID_FLIC; +export using ::AV_CODEC_ID_FLV1; +export using ::AV_CODEC_ID_FMVC; +export using ::AV_CODEC_ID_FRAPS; +export using ::AV_CODEC_ID_FRWU; +export using ::AV_CODEC_ID_FTR; +export using ::AV_CODEC_ID_G2M; +export using ::AV_CODEC_ID_G723_1; +export using ::AV_CODEC_ID_G728; +export using ::AV_CODEC_ID_G729; +export using ::AV_CODEC_ID_GDV; +export using ::AV_CODEC_ID_GEM; +export using ::AV_CODEC_ID_GIF; +export using ::AV_CODEC_ID_GREMLIN_DPCM; +export using ::AV_CODEC_ID_GSM; +export using ::AV_CODEC_ID_GSM_MS; +export using ::AV_CODEC_ID_H261; +export using ::AV_CODEC_ID_H263; +export using ::AV_CODEC_ID_H263I; +export using ::AV_CODEC_ID_H263P; +export using ::AV_CODEC_ID_H264; +export using ::AV_CODEC_ID_HAP; +export using ::AV_CODEC_ID_HCA; +export using ::AV_CODEC_ID_HCOM; +export using ::AV_CODEC_ID_HDMV_PGS_SUBTITLE; +export using ::AV_CODEC_ID_HDMV_TEXT_SUBTITLE; +export using ::AV_CODEC_ID_HEVC; +export using ::AV_CODEC_ID_HNM4_VIDEO; +export using ::AV_CODEC_ID_HQX; +export using ::AV_CODEC_ID_HQ_HQA; +export using ::AV_CODEC_ID_HUFFYUV; +export using ::AV_CODEC_ID_HYMT; +export using ::AV_CODEC_ID_IAC; +export using ::AV_CODEC_ID_IDCIN; +export using ::AV_CODEC_ID_IDF; +export using ::AV_CODEC_ID_IFF_ILBM; +export using ::AV_CODEC_ID_ILBC; +export using ::AV_CODEC_ID_IMC; +export using ::AV_CODEC_ID_IMM4; +export using ::AV_CODEC_ID_IMM5; +export using ::AV_CODEC_ID_INDEO2; +export using ::AV_CODEC_ID_INDEO3; +export using ::AV_CODEC_ID_INDEO4; +export using ::AV_CODEC_ID_INDEO5; +export using ::AV_CODEC_ID_INTERPLAY_ACM; +export using ::AV_CODEC_ID_INTERPLAY_DPCM; +export using ::AV_CODEC_ID_INTERPLAY_VIDEO; +export using ::AV_CODEC_ID_IPU; +export using ::AV_CODEC_ID_IVTV_VBI; +export using ::AV_CODEC_ID_JACOSUB; +export using ::AV_CODEC_ID_JPEG2000; +export using ::AV_CODEC_ID_JPEGLS; +export using ::AV_CODEC_ID_JPEGXL; +export using ::AV_CODEC_ID_JPEGXL_ANIM; +export using ::AV_CODEC_ID_JPEGXS; +export using ::AV_CODEC_ID_JV; +export using ::AV_CODEC_ID_KGV1; +export using ::AV_CODEC_ID_KMVC; +export using ::AV_CODEC_ID_LAGARITH; +export using ::AV_CODEC_ID_LC3; +export using ::AV_CODEC_ID_LCEVC; +export using ::AV_CODEC_ID_LEAD; +export using ::AV_CODEC_ID_LJPEG; +export using ::AV_CODEC_ID_LOCO; +export using ::AV_CODEC_ID_LSCR; +export using ::AV_CODEC_ID_M101; +export using ::AV_CODEC_ID_MACE3; +export using ::AV_CODEC_ID_MACE6; +export using ::AV_CODEC_ID_MAD; +export using ::AV_CODEC_ID_MAGICYUV; +export using ::AV_CODEC_ID_MDEC; +export using ::AV_CODEC_ID_MEDIA100; +export using ::AV_CODEC_ID_METASOUND; +export using ::AV_CODEC_ID_MICRODVD; +export using ::AV_CODEC_ID_MIMIC; +export using ::AV_CODEC_ID_MISC4; +export using ::AV_CODEC_ID_MJPEG; +export using ::AV_CODEC_ID_MJPEGB; +export using ::AV_CODEC_ID_MLP; +export using ::AV_CODEC_ID_MMVIDEO; +export using ::AV_CODEC_ID_MOBICLIP; +export using ::AV_CODEC_ID_MOTIONPIXELS; +export using ::AV_CODEC_ID_MOV_TEXT; +export using ::AV_CODEC_ID_MP1; +export using ::AV_CODEC_ID_MP2; +export using ::AV_CODEC_ID_MP3; +export using ::AV_CODEC_ID_MP3ADU; +export using ::AV_CODEC_ID_MP3ON4; +export using ::AV_CODEC_ID_MP4ALS; +export using ::AV_CODEC_ID_MPEG1VIDEO; +export using ::AV_CODEC_ID_MPEG2TS; +export using ::AV_CODEC_ID_MPEG2VIDEO; +export using ::AV_CODEC_ID_MPEG4; +export using ::AV_CODEC_ID_MPEG4SYSTEMS; +export using ::AV_CODEC_ID_MPEGH_3D_AUDIO; +export using ::AV_CODEC_ID_MPL2; +export using ::AV_CODEC_ID_MSA1; +export using ::AV_CODEC_ID_MSCC; +export using ::AV_CODEC_ID_MSMPEG4V1; +export using ::AV_CODEC_ID_MSMPEG4V2; +export using ::AV_CODEC_ID_MSMPEG4V3; +export using ::AV_CODEC_ID_MSNSIREN; +export using ::AV_CODEC_ID_MSP2; +export using ::AV_CODEC_ID_MSRLE; +export using ::AV_CODEC_ID_MSS1; +export using ::AV_CODEC_ID_MSS2; +export using ::AV_CODEC_ID_MSVIDEO1; +export using ::AV_CODEC_ID_MSZH; +export using ::AV_CODEC_ID_MTS2; +export using ::AV_CODEC_ID_MUSEPACK7; +export using ::AV_CODEC_ID_MUSEPACK8; +export using ::AV_CODEC_ID_MV30; +export using ::AV_CODEC_ID_MVC1; +export using ::AV_CODEC_ID_MVC2; +export using ::AV_CODEC_ID_MVDV; +export using ::AV_CODEC_ID_MVHA; +export using ::AV_CODEC_ID_MWSC; +export using ::AV_CODEC_ID_MXPEG; +export using ::AV_CODEC_ID_NELLYMOSER; +export using ::AV_CODEC_ID_NONE; +export using ::AV_CODEC_ID_NOTCHLC; +export using ::AV_CODEC_ID_NUV; +export using ::AV_CODEC_ID_ON2AVC; +export using ::AV_CODEC_ID_OPUS; +export using ::AV_CODEC_ID_OSQ; +export using ::AV_CODEC_ID_OTF; +export using ::AV_CODEC_ID_PAF_AUDIO; +export using ::AV_CODEC_ID_PAF_VIDEO; +export using ::AV_CODEC_ID_PAM; +export using ::AV_CODEC_ID_PBM; +export using ::AV_CODEC_ID_PCM_ALAW; +export using ::AV_CODEC_ID_PCM_BLURAY; +export using ::AV_CODEC_ID_PCM_DVD; +export using ::AV_CODEC_ID_PCM_F16LE; +export using ::AV_CODEC_ID_PCM_F24LE; +export using ::AV_CODEC_ID_PCM_F32BE; +export using ::AV_CODEC_ID_PCM_F32LE; +export using ::AV_CODEC_ID_PCM_F64BE; +export using ::AV_CODEC_ID_PCM_F64LE; +export using ::AV_CODEC_ID_PCM_LXF; +export using ::AV_CODEC_ID_PCM_MULAW; +export using ::AV_CODEC_ID_PCM_S16BE; +export using ::AV_CODEC_ID_PCM_S16BE_PLANAR; +export using ::AV_CODEC_ID_PCM_S16LE; +export using ::AV_CODEC_ID_PCM_S16LE_PLANAR; +export using ::AV_CODEC_ID_PCM_S24BE; +export using ::AV_CODEC_ID_PCM_S24DAUD; +export using ::AV_CODEC_ID_PCM_S24LE; +export using ::AV_CODEC_ID_PCM_S24LE_PLANAR; +export using ::AV_CODEC_ID_PCM_S32BE; +export using ::AV_CODEC_ID_PCM_S32LE; +export using ::AV_CODEC_ID_PCM_S32LE_PLANAR; +export using ::AV_CODEC_ID_PCM_S64BE; +export using ::AV_CODEC_ID_PCM_S64LE; +export using ::AV_CODEC_ID_PCM_S8; +export using ::AV_CODEC_ID_PCM_S8_PLANAR; +export using ::AV_CODEC_ID_PCM_SGA; +export using ::AV_CODEC_ID_PCM_U16BE; +export using ::AV_CODEC_ID_PCM_U16LE; +export using ::AV_CODEC_ID_PCM_U24BE; +export using ::AV_CODEC_ID_PCM_U24LE; +export using ::AV_CODEC_ID_PCM_U32BE; +export using ::AV_CODEC_ID_PCM_U32LE; +export using ::AV_CODEC_ID_PCM_U8; +export using ::AV_CODEC_ID_PCM_VIDC; +export using ::AV_CODEC_ID_PCM_ZORK; +export using ::AV_CODEC_ID_PCX; +export using ::AV_CODEC_ID_PDV; +export using ::AV_CODEC_ID_PFM; +export using ::AV_CODEC_ID_PGM; +export using ::AV_CODEC_ID_PGMYUV; +export using ::AV_CODEC_ID_PGX; +export using ::AV_CODEC_ID_PHM; +export using ::AV_CODEC_ID_PHOTOCD; +export using ::AV_CODEC_ID_PICTOR; +export using ::AV_CODEC_ID_PIXLET; +export using ::AV_CODEC_ID_PJS; +export using ::AV_CODEC_ID_PNG; +export using ::AV_CODEC_ID_PPM; +export using ::AV_CODEC_ID_PROBE; +export using ::AV_CODEC_ID_PRORES; +export using ::AV_CODEC_ID_PRORES_RAW; +export using ::AV_CODEC_ID_PROSUMER; +export using ::AV_CODEC_ID_PSD; +export using ::AV_CODEC_ID_PTX; +export using ::AV_CODEC_ID_QCELP; +export using ::AV_CODEC_ID_QDM2; +export using ::AV_CODEC_ID_QDMC; +export using ::AV_CODEC_ID_QDRAW; +export using ::AV_CODEC_ID_QOA; +export using ::AV_CODEC_ID_QOI; +export using ::AV_CODEC_ID_QPEG; +export using ::AV_CODEC_ID_QTRLE; +export using ::AV_CODEC_ID_R10K; +export using ::AV_CODEC_ID_R210; +export using ::AV_CODEC_ID_RADIANCE_HDR; +export using ::AV_CODEC_ID_RALF; +export using ::AV_CODEC_ID_RASC; +export using ::AV_CODEC_ID_RAWVIDEO; +export using ::AV_CODEC_ID_RA_144; +export using ::AV_CODEC_ID_RA_288; +export using ::AV_CODEC_ID_REALTEXT; +export using ::AV_CODEC_ID_RKA; +export using ::AV_CODEC_ID_RL2; +export using ::AV_CODEC_ID_ROQ; +export using ::AV_CODEC_ID_ROQ_DPCM; +export using ::AV_CODEC_ID_RPZA; +export using ::AV_CODEC_ID_RSCC; +export using ::AV_CODEC_ID_RTV1; +export using ::AV_CODEC_ID_RV10; +export using ::AV_CODEC_ID_RV20; +export using ::AV_CODEC_ID_RV30; +export using ::AV_CODEC_ID_RV40; +export using ::AV_CODEC_ID_RV60; +export using ::AV_CODEC_ID_S302M; +export using ::AV_CODEC_ID_SAMI; +export using ::AV_CODEC_ID_SANM; +export using ::AV_CODEC_ID_SBC; +export using ::AV_CODEC_ID_SCPR; +export using ::AV_CODEC_ID_SCREENPRESSO; +export using ::AV_CODEC_ID_SCTE_35; +export using ::AV_CODEC_ID_SDX2_DPCM; +export using ::AV_CODEC_ID_SGA_VIDEO; +export using ::AV_CODEC_ID_SGI; +export using ::AV_CODEC_ID_SGIRLE; +export using ::AV_CODEC_ID_SHEERVIDEO; +export using ::AV_CODEC_ID_SHORTEN; +export using ::AV_CODEC_ID_SIMBIOSIS_IMX; +export using ::AV_CODEC_ID_SIPR; +export using ::AV_CODEC_ID_SIREN; +export using ::AV_CODEC_ID_SMACKAUDIO; +export using ::AV_CODEC_ID_SMACKVIDEO; +export using ::AV_CODEC_ID_SMC; +export using ::AV_CODEC_ID_SMPTE_2038; +export using ::AV_CODEC_ID_SMPTE_436M_ANC; +export using ::AV_CODEC_ID_SMPTE_KLV; +export using ::AV_CODEC_ID_SMV; +export using ::AV_CODEC_ID_SMVJPEG; +export using ::AV_CODEC_ID_SNOW; +export using ::AV_CODEC_ID_SOL_DPCM; +export using ::AV_CODEC_ID_SONIC; +export using ::AV_CODEC_ID_SONIC_LS; +export using ::AV_CODEC_ID_SP5X; +export using ::AV_CODEC_ID_SPEEDHQ; +export using ::AV_CODEC_ID_SPEEX; +export using ::AV_CODEC_ID_SRGC; +export using ::AV_CODEC_ID_SRT; +export using ::AV_CODEC_ID_SSA; +export using ::AV_CODEC_ID_STL; +export using ::AV_CODEC_ID_SUBRIP; +export using ::AV_CODEC_ID_SUBVIEWER; +export using ::AV_CODEC_ID_SUBVIEWER1; +export using ::AV_CODEC_ID_SUNRAST; +export using ::AV_CODEC_ID_SVG; +export using ::AV_CODEC_ID_SVQ1; +export using ::AV_CODEC_ID_SVQ3; +export using ::AV_CODEC_ID_TAK; +export using ::AV_CODEC_ID_TARGA; +export using ::AV_CODEC_ID_TARGA_Y216; +export using ::AV_CODEC_ID_TDSC; +export using ::AV_CODEC_ID_TEXT; +export using ::AV_CODEC_ID_TGQ; +export using ::AV_CODEC_ID_TGV; +export using ::AV_CODEC_ID_THEORA; +export using ::AV_CODEC_ID_THP; +export using ::AV_CODEC_ID_TIERTEXSEQVIDEO; +export using ::AV_CODEC_ID_TIFF; +export using ::AV_CODEC_ID_TIMED_ID3; +export using ::AV_CODEC_ID_TMV; +export using ::AV_CODEC_ID_TQI; +export using ::AV_CODEC_ID_TRUEHD; +export using ::AV_CODEC_ID_TRUEMOTION1; +export using ::AV_CODEC_ID_TRUEMOTION2; +export using ::AV_CODEC_ID_TRUEMOTION2RT; +export using ::AV_CODEC_ID_TRUESPEECH; +export using ::AV_CODEC_ID_TSCC; +export using ::AV_CODEC_ID_TSCC2; +export using ::AV_CODEC_ID_TTA; +export using ::AV_CODEC_ID_TTF; +export using ::AV_CODEC_ID_TTML; +export using ::AV_CODEC_ID_TWINVQ; +export using ::AV_CODEC_ID_TXD; +export using ::AV_CODEC_ID_ULTI; +export using ::AV_CODEC_ID_UTVIDEO; +export using ::AV_CODEC_ID_V210; +export using ::AV_CODEC_ID_V210X; +export using ::AV_CODEC_ID_V308; +export using ::AV_CODEC_ID_V408; +export using ::AV_CODEC_ID_V410; +export using ::AV_CODEC_ID_VB; +export using ::AV_CODEC_ID_VBLE; +export using ::AV_CODEC_ID_VBN; +export using ::AV_CODEC_ID_VC1; +export using ::AV_CODEC_ID_VC1IMAGE; +export using ::AV_CODEC_ID_VCR1; +export using ::AV_CODEC_ID_VIXL; +export using ::AV_CODEC_ID_VMDAUDIO; +export using ::AV_CODEC_ID_VMDVIDEO; +export using ::AV_CODEC_ID_VMIX; +export using ::AV_CODEC_ID_VMNC; +export using ::AV_CODEC_ID_VNULL; +export using ::AV_CODEC_ID_VORBIS; +export using ::AV_CODEC_ID_VP3; +export using ::AV_CODEC_ID_VP4; +export using ::AV_CODEC_ID_VP5; +export using ::AV_CODEC_ID_VP6; +export using ::AV_CODEC_ID_VP6A; +export using ::AV_CODEC_ID_VP6F; +export using ::AV_CODEC_ID_VP7; +export using ::AV_CODEC_ID_VP8; +export using ::AV_CODEC_ID_VP9; +export using ::AV_CODEC_ID_VPLAYER; +export using ::AV_CODEC_ID_VQC; +export using ::AV_CODEC_ID_VVC; +export using ::AV_CODEC_ID_WADY_DPCM; +export using ::AV_CODEC_ID_WAVARC; +export using ::AV_CODEC_ID_WAVPACK; +export using ::AV_CODEC_ID_WBMP; +export using ::AV_CODEC_ID_WCMV; +export using ::AV_CODEC_ID_WEBP; +export using ::AV_CODEC_ID_WEBVTT; +export using ::AV_CODEC_ID_WESTWOOD_SND1; +export using ::AV_CODEC_ID_WMALOSSLESS; +export using ::AV_CODEC_ID_WMAPRO; +export using ::AV_CODEC_ID_WMAV1; +export using ::AV_CODEC_ID_WMAV2; +export using ::AV_CODEC_ID_WMAVOICE; +export using ::AV_CODEC_ID_WMV1; +export using ::AV_CODEC_ID_WMV2; +export using ::AV_CODEC_ID_WMV3; +export using ::AV_CODEC_ID_WMV3IMAGE; +export using ::AV_CODEC_ID_WNV1; +export using ::AV_CODEC_ID_WRAPPED_AVFRAME; +export using ::AV_CODEC_ID_WS_VQA; +export using ::AV_CODEC_ID_XAN_DPCM; +export using ::AV_CODEC_ID_XAN_WC3; +export using ::AV_CODEC_ID_XAN_WC4; +export using ::AV_CODEC_ID_XBIN; +export using ::AV_CODEC_ID_XBM; +export using ::AV_CODEC_ID_XFACE; +export using ::AV_CODEC_ID_XMA1; +export using ::AV_CODEC_ID_XMA2; +export using ::AV_CODEC_ID_XPM; +export using ::AV_CODEC_ID_XSUB; +export using ::AV_CODEC_ID_XWD; +export using ::AV_CODEC_ID_Y41P; +export using ::AV_CODEC_ID_YLC; +export using ::AV_CODEC_ID_YOP; +export using ::AV_CODEC_ID_YUV4; +export using ::AV_CODEC_ID_ZEROCODEC; +export using ::AV_CODEC_ID_ZLIB; +export using ::AV_CODEC_ID_ZMBV; +export using ::AV_EXIF_ASSUME_BE; +export using ::AV_EXIF_ASSUME_LE; +export using ::AV_EXIF_EXIF00; +export using ::AV_EXIF_TIFF_HEADER; +export using ::AV_EXIF_T_OFF; +export using ::AV_FIELD_BB; +export using ::AV_FIELD_BT; +export using ::AV_FIELD_PROGRESSIVE; +export using ::AV_FIELD_TB; +export using ::AV_FIELD_TT; +export using ::AV_FIELD_UNKNOWN; +export using ::AV_PICTURE_STRUCTURE_BOTTOM_FIELD; +export using ::AV_PICTURE_STRUCTURE_FRAME; +export using ::AV_PICTURE_STRUCTURE_TOP_FIELD; +export using ::AV_PICTURE_STRUCTURE_UNKNOWN; +export using ::AV_PKT_DATA_3D_REFERENCE_DISPLAYS; +export using ::AV_PKT_DATA_A53_CC; +export using ::AV_PKT_DATA_AFD; +export using ::AV_PKT_DATA_AMBIENT_VIEWING_ENVIRONMENT; +export using ::AV_PKT_DATA_AUDIO_SERVICE_TYPE; +export using ::AV_PKT_DATA_CONTENT_LIGHT_LEVEL; +export using ::AV_PKT_DATA_CPB_PROPERTIES; +export using ::AV_PKT_DATA_DISPLAYMATRIX; +export using ::AV_PKT_DATA_DOVI_CONF; +export using ::AV_PKT_DATA_DYNAMIC_HDR10_PLUS; +export using ::AV_PKT_DATA_ENCRYPTION_INFO; +export using ::AV_PKT_DATA_ENCRYPTION_INIT_INFO; +export using ::AV_PKT_DATA_EXIF; +export using ::AV_PKT_DATA_FALLBACK_TRACK; +export using ::AV_PKT_DATA_FRAME_CROPPING; +export using ::AV_PKT_DATA_H263_MB_INFO; +export using ::AV_PKT_DATA_IAMF_DEMIXING_INFO_PARAM; +export using ::AV_PKT_DATA_IAMF_MIX_GAIN_PARAM; +export using ::AV_PKT_DATA_IAMF_RECON_GAIN_INFO_PARAM; +export using ::AV_PKT_DATA_ICC_PROFILE; +export using ::AV_PKT_DATA_JP_DUALMONO; +export using ::AV_PKT_DATA_LCEVC; +export using ::AV_PKT_DATA_MASTERING_DISPLAY_METADATA; +export using ::AV_PKT_DATA_MATROSKA_BLOCKADDITIONAL; +export using ::AV_PKT_DATA_METADATA_UPDATE; +export using ::AV_PKT_DATA_MPEGTS_STREAM_ID; +export using ::AV_PKT_DATA_NB; +export using ::AV_PKT_DATA_NEW_EXTRADATA; +export using ::AV_PKT_DATA_PALETTE; +export using ::AV_PKT_DATA_PARAM_CHANGE; +export using ::AV_PKT_DATA_PRFT; +export using ::AV_PKT_DATA_QUALITY_STATS; +export using ::AV_PKT_DATA_REPLAYGAIN; +export using ::AV_PKT_DATA_RTCP_SR; +export using ::AV_PKT_DATA_S12M_TIMECODE; +export using ::AV_PKT_DATA_SKIP_SAMPLES; +export using ::AV_PKT_DATA_SPHERICAL; +export using ::AV_PKT_DATA_STEREO3D; +export using ::AV_PKT_DATA_STRINGS_METADATA; +export using ::AV_PKT_DATA_SUBTITLE_POSITION; +export using ::AV_PKT_DATA_WEBVTT_IDENTIFIER; +export using ::AV_PKT_DATA_WEBVTT_SETTINGS; +export using ::AV_SIDE_DATA_PARAM_CHANGE_DIMENSIONS; +export using ::AV_SIDE_DATA_PARAM_CHANGE_SAMPLE_RATE; +export using ::AV_SMPTE_436M_PAYLOAD_SAMPLE_CODING_10BIT_COLOR_DIFF; +export using ::AV_SMPTE_436M_PAYLOAD_SAMPLE_CODING_10BIT_LUMA; +export using ::AV_SMPTE_436M_PAYLOAD_SAMPLE_CODING_10BIT_LUMA_AND_COLOR_DIFF; +export using ::AV_SMPTE_436M_PAYLOAD_SAMPLE_CODING_1BIT_COLOR_DIFF; +export using ::AV_SMPTE_436M_PAYLOAD_SAMPLE_CODING_1BIT_LUMA; +export using ::AV_SMPTE_436M_PAYLOAD_SAMPLE_CODING_1BIT_LUMA_AND_COLOR_DIFF; +export using ::AV_SMPTE_436M_PAYLOAD_SAMPLE_CODING_8BIT_COLOR_DIFF; +export using ::AV_SMPTE_436M_PAYLOAD_SAMPLE_CODING_8BIT_COLOR_DIFF_WITH_PARITY_ERROR; +export using ::AV_SMPTE_436M_PAYLOAD_SAMPLE_CODING_8BIT_LUMA; +export using ::AV_SMPTE_436M_PAYLOAD_SAMPLE_CODING_8BIT_LUMA_AND_COLOR_DIFF; +export using ::AV_SMPTE_436M_PAYLOAD_SAMPLE_CODING_8BIT_LUMA_AND_COLOR_DIFF_WITH_PARITY_ERROR; +export using ::AV_SMPTE_436M_PAYLOAD_SAMPLE_CODING_8BIT_LUMA_WITH_PARITY_ERROR; +export using ::AV_SMPTE_436M_PAYLOAD_SAMPLE_CODING_MAX; +export using ::AV_SMPTE_436M_WRAPPING_TYPE_HANC_FIELD_1; +export using ::AV_SMPTE_436M_WRAPPING_TYPE_HANC_FIELD_2; +export using ::AV_SMPTE_436M_WRAPPING_TYPE_HANC_FRAME; +export using ::AV_SMPTE_436M_WRAPPING_TYPE_HANC_PROGRESSIVE_FRAME; +export using ::AV_SMPTE_436M_WRAPPING_TYPE_MAX; +export using ::AV_SMPTE_436M_WRAPPING_TYPE_VANC_FIELD_1; +export using ::AV_SMPTE_436M_WRAPPING_TYPE_VANC_FIELD_2; +export using ::AV_SMPTE_436M_WRAPPING_TYPE_VANC_FRAME; +export using ::AV_SMPTE_436M_WRAPPING_TYPE_VANC_PROGRESSIVE_FRAME; +export using ::AV_TIFF_BYTE; +export using ::AV_TIFF_DOUBLE; +export using ::AV_TIFF_FLOAT; +export using ::AV_TIFF_IFD; +export using ::AV_TIFF_LONG; +export using ::AV_TIFF_RATIONAL; +export using ::AV_TIFF_SBYTE; +export using ::AV_TIFF_SHORT; +export using ::AV_TIFF_SLONG; +export using ::AV_TIFF_SRATIONAL; +export using ::AV_TIFF_SSHORT; +export using ::AV_TIFF_STRING; +export using ::AV_TIFF_UNDEFINED; + +// functions (142) +export using ::av_ac3_parse_header; +export using ::av_adts_header_parse; +export using ::av_bsf_alloc; +export using ::av_bsf_flush; +export using ::av_bsf_free; +export using ::av_bsf_get_by_name; +export using ::av_bsf_get_class; +export using ::av_bsf_get_null_filter; +export using ::av_bsf_init; +export using ::av_bsf_iterate; +export using ::av_bsf_list_alloc; +export using ::av_bsf_list_append; +export using ::av_bsf_list_append2; +export using ::av_bsf_list_finalize; +export using ::av_bsf_list_free; +export using ::av_bsf_list_parse_str; +export using ::av_bsf_receive_packet; +export using ::av_bsf_send_packet; +export using ::av_codec_is_decoder; +export using ::av_codec_is_encoder; +export using ::av_codec_iterate; +export using ::av_cpb_properties_alloc; +export using ::av_dirac_parse_sequence_header; +export using ::av_dv_codec_profile; +export using ::av_dv_codec_profile2; +export using ::av_dv_frame_profile; +export using ::av_exif_clone_ifd; +export using ::av_exif_free; +export using ::av_exif_get_entry; +export using ::av_exif_get_tag_id; +export using ::av_exif_get_tag_name; +export using ::av_exif_ifd_to_dict; +export using ::av_exif_matrix_to_orientation; +export using ::av_exif_orientation_to_matrix; +export using ::av_exif_parse_buffer; +export using ::av_exif_remove_entry; +export using ::av_exif_set_entry; +export using ::av_exif_write; +export using ::av_fast_padded_malloc; +export using ::av_fast_padded_mallocz; +export using ::av_get_audio_frame_duration; +export using ::av_get_audio_frame_duration2; +export using ::av_get_bits_per_sample; +export using ::av_get_exact_bits_per_sample; +export using ::av_get_pcm_codec; +export using ::av_get_profile_name; +export using ::av_grow_packet; +export using ::av_init_packet; +export using ::av_new_packet; +export using ::av_packet_add_side_data; +export using ::av_packet_alloc; +export using ::av_packet_clone; +export using ::av_packet_copy_props; +export using ::av_packet_free; +export using ::av_packet_free_side_data; +export using ::av_packet_from_data; +export using ::av_packet_get_side_data; +export using ::av_packet_make_refcounted; +export using ::av_packet_make_writable; +export using ::av_packet_move_ref; +export using ::av_packet_new_side_data; +export using ::av_packet_pack_dictionary; +export using ::av_packet_ref; +export using ::av_packet_rescale_ts; +export using ::av_packet_shrink_side_data; +export using ::av_packet_side_data_add; +export using ::av_packet_side_data_free; +export using ::av_packet_side_data_from_frame; +export using ::av_packet_side_data_get; +export using ::av_packet_side_data_name; +export using ::av_packet_side_data_new; +export using ::av_packet_side_data_remove; +export using ::av_packet_side_data_to_frame; +export using ::av_packet_unpack_dictionary; +export using ::av_packet_unref; +export using ::av_parser_close; +export using ::av_parser_init; +export using ::av_parser_iterate; +export using ::av_parser_parse2; +export using ::av_shrink_packet; +export using ::av_smpte_291m_anc_8bit_decode; +export using ::av_smpte_291m_anc_8bit_encode; +export using ::av_smpte_291m_anc_8bit_extract_cta_708; +export using ::av_smpte_291m_anc_8bit_fill_checksum; +export using ::av_smpte_291m_anc_8bit_get_sample_count; +export using ::av_smpte_436m_anc_append; +export using ::av_smpte_436m_anc_encode; +export using ::av_smpte_436m_anc_iter_init; +export using ::av_smpte_436m_anc_iter_next; +export using ::av_smpte_436m_coded_anc_payload_size; +export using ::av_smpte_436m_coded_anc_validate; +export using ::av_xiphlacing; +export using ::avcodec_align_dimensions; +export using ::avcodec_align_dimensions2; +export using ::avcodec_alloc_context3; +export using ::avcodec_configuration; +export using ::avcodec_dct_alloc; +export using ::avcodec_dct_get_class; +export using ::avcodec_dct_init; +export using ::avcodec_decode_subtitle2; +export using ::avcodec_default_execute; +export using ::avcodec_default_execute2; +export using ::avcodec_default_get_buffer2; +export using ::avcodec_default_get_encode_buffer; +export using ::avcodec_default_get_format; +export using ::avcodec_descriptor_get; +export using ::avcodec_descriptor_get_by_name; +export using ::avcodec_descriptor_next; +export using ::avcodec_encode_subtitle; +export using ::avcodec_fill_audio_frame; +export using ::avcodec_find_best_pix_fmt_of_list; +export using ::avcodec_find_decoder; +export using ::avcodec_find_decoder_by_name; +export using ::avcodec_find_encoder; +export using ::avcodec_find_encoder_by_name; +export using ::avcodec_flush_buffers; +export using ::avcodec_free_context; +export using ::avcodec_get_class; +export using ::avcodec_get_hw_config; +export using ::avcodec_get_hw_frames_parameters; +export using ::avcodec_get_name; +export using ::avcodec_get_subtitle_rect_class; +export using ::avcodec_get_supported_config; +export using ::avcodec_get_type; +export using ::avcodec_is_open; +export using ::avcodec_license; +export using ::avcodec_open2; +export using ::avcodec_parameters_alloc; +export using ::avcodec_parameters_copy; +export using ::avcodec_parameters_free; +export using ::avcodec_parameters_from_context; +export using ::avcodec_parameters_to_context; +export using ::avcodec_pix_fmt_to_codec_tag; +export using ::avcodec_profile_name; +export using ::avcodec_receive_frame; +export using ::avcodec_receive_frame_flags; +export using ::avcodec_receive_packet; +export using ::avcodec_send_frame; +export using ::avcodec_send_packet; +export using ::avcodec_string; +export using ::avcodec_version; +export using ::avsubtitle_free; diff --git a/src/gen_exports/avcodec.includes.inc b/src/gen_exports/avcodec.includes.inc new file mode 100644 index 0000000..a318204 --- /dev/null +++ b/src/gen_exports/avcodec.includes.inc @@ -0,0 +1,19 @@ +// Auto-generated by tools/gen_exports.py — installed public headers of libavcodec. + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include diff --git a/src/gen_exports/avcodec.skipped.txt b/src/gen_exports/avcodec.skipped.txt new file mode 100644 index 0000000..dcc75a4 --- /dev/null +++ b/src/gen_exports/avcodec.skipped.txt @@ -0,0 +1,346 @@ +ac3_parser.h: macro AVCODEC_AC3_PARSER_H +adts_parser.h: macro AVCODEC_ADTS_PARSER_H +adts_parser.h: macro AV_AAC_ADTS_HEADER_SIZE +avcodec.h: macro AVCODEC_AVCODEC_H +avcodec.h: macro AV_CODEC_EXPORT_DATA_ENHANCEMENTS +avcodec.h: macro AV_CODEC_EXPORT_DATA_FILM_GRAIN +avcodec.h: macro AV_CODEC_EXPORT_DATA_MVS +avcodec.h: macro AV_CODEC_EXPORT_DATA_PRFT +avcodec.h: macro AV_CODEC_EXPORT_DATA_VIDEO_ENC_PARAMS +avcodec.h: macro AV_CODEC_FLAG2_CHUNKS +avcodec.h: macro AV_CODEC_FLAG2_EXPORT_MVS +avcodec.h: macro AV_CODEC_FLAG2_FAST +avcodec.h: macro AV_CODEC_FLAG2_ICC_PROFILES +avcodec.h: macro AV_CODEC_FLAG2_IGNORE_CROP +avcodec.h: macro AV_CODEC_FLAG2_LOCAL_HEADER +avcodec.h: macro AV_CODEC_FLAG2_NO_OUTPUT +avcodec.h: macro AV_CODEC_FLAG2_RO_FLUSH_NOOP +avcodec.h: macro AV_CODEC_FLAG2_SHOW_ALL +avcodec.h: macro AV_CODEC_FLAG2_SKIP_MANUAL +avcodec.h: macro AV_CODEC_FLAG_4MV +avcodec.h: macro AV_CODEC_FLAG_AC_PRED +avcodec.h: macro AV_CODEC_FLAG_BITEXACT +avcodec.h: macro AV_CODEC_FLAG_CLOSED_GOP +avcodec.h: macro AV_CODEC_FLAG_COPY_OPAQUE +avcodec.h: macro AV_CODEC_FLAG_FRAME_DURATION +avcodec.h: macro AV_CODEC_FLAG_GLOBAL_HEADER +avcodec.h: macro AV_CODEC_FLAG_GRAY +avcodec.h: macro AV_CODEC_FLAG_INTERLACED_DCT +avcodec.h: macro AV_CODEC_FLAG_INTERLACED_ME +avcodec.h: macro AV_CODEC_FLAG_LOOP_FILTER +avcodec.h: macro AV_CODEC_FLAG_LOW_DELAY +avcodec.h: macro AV_CODEC_FLAG_OUTPUT_CORRUPT +avcodec.h: macro AV_CODEC_FLAG_PASS1 +avcodec.h: macro AV_CODEC_FLAG_PASS2 +avcodec.h: macro AV_CODEC_FLAG_PSNR +avcodec.h: macro AV_CODEC_FLAG_QPEL +avcodec.h: macro AV_CODEC_FLAG_QSCALE +avcodec.h: macro AV_CODEC_FLAG_RECON_FRAME +avcodec.h: macro AV_CODEC_FLAG_UNALIGNED +avcodec.h: macro AV_CODEC_RECEIVE_FRAME_FLAG_SYNCHRONOUS +avcodec.h: macro AV_GET_BUFFER_FLAG_REF +avcodec.h: macro AV_GET_ENCODE_BUFFER_FLAG_REF +avcodec.h: macro AV_HWACCEL_CODEC_CAP_EXPERIMENTAL +avcodec.h: macro AV_HWACCEL_FLAG_ALLOW_HIGH_DEPTH +avcodec.h: macro AV_HWACCEL_FLAG_ALLOW_PROFILE_MISMATCH +avcodec.h: macro AV_HWACCEL_FLAG_IGNORE_LEVEL +avcodec.h: macro AV_HWACCEL_FLAG_UNSAFE_OUTPUT +avcodec.h: macro AV_PARSER_PTS_NB +avcodec.h: macro AV_SUBTITLE_FLAG_FORCED +avcodec.h: macro FF_BUG_AMV +avcodec.h: macro FF_BUG_AUTODETECT +avcodec.h: macro FF_BUG_DC_CLIP +avcodec.h: macro FF_BUG_DIRECT_BLOCKSIZE +avcodec.h: macro FF_BUG_EDGE +avcodec.h: macro FF_BUG_HPEL_CHROMA +avcodec.h: macro FF_BUG_IEDGE +avcodec.h: macro FF_BUG_MS +avcodec.h: macro FF_BUG_NO_PADDING +avcodec.h: macro FF_BUG_QPEL_CHROMA +avcodec.h: macro FF_BUG_QPEL_CHROMA2 +avcodec.h: macro FF_BUG_STD_QPEL +avcodec.h: macro FF_BUG_TRUNCATED +avcodec.h: macro FF_BUG_UMP4 +avcodec.h: macro FF_BUG_XVID_ILACE +avcodec.h: macro FF_CMP_BIT +avcodec.h: macro FF_CMP_CHROMA +avcodec.h: macro FF_CMP_DCT +avcodec.h: macro FF_CMP_DCT264 +avcodec.h: macro FF_CMP_DCTMAX +avcodec.h: macro FF_CMP_MEDIAN_SAD +avcodec.h: macro FF_CMP_NSSE +avcodec.h: macro FF_CMP_PSNR +avcodec.h: macro FF_CMP_RD +avcodec.h: macro FF_CMP_SAD +avcodec.h: macro FF_CMP_SATD +avcodec.h: macro FF_CMP_SSE +avcodec.h: macro FF_CMP_VSAD +avcodec.h: macro FF_CMP_VSSE +avcodec.h: macro FF_CMP_W53 +avcodec.h: macro FF_CMP_W97 +avcodec.h: macro FF_CMP_ZERO +avcodec.h: macro FF_CODEC_PROPERTY_CLOSED_CAPTIONS +avcodec.h: macro FF_CODEC_PROPERTY_FILM_GRAIN +avcodec.h: macro FF_CODEC_PROPERTY_LOSSLESS +avcodec.h: macro FF_COMPRESSION_DEFAULT +avcodec.h: macro FF_DCT_ALTIVEC +avcodec.h: macro FF_DCT_AUTO +avcodec.h: macro FF_DCT_FAAN +avcodec.h: macro FF_DCT_FASTINT +avcodec.h: macro FF_DCT_INT +avcodec.h: macro FF_DCT_MMX +avcodec.h: macro FF_DCT_NEON +avcodec.h: macro FF_DEBUG_BITSTREAM +avcodec.h: macro FF_DEBUG_BUFFERS +avcodec.h: macro FF_DEBUG_BUGS +avcodec.h: macro FF_DEBUG_DCT_COEFF +avcodec.h: macro FF_DEBUG_ER +avcodec.h: macro FF_DEBUG_GREEN_MD +avcodec.h: macro FF_DEBUG_MB_TYPE +avcodec.h: macro FF_DEBUG_MMCO +avcodec.h: macro FF_DEBUG_NOMC +avcodec.h: macro FF_DEBUG_PICT_INFO +avcodec.h: macro FF_DEBUG_QP +avcodec.h: macro FF_DEBUG_RC +avcodec.h: macro FF_DEBUG_SKIP +avcodec.h: macro FF_DEBUG_STARTCODE +avcodec.h: macro FF_DEBUG_THREADS +avcodec.h: macro FF_EC_DEBLOCK +avcodec.h: macro FF_EC_FAVOR_INTER +avcodec.h: macro FF_EC_GUESS_MVS +avcodec.h: macro FF_IDCT_ALTIVEC +avcodec.h: macro FF_IDCT_ARM +avcodec.h: macro FF_IDCT_AUTO +avcodec.h: macro FF_IDCT_FAAN +avcodec.h: macro FF_IDCT_INT +avcodec.h: macro FF_IDCT_SIMPLE +avcodec.h: macro FF_IDCT_SIMPLEARM +avcodec.h: macro FF_IDCT_SIMPLEARMV5TE +avcodec.h: macro FF_IDCT_SIMPLEARMV6 +avcodec.h: macro FF_IDCT_SIMPLEAUTO +avcodec.h: macro FF_IDCT_SIMPLEMMX +avcodec.h: macro FF_IDCT_SIMPLENEON +avcodec.h: macro FF_IDCT_XVID +avcodec.h: macro FF_MB_DECISION_BITS +avcodec.h: macro FF_MB_DECISION_RD +avcodec.h: macro FF_MB_DECISION_SIMPLE +avcodec.h: macro FF_SUB_CHARENC_MODE_AUTOMATIC +avcodec.h: macro FF_SUB_CHARENC_MODE_DO_NOTHING +avcodec.h: macro FF_SUB_CHARENC_MODE_IGNORE +avcodec.h: macro FF_SUB_CHARENC_MODE_PRE_DECODER +avcodec.h: macro FF_THREAD_FRAME +avcodec.h: macro FF_THREAD_SLICE +avcodec.h: macro PARSER_FLAG_COMPLETE_FRAMES +avcodec.h: macro PARSER_FLAG_FETCHED_OFFSET +avcodec.h: macro PARSER_FLAG_ONCE +avcodec.h: macro PARSER_FLAG_USE_CODEC_TS +avcodec.h: macro SLICE_FLAG_ALLOW_FIELD +avcodec.h: macro SLICE_FLAG_ALLOW_PLANE +avcodec.h: macro SLICE_FLAG_CODED_ORDER +avdct.h: macro AVCODEC_AVDCT_H +bsf.h: macro AVCODEC_BSF_H +codec.h: macro AVCODEC_CODEC_H +codec.h: macro AV_CODEC_CAP_AVOID_PROBING +codec.h: macro AV_CODEC_CAP_CHANNEL_CONF +codec.h: macro AV_CODEC_CAP_DELAY +codec.h: macro AV_CODEC_CAP_DR1 +codec.h: macro AV_CODEC_CAP_DRAW_HORIZ_BAND +codec.h: macro AV_CODEC_CAP_ENCODER_FLUSH +codec.h: macro AV_CODEC_CAP_ENCODER_RECON_FRAME +codec.h: macro AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE +codec.h: macro AV_CODEC_CAP_EXPERIMENTAL +codec.h: macro AV_CODEC_CAP_FRAME_THREADS +codec.h: macro AV_CODEC_CAP_HARDWARE +codec.h: macro AV_CODEC_CAP_HYBRID +codec.h: macro AV_CODEC_CAP_OTHER_THREADS +codec.h: macro AV_CODEC_CAP_PARAM_CHANGE +codec.h: macro AV_CODEC_CAP_SLICE_THREADS +codec.h: macro AV_CODEC_CAP_SMALL_LAST_FRAME +codec.h: macro AV_CODEC_CAP_VARIABLE_FRAME_SIZE +codec_desc.h: macro AVCODEC_CODEC_DESC_H +codec_desc.h: macro AV_CODEC_PROP_BITMAP_SUB +codec_desc.h: macro AV_CODEC_PROP_ENHANCEMENT +codec_desc.h: macro AV_CODEC_PROP_FIELDS +codec_desc.h: macro AV_CODEC_PROP_INTRA_ONLY +codec_desc.h: macro AV_CODEC_PROP_LOSSLESS +codec_desc.h: macro AV_CODEC_PROP_LOSSY +codec_desc.h: macro AV_CODEC_PROP_REORDER +codec_desc.h: macro AV_CODEC_PROP_TEXT_SUB +codec_id.h: macro AVCODEC_CODEC_ID_H +codec_id.h: macro AV_CODEC_ID_H265 +codec_id.h: macro AV_CODEC_ID_H266 +codec_id.h: macro AV_CODEC_ID_IFF_BYTERUN1 +codec_par.h: macro AVCODEC_CODEC_PAR_H +defs.h: macro AVCODEC_DEFS_H +defs.h: macro AV_EF_AGGRESSIVE +defs.h: macro AV_EF_BITSTREAM +defs.h: macro AV_EF_BUFFER +defs.h: macro AV_EF_CAREFUL +defs.h: macro AV_EF_COMPLIANT +defs.h: macro AV_EF_CRCCHECK +defs.h: macro AV_EF_EXPLODE +defs.h: macro AV_EF_IGNORE_ERR +defs.h: macro AV_INPUT_BUFFER_PADDING_SIZE +defs.h: macro AV_LEVEL_UNKNOWN +defs.h: macro AV_PROFILE_AAC_ELD +defs.h: macro AV_PROFILE_AAC_HE +defs.h: macro AV_PROFILE_AAC_HE_V2 +defs.h: macro AV_PROFILE_AAC_LD +defs.h: macro AV_PROFILE_AAC_LOW +defs.h: macro AV_PROFILE_AAC_LTP +defs.h: macro AV_PROFILE_AAC_MAIN +defs.h: macro AV_PROFILE_AAC_SSR +defs.h: macro AV_PROFILE_AAC_USAC +defs.h: macro AV_PROFILE_APV_400_10 +defs.h: macro AV_PROFILE_APV_422_10 +defs.h: macro AV_PROFILE_APV_422_12 +defs.h: macro AV_PROFILE_APV_4444_10 +defs.h: macro AV_PROFILE_APV_4444_12 +defs.h: macro AV_PROFILE_APV_444_10 +defs.h: macro AV_PROFILE_APV_444_12 +defs.h: macro AV_PROFILE_ARIB_PROFILE_A +defs.h: macro AV_PROFILE_ARIB_PROFILE_C +defs.h: macro AV_PROFILE_AV1_HIGH +defs.h: macro AV_PROFILE_AV1_MAIN +defs.h: macro AV_PROFILE_AV1_PROFESSIONAL +defs.h: macro AV_PROFILE_DNXHD +defs.h: macro AV_PROFILE_DNXHR_444 +defs.h: macro AV_PROFILE_DNXHR_HQ +defs.h: macro AV_PROFILE_DNXHR_HQX +defs.h: macro AV_PROFILE_DNXHR_LB +defs.h: macro AV_PROFILE_DNXHR_SQ +defs.h: macro AV_PROFILE_DTS +defs.h: macro AV_PROFILE_DTS_96_24 +defs.h: macro AV_PROFILE_DTS_ES +defs.h: macro AV_PROFILE_DTS_EXPRESS +defs.h: macro AV_PROFILE_DTS_HD_HRA +defs.h: macro AV_PROFILE_DTS_HD_MA +defs.h: macro AV_PROFILE_DTS_HD_MA_X +defs.h: macro AV_PROFILE_DTS_HD_MA_X_IMAX +defs.h: macro AV_PROFILE_EAC3_DDP_ATMOS +defs.h: macro AV_PROFILE_EVC_BASELINE +defs.h: macro AV_PROFILE_EVC_MAIN +defs.h: macro AV_PROFILE_H264_BASELINE +defs.h: macro AV_PROFILE_H264_CAVLC_444 +defs.h: macro AV_PROFILE_H264_CONSTRAINED +defs.h: macro AV_PROFILE_H264_CONSTRAINED_BASELINE +defs.h: macro AV_PROFILE_H264_EXTENDED +defs.h: macro AV_PROFILE_H264_HIGH +defs.h: macro AV_PROFILE_H264_HIGH_10 +defs.h: macro AV_PROFILE_H264_HIGH_10_INTRA +defs.h: macro AV_PROFILE_H264_HIGH_422 +defs.h: macro AV_PROFILE_H264_HIGH_422_INTRA +defs.h: macro AV_PROFILE_H264_HIGH_444 +defs.h: macro AV_PROFILE_H264_HIGH_444_INTRA +defs.h: macro AV_PROFILE_H264_HIGH_444_PREDICTIVE +defs.h: macro AV_PROFILE_H264_INTRA +defs.h: macro AV_PROFILE_H264_MAIN +defs.h: macro AV_PROFILE_H264_MULTIVIEW_HIGH +defs.h: macro AV_PROFILE_H264_STEREO_HIGH +defs.h: macro AV_PROFILE_HEVC_MAIN +defs.h: macro AV_PROFILE_HEVC_MAIN_10 +defs.h: macro AV_PROFILE_HEVC_MAIN_STILL_PICTURE +defs.h: macro AV_PROFILE_HEVC_MULTIVIEW_MAIN +defs.h: macro AV_PROFILE_HEVC_REXT +defs.h: macro AV_PROFILE_HEVC_SCC +defs.h: macro AV_PROFILE_JPEG2000_CSTREAM_NO_RESTRICTION +defs.h: macro AV_PROFILE_JPEG2000_CSTREAM_RESTRICTION_0 +defs.h: macro AV_PROFILE_JPEG2000_CSTREAM_RESTRICTION_1 +defs.h: macro AV_PROFILE_JPEG2000_DCINEMA_2K +defs.h: macro AV_PROFILE_JPEG2000_DCINEMA_4K +defs.h: macro AV_PROFILE_KLVA_ASYNC +defs.h: macro AV_PROFILE_KLVA_SYNC +defs.h: macro AV_PROFILE_MJPEG_HUFFMAN_BASELINE_DCT +defs.h: macro AV_PROFILE_MJPEG_HUFFMAN_EXTENDED_SEQUENTIAL_DCT +defs.h: macro AV_PROFILE_MJPEG_HUFFMAN_LOSSLESS +defs.h: macro AV_PROFILE_MJPEG_HUFFMAN_PROGRESSIVE_DCT +defs.h: macro AV_PROFILE_MJPEG_JPEG_LS +defs.h: macro AV_PROFILE_MPEG2_422 +defs.h: macro AV_PROFILE_MPEG2_AAC_HE +defs.h: macro AV_PROFILE_MPEG2_AAC_LOW +defs.h: macro AV_PROFILE_MPEG2_HIGH +defs.h: macro AV_PROFILE_MPEG2_MAIN +defs.h: macro AV_PROFILE_MPEG2_SIMPLE +defs.h: macro AV_PROFILE_MPEG2_SNR_SCALABLE +defs.h: macro AV_PROFILE_MPEG2_SS +defs.h: macro AV_PROFILE_MPEG4_ADVANCED_CODING +defs.h: macro AV_PROFILE_MPEG4_ADVANCED_CORE +defs.h: macro AV_PROFILE_MPEG4_ADVANCED_REAL_TIME +defs.h: macro AV_PROFILE_MPEG4_ADVANCED_SCALABLE_TEXTURE +defs.h: macro AV_PROFILE_MPEG4_ADVANCED_SIMPLE +defs.h: macro AV_PROFILE_MPEG4_BASIC_ANIMATED_TEXTURE +defs.h: macro AV_PROFILE_MPEG4_CORE +defs.h: macro AV_PROFILE_MPEG4_CORE_SCALABLE +defs.h: macro AV_PROFILE_MPEG4_HYBRID +defs.h: macro AV_PROFILE_MPEG4_MAIN +defs.h: macro AV_PROFILE_MPEG4_N_BIT +defs.h: macro AV_PROFILE_MPEG4_SCALABLE_TEXTURE +defs.h: macro AV_PROFILE_MPEG4_SIMPLE +defs.h: macro AV_PROFILE_MPEG4_SIMPLE_FACE_ANIMATION +defs.h: macro AV_PROFILE_MPEG4_SIMPLE_SCALABLE +defs.h: macro AV_PROFILE_MPEG4_SIMPLE_STUDIO +defs.h: macro AV_PROFILE_PRORES_4444 +defs.h: macro AV_PROFILE_PRORES_HQ +defs.h: macro AV_PROFILE_PRORES_LT +defs.h: macro AV_PROFILE_PRORES_PROXY +defs.h: macro AV_PROFILE_PRORES_RAW +defs.h: macro AV_PROFILE_PRORES_RAW_HQ +defs.h: macro AV_PROFILE_PRORES_STANDARD +defs.h: macro AV_PROFILE_PRORES_XQ +defs.h: macro AV_PROFILE_RESERVED +defs.h: macro AV_PROFILE_SBC_MSBC +defs.h: macro AV_PROFILE_TRUEHD_ATMOS +defs.h: macro AV_PROFILE_UNKNOWN +defs.h: macro AV_PROFILE_VC1_ADVANCED +defs.h: macro AV_PROFILE_VC1_COMPLEX +defs.h: macro AV_PROFILE_VC1_MAIN +defs.h: macro AV_PROFILE_VC1_SIMPLE +defs.h: macro AV_PROFILE_VP9_0 +defs.h: macro AV_PROFILE_VP9_1 +defs.h: macro AV_PROFILE_VP9_2 +defs.h: macro AV_PROFILE_VP9_3 +defs.h: macro AV_PROFILE_VVC_MAIN_10 +defs.h: macro AV_PROFILE_VVC_MAIN_10_444 +defs.h: macro FF_COMPLIANCE_EXPERIMENTAL +defs.h: macro FF_COMPLIANCE_NORMAL +defs.h: macro FF_COMPLIANCE_STRICT +defs.h: macro FF_COMPLIANCE_UNOFFICIAL +defs.h: macro FF_COMPLIANCE_VERY_STRICT +dirac.h: macro AVCODEC_DIRAC_H +dirac.h: macro MAX_DWT_LEVELS +dv_profile.h: macro AVCODEC_DV_PROFILE_H +dv_profile.h: macro DV_PROFILE_BYTES +exif.h: macro AVCODEC_EXIF_H +exif.h: macro AV_EXIF_FLAG_RECURSIVE +packet.h: macro AVCODEC_PACKET_H +packet.h: macro AV_PKT_FLAG_CORRUPT +packet.h: macro AV_PKT_FLAG_DISCARD +packet.h: macro AV_PKT_FLAG_DISPOSABLE +packet.h: macro AV_PKT_FLAG_KEY +packet.h: macro AV_PKT_FLAG_TRUSTED +smpte_436m.h: macro AVCODEC_SMPTE_436M_H +smpte_436m.h: macro AV_SMPTE_291M_ANC_DID_CTA_708 +smpte_436m.h: macro AV_SMPTE_291M_ANC_PAYLOAD_CAPACITY +smpte_436m.h: macro AV_SMPTE_291M_ANC_SDID_CTA_708 +smpte_436m.h: macro AV_SMPTE_436M_CODED_ANC_PAYLOAD_CAPACITY +smpte_436m.h: macro AV_SMPTE_436M_CODED_ANC_SAMPLE_CAPACITY +version.h: macro AVCODEC_VERSION_H +version.h: macro LIBAVCODEC_BUILD +version.h: macro LIBAVCODEC_IDENT +version.h: macro LIBAVCODEC_VERSION +version.h: macro LIBAVCODEC_VERSION_INT +version.h: macro LIBAVCODEC_VERSION_MICRO +version.h: macro LIBAVCODEC_VERSION_MINOR +version_major.h: macro AVCODEC_VERSION_MAJOR_H +version_major.h: macro FF_API_CODEC_PROPS +version_major.h: macro FF_API_EXR_GAMMA +version_major.h: macro FF_API_INIT_PACKET +version_major.h: macro FF_API_INTRA_DC_PRECISION +version_major.h: macro FF_API_NVDEC_OLD_PIX_FMTS +version_major.h: macro FF_API_PARSER_CODECID +version_major.h: macro FF_API_PARSER_PRIVATE +version_major.h: macro FF_API_V408_CODECID +version_major.h: macro FF_CODEC_OMX +version_major.h: macro FF_CODEC_SONIC_DEC +version_major.h: macro FF_CODEC_SONIC_ENC +version_major.h: macro LIBAVCODEC_VERSION_MAJOR diff --git a/src/gen_exports/avdevice.inc b/src/gen_exports/avdevice.inc new file mode 100644 index 0000000..254351b --- /dev/null +++ b/src/gen_exports/avdevice.inc @@ -0,0 +1,52 @@ +// Auto-generated by tools/gen_exports.py from libavdevice +// public headers (3 files) — do not edit by hand. + +// structs (3) +export using ::AVDeviceInfo; +export using ::AVDeviceInfoList; +export using ::AVDeviceRect; + +// enums (2) +export using ::AVAppToDevMessageType; +export using ::AVDevToAppMessageType; + +// enumerators (23) +export using ::AV_APP_TO_DEV_GET_MUTE; +export using ::AV_APP_TO_DEV_GET_VOLUME; +export using ::AV_APP_TO_DEV_MUTE; +export using ::AV_APP_TO_DEV_NONE; +export using ::AV_APP_TO_DEV_PAUSE; +export using ::AV_APP_TO_DEV_PLAY; +export using ::AV_APP_TO_DEV_SET_VOLUME; +export using ::AV_APP_TO_DEV_TOGGLE_MUTE; +export using ::AV_APP_TO_DEV_TOGGLE_PAUSE; +export using ::AV_APP_TO_DEV_UNMUTE; +export using ::AV_APP_TO_DEV_WINDOW_REPAINT; +export using ::AV_APP_TO_DEV_WINDOW_SIZE; +export using ::AV_DEV_TO_APP_BUFFER_OVERFLOW; +export using ::AV_DEV_TO_APP_BUFFER_READABLE; +export using ::AV_DEV_TO_APP_BUFFER_UNDERFLOW; +export using ::AV_DEV_TO_APP_BUFFER_WRITABLE; +export using ::AV_DEV_TO_APP_CREATE_WINDOW_BUFFER; +export using ::AV_DEV_TO_APP_DESTROY_WINDOW_BUFFER; +export using ::AV_DEV_TO_APP_DISPLAY_WINDOW_BUFFER; +export using ::AV_DEV_TO_APP_MUTE_STATE_CHANGED; +export using ::AV_DEV_TO_APP_NONE; +export using ::AV_DEV_TO_APP_PREPARE_WINDOW_BUFFER; +export using ::AV_DEV_TO_APP_VOLUME_LEVEL_CHANGED; + +// functions (14) +export using ::av_input_audio_device_next; +export using ::av_input_video_device_next; +export using ::av_output_audio_device_next; +export using ::av_output_video_device_next; +export using ::avdevice_app_to_dev_control_message; +export using ::avdevice_configuration; +export using ::avdevice_dev_to_app_control_message; +export using ::avdevice_free_list_devices; +export using ::avdevice_license; +export using ::avdevice_list_devices; +export using ::avdevice_list_input_sources; +export using ::avdevice_list_output_sinks; +export using ::avdevice_register_all; +export using ::avdevice_version; diff --git a/src/gen_exports/avdevice.includes.inc b/src/gen_exports/avdevice.includes.inc new file mode 100644 index 0000000..bfc9231 --- /dev/null +++ b/src/gen_exports/avdevice.includes.inc @@ -0,0 +1,5 @@ +// Auto-generated by tools/gen_exports.py — installed public headers of libavdevice. + +#include +#include +#include diff --git a/src/gen_exports/avdevice.skipped.txt b/src/gen_exports/avdevice.skipped.txt new file mode 100644 index 0000000..1268d3e --- /dev/null +++ b/src/gen_exports/avdevice.skipped.txt @@ -0,0 +1,11 @@ +avdevice.h: macro AVDEVICE_AVDEVICE_H +version.h: macro AVDEVICE_VERSION_H +version.h: macro LIBAVDEVICE_BUILD +version.h: macro LIBAVDEVICE_IDENT +version.h: macro LIBAVDEVICE_VERSION +version.h: macro LIBAVDEVICE_VERSION_INT +version.h: macro LIBAVDEVICE_VERSION_MICRO +version.h: macro LIBAVDEVICE_VERSION_MINOR +version_major.h: macro AVDEVICE_VERSION_MAJOR_H +version_major.h: macro FF_API_ALSA_CHANNELS +version_major.h: macro LIBAVDEVICE_VERSION_MAJOR diff --git a/src/gen_exports/avfilter.inc b/src/gen_exports/avfilter.inc new file mode 100644 index 0000000..989e1dd --- /dev/null +++ b/src/gen_exports/avfilter.inc @@ -0,0 +1,93 @@ +// Auto-generated by tools/gen_exports.py from libavfilter +// public headers (5 files) — do not edit by hand. + +// structs (14) +export using ::AVBufferSrcParameters; +export using ::AVFilter; +export using ::AVFilterChain; +export using ::AVFilterChannelLayouts; +export using ::AVFilterContext; +export using ::AVFilterFormats; +export using ::AVFilterFormatsConfig; +export using ::AVFilterGraph; +export using ::AVFilterGraphSegment; +export using ::AVFilterInOut; +export using ::AVFilterLink; +export using ::AVFilterPad; +export using ::AVFilterPadParams; +export using ::AVFilterParams; + +// enumerators (5) +export using ::AVFILTER_AUTO_CONVERT_ALL; +export using ::AVFILTER_AUTO_CONVERT_NONE; +export using ::AV_BUFFERSRC_FLAG_KEEP_REF; +export using ::AV_BUFFERSRC_FLAG_NO_CHECK_FORMAT; +export using ::AV_BUFFERSRC_FLAG_PUSH; + +// functions (66) +export using ::av_buffersink_get_alpha_mode; +export using ::av_buffersink_get_ch_layout; +export using ::av_buffersink_get_channels; +export using ::av_buffersink_get_color_range; +export using ::av_buffersink_get_colorspace; +export using ::av_buffersink_get_format; +export using ::av_buffersink_get_frame; +export using ::av_buffersink_get_frame_flags; +export using ::av_buffersink_get_frame_rate; +export using ::av_buffersink_get_h; +export using ::av_buffersink_get_hw_frames_ctx; +export using ::av_buffersink_get_sample_aspect_ratio; +export using ::av_buffersink_get_sample_rate; +export using ::av_buffersink_get_samples; +export using ::av_buffersink_get_side_data; +export using ::av_buffersink_get_time_base; +export using ::av_buffersink_get_type; +export using ::av_buffersink_get_w; +export using ::av_buffersink_set_frame_size; +export using ::av_buffersrc_add_frame; +export using ::av_buffersrc_add_frame_flags; +export using ::av_buffersrc_close; +export using ::av_buffersrc_get_nb_failed_requests; +export using ::av_buffersrc_get_status; +export using ::av_buffersrc_parameters_alloc; +export using ::av_buffersrc_parameters_set; +export using ::av_buffersrc_write_frame; +export using ::av_filter_iterate; +export using ::avfilter_configuration; +export using ::avfilter_filter_pad_count; +export using ::avfilter_free; +export using ::avfilter_get_by_name; +export using ::avfilter_get_class; +export using ::avfilter_graph_alloc; +export using ::avfilter_graph_alloc_filter; +export using ::avfilter_graph_config; +export using ::avfilter_graph_create_filter; +export using ::avfilter_graph_dump; +export using ::avfilter_graph_free; +export using ::avfilter_graph_get_filter; +export using ::avfilter_graph_parse; +export using ::avfilter_graph_parse2; +export using ::avfilter_graph_parse_ptr; +export using ::avfilter_graph_queue_command; +export using ::avfilter_graph_request_oldest; +export using ::avfilter_graph_segment_apply; +export using ::avfilter_graph_segment_apply_opts; +export using ::avfilter_graph_segment_create_filters; +export using ::avfilter_graph_segment_free; +export using ::avfilter_graph_segment_init; +export using ::avfilter_graph_segment_link; +export using ::avfilter_graph_segment_parse; +export using ::avfilter_graph_send_command; +export using ::avfilter_graph_set_auto_convert; +export using ::avfilter_init_dict; +export using ::avfilter_init_str; +export using ::avfilter_inout_alloc; +export using ::avfilter_inout_free; +export using ::avfilter_insert_filter; +export using ::avfilter_license; +export using ::avfilter_link; +export using ::avfilter_link_get_hw_frames_ctx; +export using ::avfilter_pad_get_name; +export using ::avfilter_pad_get_type; +export using ::avfilter_process_command; +export using ::avfilter_version; diff --git a/src/gen_exports/avfilter.includes.inc b/src/gen_exports/avfilter.includes.inc new file mode 100644 index 0000000..a761789 --- /dev/null +++ b/src/gen_exports/avfilter.includes.inc @@ -0,0 +1,7 @@ +// Auto-generated by tools/gen_exports.py — installed public headers of libavfilter. + +#include +#include +#include +#include +#include diff --git a/src/gen_exports/avfilter.skipped.txt b/src/gen_exports/avfilter.skipped.txt new file mode 100644 index 0000000..9a48a0b --- /dev/null +++ b/src/gen_exports/avfilter.skipped.txt @@ -0,0 +1,28 @@ +avfilter.h: macro AVFILTER_AVFILTER_H +avfilter.h: macro AVFILTER_CMD_FLAG_FAST +avfilter.h: macro AVFILTER_CMD_FLAG_ONE +avfilter.h: macro AVFILTER_FLAG_DYNAMIC_INPUTS +avfilter.h: macro AVFILTER_FLAG_DYNAMIC_OUTPUTS +avfilter.h: macro AVFILTER_FLAG_HWDEVICE +avfilter.h: macro AVFILTER_FLAG_METADATA_ONLY +avfilter.h: macro AVFILTER_FLAG_SLICE_THREADS +avfilter.h: macro AVFILTER_FLAG_SUPPORT_TIMELINE +avfilter.h: macro AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC +avfilter.h: macro AVFILTER_FLAG_SUPPORT_TIMELINE_INTERNAL +avfilter.h: macro AVFILTER_THREAD_SLICE +buffersink.h: macro AVFILTER_BUFFERSINK_H +buffersink.h: macro AV_BUFFERSINK_FLAG_NO_REQUEST +buffersink.h: macro AV_BUFFERSINK_FLAG_PEEK +buffersrc.h: macro AVFILTER_BUFFERSRC_H +version.h: macro AVFILTER_VERSION_H +version.h: macro LIBAVFILTER_BUILD +version.h: macro LIBAVFILTER_IDENT +version.h: macro LIBAVFILTER_VERSION +version.h: macro LIBAVFILTER_VERSION_INT +version.h: macro LIBAVFILTER_VERSION_MICRO +version.h: macro LIBAVFILTER_VERSION_MINOR +version_major.h: macro AVFILTER_VERSION_MAJOR_H +version_major.h: macro FF_API_BUFFERSINK_OPTS +version_major.h: macro FF_API_CONTEXT_PUBLIC +version_major.h: macro FF_API_LIBNPP_SUPPORT +version_major.h: macro LIBAVFILTER_VERSION_MAJOR diff --git a/src/gen_exports/avformat.inc b/src/gen_exports/avformat.inc new file mode 100644 index 0000000..86b19c9 --- /dev/null +++ b/src/gen_exports/avformat.inc @@ -0,0 +1,222 @@ +// Auto-generated by tools/gen_exports.py from libavformat +// public headers (4 files) — do not edit by hand. + +// structs (23) +export using ::AVBPrint; +export using ::AVChapter; +export using ::AVCodecParserContext; +export using ::AVCodecTag; +export using ::AVFormatContext; +export using ::AVFrame; +export using ::AVIAMFAudioElement; +export using ::AVIAMFMixPresentation; +export using ::AVIOContext; +export using ::AVIODirContext; +export using ::AVIODirEntry; +export using ::AVIOInterruptCB; +export using ::AVIndexEntry; +export using ::AVInputFormat; +export using ::AVOutputFormat; +export using ::AVProbeData; +export using ::AVProgram; +export using ::AVRTSPCommandRequest; +export using ::AVRTSPResponse; +export using ::AVStream; +export using ::AVStreamGroup; +export using ::AVStreamGroupLCEVC; +export using ::AVStreamGroupTileGrid; + +// typedefs (2) +export using ::AVOpenCallback; +export using ::av_format_control_message; + +// enums (7) +export using ::AVDurationEstimationMethod; +export using ::AVFormatCommandID; +export using ::AVIODataMarkerType; +export using ::AVIODirEntryType; +export using ::AVStreamGroupParamsType; +export using ::AVStreamParseType; +export using ::AVTimebaseSource; + +// enumerators (36) +export using ::AVFMT_DURATION_FROM_BITRATE; +export using ::AVFMT_DURATION_FROM_PTS; +export using ::AVFMT_DURATION_FROM_STREAM; +export using ::AVFMT_TBCF_AUTO; +export using ::AVFMT_TBCF_DECODER; +export using ::AVFMT_TBCF_DEMUXER; +export using ::AVFMT_TBCF_R_FRAMERATE; +export using ::AVFORMAT_COMMAND_RTSP_SET_PARAMETER; +export using ::AVIO_DATA_MARKER_BOUNDARY_POINT; +export using ::AVIO_DATA_MARKER_FLUSH_POINT; +export using ::AVIO_DATA_MARKER_HEADER; +export using ::AVIO_DATA_MARKER_SYNC_POINT; +export using ::AVIO_DATA_MARKER_TRAILER; +export using ::AVIO_DATA_MARKER_UNKNOWN; +export using ::AVIO_ENTRY_BLOCK_DEVICE; +export using ::AVIO_ENTRY_CHARACTER_DEVICE; +export using ::AVIO_ENTRY_DIRECTORY; +export using ::AVIO_ENTRY_FILE; +export using ::AVIO_ENTRY_NAMED_PIPE; +export using ::AVIO_ENTRY_SERVER; +export using ::AVIO_ENTRY_SHARE; +export using ::AVIO_ENTRY_SOCKET; +export using ::AVIO_ENTRY_SYMBOLIC_LINK; +export using ::AVIO_ENTRY_UNKNOWN; +export using ::AVIO_ENTRY_WORKGROUP; +export using ::AVSTREAM_PARSE_FULL; +export using ::AVSTREAM_PARSE_FULL_ONCE; +export using ::AVSTREAM_PARSE_FULL_RAW; +export using ::AVSTREAM_PARSE_HEADERS; +export using ::AVSTREAM_PARSE_NONE; +export using ::AVSTREAM_PARSE_TIMESTAMPS; +export using ::AV_STREAM_GROUP_PARAMS_IAMF_AUDIO_ELEMENT; +export using ::AV_STREAM_GROUP_PARAMS_IAMF_MIX_PRESENTATION; +export using ::AV_STREAM_GROUP_PARAMS_LCEVC; +export using ::AV_STREAM_GROUP_PARAMS_NONE; +export using ::AV_STREAM_GROUP_PARAMS_TILE_GRID; + +// functions (142) +export using ::av_add_index_entry; +export using ::av_append_packet; +export using ::av_codec_get_id; +export using ::av_codec_get_tag; +export using ::av_codec_get_tag2; +export using ::av_demuxer_iterate; +export using ::av_disposition_from_string; +export using ::av_disposition_to_string; +export using ::av_dump_format; +export using ::av_filename_number_test; +export using ::av_find_best_stream; +export using ::av_find_default_stream_index; +export using ::av_find_input_format; +export using ::av_find_program_from_stream; +export using ::av_get_frame_filename; +export using ::av_get_frame_filename2; +export using ::av_get_output_timestamp; +export using ::av_get_packet; +export using ::av_guess_codec; +export using ::av_guess_format; +export using ::av_guess_frame_rate; +export using ::av_guess_sample_aspect_ratio; +export using ::av_hex_dump; +export using ::av_hex_dump_log; +export using ::av_index_search_timestamp; +export using ::av_interleaved_write_frame; +export using ::av_interleaved_write_uncoded_frame; +export using ::av_match_ext; +export using ::av_mime_codec_str; +export using ::av_muxer_iterate; +export using ::av_new_program; +export using ::av_pkt_dump2; +export using ::av_pkt_dump_log2; +export using ::av_probe_input_buffer; +export using ::av_probe_input_buffer2; +export using ::av_probe_input_format; +export using ::av_probe_input_format2; +export using ::av_probe_input_format3; +export using ::av_program_add_stream_index; +export using ::av_read_frame; +export using ::av_read_pause; +export using ::av_read_play; +export using ::av_sdp_create; +export using ::av_seek_frame; +export using ::av_stream_get_class; +export using ::av_stream_get_codec_timebase; +export using ::av_stream_group_get_class; +export using ::av_url_split; +export using ::av_write_frame; +export using ::av_write_trailer; +export using ::av_write_uncoded_frame; +export using ::av_write_uncoded_frame_query; +export using ::avformat_alloc_context; +export using ::avformat_alloc_output_context2; +export using ::avformat_close_input; +export using ::avformat_configuration; +export using ::avformat_find_stream_info; +export using ::avformat_flush; +export using ::avformat_free_context; +export using ::avformat_get_class; +export using ::avformat_get_mov_audio_tags; +export using ::avformat_get_mov_video_tags; +export using ::avformat_get_riff_audio_tags; +export using ::avformat_get_riff_video_tags; +export using ::avformat_index_get_entries_count; +export using ::avformat_index_get_entry; +export using ::avformat_index_get_entry_from_timestamp; +export using ::avformat_init_output; +export using ::avformat_license; +export using ::avformat_match_stream_specifier; +export using ::avformat_network_deinit; +export using ::avformat_network_init; +export using ::avformat_new_stream; +export using ::avformat_open_input; +export using ::avformat_query_codec; +export using ::avformat_queue_attached_pictures; +export using ::avformat_receive_command_reply; +export using ::avformat_seek_file; +export using ::avformat_send_command; +export using ::avformat_stream_group_add_stream; +export using ::avformat_stream_group_create; +export using ::avformat_stream_group_name; +export using ::avformat_transfer_internal_stream_timing_info; +export using ::avformat_version; +export using ::avformat_write_header; +export using ::avio_accept; +export using ::avio_alloc_context; +export using ::avio_check; +export using ::avio_close; +export using ::avio_close_dir; +export using ::avio_close_dyn_buf; +export using ::avio_closep; +export using ::avio_context_free; +export using ::avio_enum_protocols; +export using ::avio_feof; +export using ::avio_find_protocol_name; +export using ::avio_flush; +export using ::avio_free_directory_entry; +export using ::avio_get_dyn_buf; +export using ::avio_get_str; +export using ::avio_get_str16be; +export using ::avio_get_str16le; +export using ::avio_handshake; +export using ::avio_open; +export using ::avio_open2; +export using ::avio_open_dir; +export using ::avio_open_dyn_buf; +export using ::avio_pause; +export using ::avio_print_string_array; +export using ::avio_printf; +export using ::avio_protocol_get_class; +export using ::avio_put_str; +export using ::avio_put_str16be; +export using ::avio_put_str16le; +export using ::avio_r8; +export using ::avio_rb16; +export using ::avio_rb24; +export using ::avio_rb32; +export using ::avio_rb64; +export using ::avio_read; +export using ::avio_read_dir; +export using ::avio_read_partial; +export using ::avio_read_to_bprint; +export using ::avio_rl16; +export using ::avio_rl24; +export using ::avio_rl32; +export using ::avio_rl64; +export using ::avio_seek; +export using ::avio_seek_time; +export using ::avio_skip; +export using ::avio_vprintf; +export using ::avio_w8; +export using ::avio_wb16; +export using ::avio_wb24; +export using ::avio_wb32; +export using ::avio_wb64; +export using ::avio_wl16; +export using ::avio_wl24; +export using ::avio_wl32; +export using ::avio_wl64; +export using ::avio_write; +export using ::avio_write_marker; diff --git a/src/gen_exports/avformat.includes.inc b/src/gen_exports/avformat.includes.inc new file mode 100644 index 0000000..a5b3e75 --- /dev/null +++ b/src/gen_exports/avformat.includes.inc @@ -0,0 +1,6 @@ +// Auto-generated by tools/gen_exports.py — installed public headers of libavformat. + +#include +#include +#include +#include diff --git a/src/gen_exports/avformat.skipped.txt b/src/gen_exports/avformat.skipped.txt new file mode 100644 index 0000000..f5d1241 --- /dev/null +++ b/src/gen_exports/avformat.skipped.txt @@ -0,0 +1,106 @@ +avformat.h: macro AVFMTCTX_NOHEADER +avformat.h: macro AVFMTCTX_UNSEEKABLE +avformat.h: macro AVFMT_AVOID_NEG_TS_AUTO +avformat.h: macro AVFMT_AVOID_NEG_TS_DISABLED +avformat.h: macro AVFMT_AVOID_NEG_TS_MAKE_NON_NEGATIVE +avformat.h: macro AVFMT_AVOID_NEG_TS_MAKE_ZERO +avformat.h: macro AVFMT_EVENT_FLAG_METADATA_UPDATED +avformat.h: macro AVFMT_EXPERIMENTAL +avformat.h: macro AVFMT_FLAG_AUTO_BSF +avformat.h: macro AVFMT_FLAG_BITEXACT +avformat.h: macro AVFMT_FLAG_CUSTOM_IO +avformat.h: macro AVFMT_FLAG_DISCARD_CORRUPT +avformat.h: macro AVFMT_FLAG_FAST_SEEK +avformat.h: macro AVFMT_FLAG_FLUSH_PACKETS +avformat.h: macro AVFMT_FLAG_GENPTS +avformat.h: macro AVFMT_FLAG_IGNDTS +avformat.h: macro AVFMT_FLAG_IGNIDX +avformat.h: macro AVFMT_FLAG_NOBUFFER +avformat.h: macro AVFMT_FLAG_NOFILLIN +avformat.h: macro AVFMT_FLAG_NONBLOCK +avformat.h: macro AVFMT_FLAG_NOPARSE +avformat.h: macro AVFMT_FLAG_SORT_DTS +avformat.h: macro AVFMT_GENERIC_INDEX +avformat.h: macro AVFMT_GLOBALHEADER +avformat.h: macro AVFMT_NEEDNUMBER +avformat.h: macro AVFMT_NOBINSEARCH +avformat.h: macro AVFMT_NODIMENSIONS +avformat.h: macro AVFMT_NOFILE +avformat.h: macro AVFMT_NOGENSEARCH +avformat.h: macro AVFMT_NOSTREAMS +avformat.h: macro AVFMT_NOTIMESTAMPS +avformat.h: macro AVFMT_NO_BYTE_SEEK +avformat.h: macro AVFMT_SEEK_TO_PTS +avformat.h: macro AVFMT_SHOW_IDS +avformat.h: macro AVFMT_TS_DISCONT +avformat.h: macro AVFMT_TS_NEGATIVE +avformat.h: macro AVFMT_TS_NONSTRICT +avformat.h: macro AVFMT_VARIABLE_FPS +avformat.h: macro AVFORMAT_AVFORMAT_H +avformat.h: macro AVINDEX_DISCARD_FRAME +avformat.h: macro AVINDEX_KEYFRAME +avformat.h: macro AVPROBE_PADDING_SIZE +avformat.h: macro AVPROBE_SCORE_EXTENSION +avformat.h: macro AVPROBE_SCORE_MAX +avformat.h: macro AVPROBE_SCORE_MIME_BONUS +avformat.h: macro AVPROBE_SCORE_RETRY +avformat.h: macro AVPROBE_SCORE_STREAM_RETRY +avformat.h: macro AVSEEK_FLAG_ANY +avformat.h: macro AVSEEK_FLAG_BACKWARD +avformat.h: macro AVSEEK_FLAG_BYTE +avformat.h: macro AVSEEK_FLAG_FRAME +avformat.h: macro AVSTREAM_EVENT_FLAG_METADATA_UPDATED +avformat.h: macro AVSTREAM_EVENT_FLAG_NEW_PACKETS +avformat.h: macro AVSTREAM_INIT_IN_INIT_OUTPUT +avformat.h: macro AVSTREAM_INIT_IN_WRITE_HEADER +avformat.h: macro AV_DISPOSITION_ATTACHED_PIC +avformat.h: macro AV_DISPOSITION_CAPTIONS +avformat.h: macro AV_DISPOSITION_CLEAN_EFFECTS +avformat.h: macro AV_DISPOSITION_COMMENT +avformat.h: macro AV_DISPOSITION_DEFAULT +avformat.h: macro AV_DISPOSITION_DEPENDENT +avformat.h: macro AV_DISPOSITION_DESCRIPTIONS +avformat.h: macro AV_DISPOSITION_DUB +avformat.h: macro AV_DISPOSITION_FORCED +avformat.h: macro AV_DISPOSITION_HEARING_IMPAIRED +avformat.h: macro AV_DISPOSITION_KARAOKE +avformat.h: macro AV_DISPOSITION_LYRICS +avformat.h: macro AV_DISPOSITION_METADATA +avformat.h: macro AV_DISPOSITION_MULTILAYER +avformat.h: macro AV_DISPOSITION_NON_DIEGETIC +avformat.h: macro AV_DISPOSITION_ORIGINAL +avformat.h: macro AV_DISPOSITION_STILL_IMAGE +avformat.h: macro AV_DISPOSITION_TIMED_THUMBNAILS +avformat.h: macro AV_DISPOSITION_VISUAL_IMPAIRED +avformat.h: macro AV_FRAME_FILENAME_FLAGS_IGNORE_TRUNCATION +avformat.h: macro AV_FRAME_FILENAME_FLAGS_MULTIPLE +avformat.h: macro AV_PROGRAM_RUNNING +avformat.h: macro AV_PTS_WRAP_ADD_OFFSET +avformat.h: macro AV_PTS_WRAP_IGNORE +avformat.h: macro AV_PTS_WRAP_SUB_OFFSET +avformat.h: macro FF_FDEBUG_TS +avio.h: macro AVFORMAT_AVIO_H +avio.h: macro AVIO_FLAG_DIRECT +avio.h: macro AVIO_FLAG_NONBLOCK +avio.h: macro AVIO_FLAG_READ +avio.h: macro AVIO_FLAG_READ_WRITE +avio.h: macro AVIO_FLAG_WRITE +avio.h: macro AVIO_SEEKABLE_NORMAL +avio.h: macro AVIO_SEEKABLE_TIME +avio.h: macro AVSEEK_FORCE +avio.h: macro AVSEEK_SIZE +avio.h: macro avio_print +avio.h: static-inline avio_tell +version.h: macro AVFORMAT_VERSION_H +version.h: macro LIBAVFORMAT_BUILD +version.h: macro LIBAVFORMAT_IDENT +version.h: macro LIBAVFORMAT_VERSION +version.h: macro LIBAVFORMAT_VERSION_INT +version.h: macro LIBAVFORMAT_VERSION_MICRO +version.h: macro LIBAVFORMAT_VERSION_MINOR +version_major.h: macro AVFORMAT_VERSION_MAJOR_H +version_major.h: macro FF_API_COMPUTE_PKT_FIELDS2 +version_major.h: macro FF_API_INTERNAL_TIMING +version_major.h: macro FF_API_NO_DEFAULT_TLS_VERIFY +version_major.h: macro FF_API_R_FRAME_RATE +version_major.h: macro LIBAVFORMAT_VERSION_MAJOR diff --git a/src/gen_exports/avutil.inc b/src/gen_exports/avutil.inc new file mode 100644 index 0000000..62a1a8a --- /dev/null +++ b/src/gen_exports/avutil.inc @@ -0,0 +1,1403 @@ +// Auto-generated by tools/gen_exports.py from libavutil +// public headers (85 files) — do not edit by hand. + +// structs (120) +export using ::AV3DReferenceDisplay; +export using ::AV3DReferenceDisplaysInfo; +export using ::AVAES; +export using ::AVAESCTR; +export using ::AVAmbientViewingEnvironment; +export using ::AVAudioFifo; +export using ::AVBPrint; +export using ::AVBlowfish; +export using ::AVBuffer; +export using ::AVBufferPool; +export using ::AVBufferRef; +export using ::AVCAMELLIA; +export using ::AVCAST5; +export using ::AVCIExy; +export using ::AVChannelCustom; +export using ::AVChannelLayout; +export using ::AVClass; +export using ::AVColorPrimariesDesc; +export using ::AVComplexDouble; +export using ::AVComplexFloat; +export using ::AVComplexInt32; +export using ::AVComponentDescriptor; +export using ::AVContainerFifo; +export using ::AVContentLightMetadata; +export using ::AVDES; +export using ::AVDOVIColorMetadata; +export using ::AVDOVIDataMapping; +export using ::AVDOVIDecoderConfigurationRecord; +export using ::AVDOVIDmData; +export using ::AVDOVIDmLevel1; +export using ::AVDOVIDmLevel10; +export using ::AVDOVIDmLevel11; +export using ::AVDOVIDmLevel2; +export using ::AVDOVIDmLevel254; +export using ::AVDOVIDmLevel255; +export using ::AVDOVIDmLevel3; +export using ::AVDOVIDmLevel4; +export using ::AVDOVIDmLevel5; +export using ::AVDOVIDmLevel6; +export using ::AVDOVIDmLevel8; +export using ::AVDOVIDmLevel9; +export using ::AVDOVIMetadata; +export using ::AVDOVINLQParams; +export using ::AVDOVIReshapingCurve; +export using ::AVDOVIRpuDataHeader; +export using ::AVDetectionBBox; +export using ::AVDetectionBBoxHeader; +export using ::AVDictionary; +export using ::AVDictionaryEntry; +export using ::AVDownmixInfo; +export using ::AVDynamicHDRPlus; +export using ::AVDynamicHDRVivid; +export using ::AVEncryptionInfo; +export using ::AVEncryptionInitInfo; +export using ::AVExecutor; +export using ::AVExpr; +export using ::AVFifo; +export using ::AVFilmGrainAOMParams; +export using ::AVFilmGrainH274Params; +export using ::AVFilmGrainParams; +export using ::AVFrame; +export using ::AVFrameSideData; +export using ::AVHDRPlusColorTransformParams; +export using ::AVHDRPlusPercentile; +export using ::AVHDRVivid3SplineParams; +export using ::AVHDRVividColorToneMappingParams; +export using ::AVHDRVividColorTransformParams; +export using ::AVHMAC; +export using ::AVHWDeviceContext; +export using ::AVHWFramesConstraints; +export using ::AVHWFramesContext; +export using ::AVHashContext; +export using ::AVIAMFAudioElement; +export using ::AVIAMFDemixingInfo; +export using ::AVIAMFLayer; +export using ::AVIAMFMixGain; +export using ::AVIAMFMixPresentation; +export using ::AVIAMFParamDefinition; +export using ::AVIAMFReconGain; +export using ::AVIAMFSubmix; +export using ::AVIAMFSubmixElement; +export using ::AVIAMFSubmixLayout; +export using ::AVLFG; +export using ::AVLumaCoefficients; +export using ::AVMD5; +export using ::AVMasteringDisplayMetadata; +export using ::AVMotionVector; +export using ::AVMurMur3; +export using ::AVOption; +export using ::AVOptionArrayDef; +export using ::AVOptionRange; +export using ::AVOptionRanges; +export using ::AVPixFmtDescriptor; +export using ::AVPrimaryCoefficients; +export using ::AVRC4; +export using ::AVRIPEMD; +export using ::AVRational; +export using ::AVRefStructPool; +export using ::AVRegionOfInterest; +export using ::AVReplayGain; +export using ::AVSHA; +export using ::AVSHA512; +export using ::AVSideDataDescriptor; +export using ::AVSphericalMapping; +export using ::AVStereo3D; +export using ::AVSubsampleEncryptionInfo; +export using ::AVTEA; +export using ::AVTWOFISH; +export using ::AVTXContext; +export using ::AVTask; +export using ::AVTaskCallbacks; +export using ::AVThreadMessageQueue; +export using ::AVTreeNode; +export using ::AVVideoBlockParams; +export using ::AVVideoEncParams; +export using ::AVVideoHint; +export using ::AVVideoRect; +export using ::AVXTEA; +export using ::av_intfloat32; +export using ::av_intfloat64; + +// typedefs (13) +export using ::AVAdler; +export using ::AVCRC; +export using ::AVRefStructOpaque; +export using ::AVTimecode; +export using ::AVUUID; +export using ::AVWhitepointCoefficients; +export using ::av_alias16; +export using ::av_alias32; +export using ::av_alias64; +export using ::av_csp_eotf_function; +export using ::av_csp_trc_function; +export using ::av_pixelutils_sad_fn; +export using ::av_tx_fn; + +// enums (47) +export using ::AVActiveFormatDescription; +export using ::AVAlphaMode; +export using ::AVCRCId; +export using ::AVChannel; +export using ::AVChannelOrder; +export using ::AVChromaLocation; +export using ::AVClassCategory; +export using ::AVClassStateFlags; +export using ::AVColorPrimaries; +export using ::AVColorRange; +export using ::AVColorSpace; +export using ::AVColorTransferCharacteristic; +export using ::AVContainerFifoFlags; +export using ::AVDOVICompression; +export using ::AVDOVIMappingMethod; +export using ::AVDOVINLQMethod; +export using ::AVDownmixType; +export using ::AVEscapeMode; +export using ::AVFilmGrainParamsType; +export using ::AVFrameSideDataType; +export using ::AVHDRPlusOverlapProcessOption; +export using ::AVHMACType; +export using ::AVHWDeviceType; +export using ::AVHWFrameTransferDirection; +export using ::AVIAMFAnimationType; +export using ::AVIAMFAudioElementType; +export using ::AVIAMFHeadphonesMode; +export using ::AVIAMFParamDefinitionType; +export using ::AVIAMFSubmixLayoutType; +export using ::AVMatrixEncoding; +export using ::AVMediaType; +export using ::AVOptionType; +export using ::AVPictureType; +export using ::AVPixelFormat; +export using ::AVRounding; +export using ::AVSampleFormat; +export using ::AVSideDataProps; +export using ::AVSphericalProjection; +export using ::AVStereo3DPrimaryEye; +export using ::AVStereo3DType; +export using ::AVStereo3DView; +export using ::AVTXFlags; +export using ::AVTXType; +export using ::AVThreadMessageFlags; +export using ::AVTimecodeFlag; +export using ::AVVideoEncParamsType; +export using ::AVVideoHintType; + +// enumerators (658) +export using ::AVALPHA_MODE_NB; +export using ::AVALPHA_MODE_PREMULTIPLIED; +export using ::AVALPHA_MODE_STRAIGHT; +export using ::AVALPHA_MODE_UNSPECIFIED; +export using ::AVCHROMA_LOC_BOTTOM; +export using ::AVCHROMA_LOC_BOTTOMLEFT; +export using ::AVCHROMA_LOC_CENTER; +export using ::AVCHROMA_LOC_LEFT; +export using ::AVCHROMA_LOC_NB; +export using ::AVCHROMA_LOC_TOP; +export using ::AVCHROMA_LOC_TOPLEFT; +export using ::AVCHROMA_LOC_UNSPECIFIED; +export using ::AVCOL_PRI_BT2020; +export using ::AVCOL_PRI_BT470BG; +export using ::AVCOL_PRI_BT470M; +export using ::AVCOL_PRI_BT709; +export using ::AVCOL_PRI_EBU3213; +export using ::AVCOL_PRI_EXT_BASE; +export using ::AVCOL_PRI_EXT_NB; +export using ::AVCOL_PRI_FILM; +export using ::AVCOL_PRI_JEDEC_P22; +export using ::AVCOL_PRI_NB; +export using ::AVCOL_PRI_RESERVED; +export using ::AVCOL_PRI_RESERVED0; +export using ::AVCOL_PRI_SMPTE170M; +export using ::AVCOL_PRI_SMPTE240M; +export using ::AVCOL_PRI_SMPTE428; +export using ::AVCOL_PRI_SMPTE431; +export using ::AVCOL_PRI_SMPTE432; +export using ::AVCOL_PRI_SMPTEST428_1; +export using ::AVCOL_PRI_UNSPECIFIED; +export using ::AVCOL_PRI_V_GAMUT; +export using ::AVCOL_RANGE_JPEG; +export using ::AVCOL_RANGE_MPEG; +export using ::AVCOL_RANGE_NB; +export using ::AVCOL_RANGE_UNSPECIFIED; +export using ::AVCOL_SPC_BT2020_CL; +export using ::AVCOL_SPC_BT2020_NCL; +export using ::AVCOL_SPC_BT470BG; +export using ::AVCOL_SPC_BT709; +export using ::AVCOL_SPC_CHROMA_DERIVED_CL; +export using ::AVCOL_SPC_CHROMA_DERIVED_NCL; +export using ::AVCOL_SPC_FCC; +export using ::AVCOL_SPC_ICTCP; +export using ::AVCOL_SPC_IPT_C2; +export using ::AVCOL_SPC_NB; +export using ::AVCOL_SPC_RESERVED; +export using ::AVCOL_SPC_RGB; +export using ::AVCOL_SPC_SMPTE170M; +export using ::AVCOL_SPC_SMPTE2085; +export using ::AVCOL_SPC_SMPTE240M; +export using ::AVCOL_SPC_UNSPECIFIED; +export using ::AVCOL_SPC_YCGCO; +export using ::AVCOL_SPC_YCGCO_RE; +export using ::AVCOL_SPC_YCGCO_RO; +export using ::AVCOL_SPC_YCOCG; +export using ::AVCOL_TRC_ARIB_STD_B67; +export using ::AVCOL_TRC_BT1361_ECG; +export using ::AVCOL_TRC_BT2020_10; +export using ::AVCOL_TRC_BT2020_12; +export using ::AVCOL_TRC_BT709; +export using ::AVCOL_TRC_EXT_BASE; +export using ::AVCOL_TRC_EXT_NB; +export using ::AVCOL_TRC_GAMMA22; +export using ::AVCOL_TRC_GAMMA28; +export using ::AVCOL_TRC_IEC61966_2_1; +export using ::AVCOL_TRC_IEC61966_2_4; +export using ::AVCOL_TRC_LINEAR; +export using ::AVCOL_TRC_LOG; +export using ::AVCOL_TRC_LOG_SQRT; +export using ::AVCOL_TRC_NB; +export using ::AVCOL_TRC_RESERVED; +export using ::AVCOL_TRC_RESERVED0; +export using ::AVCOL_TRC_SMPTE170M; +export using ::AVCOL_TRC_SMPTE2084; +export using ::AVCOL_TRC_SMPTE240M; +export using ::AVCOL_TRC_SMPTE428; +export using ::AVCOL_TRC_SMPTEST2084; +export using ::AVCOL_TRC_SMPTEST428_1; +export using ::AVCOL_TRC_UNSPECIFIED; +export using ::AVCOL_TRC_V_LOG; +export using ::AVMEDIA_TYPE_ATTACHMENT; +export using ::AVMEDIA_TYPE_AUDIO; +export using ::AVMEDIA_TYPE_DATA; +export using ::AVMEDIA_TYPE_NB; +export using ::AVMEDIA_TYPE_SUBTITLE; +export using ::AVMEDIA_TYPE_UNKNOWN; +export using ::AVMEDIA_TYPE_VIDEO; +export using ::AV_AFD_14_9; +export using ::AV_AFD_16_9; +export using ::AV_AFD_16_9_SP_14_9; +export using ::AV_AFD_4_3; +export using ::AV_AFD_4_3_SP_14_9; +export using ::AV_AFD_SAME; +export using ::AV_AFD_SP_4_3; +export using ::AV_CHANNEL_ORDER_AMBISONIC; +export using ::AV_CHANNEL_ORDER_CUSTOM; +export using ::AV_CHANNEL_ORDER_NATIVE; +export using ::AV_CHANNEL_ORDER_UNSPEC; +export using ::AV_CHAN_AMBISONIC_BASE; +export using ::AV_CHAN_AMBISONIC_END; +export using ::AV_CHAN_BACK_CENTER; +export using ::AV_CHAN_BACK_LEFT; +export using ::AV_CHAN_BACK_RIGHT; +export using ::AV_CHAN_BINAURAL_LEFT; +export using ::AV_CHAN_BINAURAL_RIGHT; +export using ::AV_CHAN_BOTTOM_FRONT_CENTER; +export using ::AV_CHAN_BOTTOM_FRONT_LEFT; +export using ::AV_CHAN_BOTTOM_FRONT_RIGHT; +export using ::AV_CHAN_FRONT_CENTER; +export using ::AV_CHAN_FRONT_LEFT; +export using ::AV_CHAN_FRONT_LEFT_OF_CENTER; +export using ::AV_CHAN_FRONT_RIGHT; +export using ::AV_CHAN_FRONT_RIGHT_OF_CENTER; +export using ::AV_CHAN_LOW_FREQUENCY; +export using ::AV_CHAN_LOW_FREQUENCY_2; +export using ::AV_CHAN_NONE; +export using ::AV_CHAN_SIDE_LEFT; +export using ::AV_CHAN_SIDE_RIGHT; +export using ::AV_CHAN_SIDE_SURROUND_LEFT; +export using ::AV_CHAN_SIDE_SURROUND_RIGHT; +export using ::AV_CHAN_STEREO_LEFT; +export using ::AV_CHAN_STEREO_RIGHT; +export using ::AV_CHAN_SURROUND_DIRECT_LEFT; +export using ::AV_CHAN_SURROUND_DIRECT_RIGHT; +export using ::AV_CHAN_TOP_BACK_CENTER; +export using ::AV_CHAN_TOP_BACK_LEFT; +export using ::AV_CHAN_TOP_BACK_RIGHT; +export using ::AV_CHAN_TOP_CENTER; +export using ::AV_CHAN_TOP_FRONT_CENTER; +export using ::AV_CHAN_TOP_FRONT_LEFT; +export using ::AV_CHAN_TOP_FRONT_RIGHT; +export using ::AV_CHAN_TOP_SIDE_LEFT; +export using ::AV_CHAN_TOP_SIDE_RIGHT; +export using ::AV_CHAN_TOP_SURROUND_LEFT; +export using ::AV_CHAN_TOP_SURROUND_RIGHT; +export using ::AV_CHAN_UNKNOWN; +export using ::AV_CHAN_UNUSED; +export using ::AV_CHAN_WIDE_LEFT; +export using ::AV_CHAN_WIDE_RIGHT; +export using ::AV_CLASS_CATEGORY_BITSTREAM_FILTER; +export using ::AV_CLASS_CATEGORY_DECODER; +export using ::AV_CLASS_CATEGORY_DEMUXER; +export using ::AV_CLASS_CATEGORY_DEVICE_AUDIO_INPUT; +export using ::AV_CLASS_CATEGORY_DEVICE_AUDIO_OUTPUT; +export using ::AV_CLASS_CATEGORY_DEVICE_INPUT; +export using ::AV_CLASS_CATEGORY_DEVICE_OUTPUT; +export using ::AV_CLASS_CATEGORY_DEVICE_VIDEO_INPUT; +export using ::AV_CLASS_CATEGORY_DEVICE_VIDEO_OUTPUT; +export using ::AV_CLASS_CATEGORY_ENCODER; +export using ::AV_CLASS_CATEGORY_FILTER; +export using ::AV_CLASS_CATEGORY_HWDEVICE; +export using ::AV_CLASS_CATEGORY_INPUT; +export using ::AV_CLASS_CATEGORY_MUXER; +export using ::AV_CLASS_CATEGORY_NA; +export using ::AV_CLASS_CATEGORY_NB; +export using ::AV_CLASS_CATEGORY_OUTPUT; +export using ::AV_CLASS_CATEGORY_SWRESAMPLER; +export using ::AV_CLASS_CATEGORY_SWSCALER; +export using ::AV_CLASS_STATE_INITIALIZED; +export using ::AV_CONTAINER_FIFO_FLAG_REF; +export using ::AV_CONTAINER_FIFO_FLAG_USER; +export using ::AV_CRC_16_ANSI; +export using ::AV_CRC_16_ANSI_LE; +export using ::AV_CRC_16_CCITT; +export using ::AV_CRC_24_IEEE; +export using ::AV_CRC_32_IEEE; +export using ::AV_CRC_32_IEEE_LE; +export using ::AV_CRC_8_ATM; +export using ::AV_CRC_8_EBU; +export using ::AV_CRC_MAX; +export using ::AV_DOVI_COMPRESSION_EXTENDED; +export using ::AV_DOVI_COMPRESSION_LIMITED; +export using ::AV_DOVI_COMPRESSION_NONE; +export using ::AV_DOVI_COMPRESSION_RESERVED; +export using ::AV_DOVI_MAPPING_MMR; +export using ::AV_DOVI_MAPPING_POLYNOMIAL; +export using ::AV_DOVI_NLQ_LINEAR_DZ; +export using ::AV_DOVI_NLQ_NONE; +export using ::AV_DOWNMIX_TYPE_DPLII; +export using ::AV_DOWNMIX_TYPE_LORO; +export using ::AV_DOWNMIX_TYPE_LTRT; +export using ::AV_DOWNMIX_TYPE_NB; +export using ::AV_DOWNMIX_TYPE_UNKNOWN; +export using ::AV_ESCAPE_MODE_AUTO; +export using ::AV_ESCAPE_MODE_BACKSLASH; +export using ::AV_ESCAPE_MODE_QUOTE; +export using ::AV_ESCAPE_MODE_XML; +export using ::AV_FILM_GRAIN_PARAMS_AV1; +export using ::AV_FILM_GRAIN_PARAMS_H274; +export using ::AV_FILM_GRAIN_PARAMS_NONE; +export using ::AV_FRAME_CROP_UNALIGNED; +export using ::AV_FRAME_DATA_3D_REFERENCE_DISPLAYS; +export using ::AV_FRAME_DATA_A53_CC; +export using ::AV_FRAME_DATA_AFD; +export using ::AV_FRAME_DATA_AMBIENT_VIEWING_ENVIRONMENT; +export using ::AV_FRAME_DATA_AUDIO_SERVICE_TYPE; +export using ::AV_FRAME_DATA_CONTENT_LIGHT_LEVEL; +export using ::AV_FRAME_DATA_DETECTION_BBOXES; +export using ::AV_FRAME_DATA_DISPLAYMATRIX; +export using ::AV_FRAME_DATA_DOVI_METADATA; +export using ::AV_FRAME_DATA_DOVI_RPU_BUFFER; +export using ::AV_FRAME_DATA_DOWNMIX_INFO; +export using ::AV_FRAME_DATA_DYNAMIC_HDR_PLUS; +export using ::AV_FRAME_DATA_DYNAMIC_HDR_VIVID; +export using ::AV_FRAME_DATA_EXIF; +export using ::AV_FRAME_DATA_FILM_GRAIN_PARAMS; +export using ::AV_FRAME_DATA_GOP_TIMECODE; +export using ::AV_FRAME_DATA_ICC_PROFILE; +export using ::AV_FRAME_DATA_LCEVC; +export using ::AV_FRAME_DATA_MASTERING_DISPLAY_METADATA; +export using ::AV_FRAME_DATA_MATRIXENCODING; +export using ::AV_FRAME_DATA_MOTION_VECTORS; +export using ::AV_FRAME_DATA_PANSCAN; +export using ::AV_FRAME_DATA_REGIONS_OF_INTEREST; +export using ::AV_FRAME_DATA_REPLAYGAIN; +export using ::AV_FRAME_DATA_S12M_TIMECODE; +export using ::AV_FRAME_DATA_SEI_UNREGISTERED; +export using ::AV_FRAME_DATA_SKIP_SAMPLES; +export using ::AV_FRAME_DATA_SPHERICAL; +export using ::AV_FRAME_DATA_STEREO3D; +export using ::AV_FRAME_DATA_VIDEO_ENC_PARAMS; +export using ::AV_FRAME_DATA_VIDEO_HINT; +export using ::AV_FRAME_DATA_VIEW_ID; +export using ::AV_HDR_PLUS_OVERLAP_PROCESS_LAYERING; +export using ::AV_HDR_PLUS_OVERLAP_PROCESS_WEIGHTED_AVERAGING; +export using ::AV_HMAC_MD5; +export using ::AV_HMAC_SHA1; +export using ::AV_HMAC_SHA224; +export using ::AV_HMAC_SHA256; +export using ::AV_HMAC_SHA384; +export using ::AV_HMAC_SHA512; +export using ::AV_HWDEVICE_TYPE_AMF; +export using ::AV_HWDEVICE_TYPE_CUDA; +export using ::AV_HWDEVICE_TYPE_D3D11VA; +export using ::AV_HWDEVICE_TYPE_D3D12VA; +export using ::AV_HWDEVICE_TYPE_DRM; +export using ::AV_HWDEVICE_TYPE_DXVA2; +export using ::AV_HWDEVICE_TYPE_MEDIACODEC; +export using ::AV_HWDEVICE_TYPE_NONE; +export using ::AV_HWDEVICE_TYPE_OHCODEC; +export using ::AV_HWDEVICE_TYPE_OPENCL; +export using ::AV_HWDEVICE_TYPE_QSV; +export using ::AV_HWDEVICE_TYPE_VAAPI; +export using ::AV_HWDEVICE_TYPE_VDPAU; +export using ::AV_HWDEVICE_TYPE_VIDEOTOOLBOX; +export using ::AV_HWDEVICE_TYPE_VULKAN; +export using ::AV_HWFRAME_MAP_DIRECT; +export using ::AV_HWFRAME_MAP_OVERWRITE; +export using ::AV_HWFRAME_MAP_READ; +export using ::AV_HWFRAME_MAP_WRITE; +export using ::AV_HWFRAME_TRANSFER_DIRECTION_FROM; +export using ::AV_HWFRAME_TRANSFER_DIRECTION_TO; +export using ::AV_IAMF_ANIMATION_TYPE_BEZIER; +export using ::AV_IAMF_ANIMATION_TYPE_LINEAR; +export using ::AV_IAMF_ANIMATION_TYPE_STEP; +export using ::AV_IAMF_AUDIO_ELEMENT_TYPE_CHANNEL; +export using ::AV_IAMF_AUDIO_ELEMENT_TYPE_SCENE; +export using ::AV_IAMF_HEADPHONES_MODE_BINAURAL; +export using ::AV_IAMF_HEADPHONES_MODE_STEREO; +export using ::AV_IAMF_PARAMETER_DEFINITION_DEMIXING; +export using ::AV_IAMF_PARAMETER_DEFINITION_MIX_GAIN; +export using ::AV_IAMF_PARAMETER_DEFINITION_RECON_GAIN; +export using ::AV_IAMF_SUBMIX_LAYOUT_TYPE_BINAURAL; +export using ::AV_IAMF_SUBMIX_LAYOUT_TYPE_LOUDSPEAKERS; +export using ::AV_MATRIX_ENCODING_DOLBY; +export using ::AV_MATRIX_ENCODING_DOLBYEX; +export using ::AV_MATRIX_ENCODING_DOLBYHEADPHONE; +export using ::AV_MATRIX_ENCODING_DPLII; +export using ::AV_MATRIX_ENCODING_DPLIIX; +export using ::AV_MATRIX_ENCODING_DPLIIZ; +export using ::AV_MATRIX_ENCODING_NB; +export using ::AV_MATRIX_ENCODING_NONE; +export using ::AV_OPT_FLAG_IMPLICIT_KEY; +export using ::AV_OPT_TYPE_BINARY; +export using ::AV_OPT_TYPE_BOOL; +export using ::AV_OPT_TYPE_CHLAYOUT; +export using ::AV_OPT_TYPE_COLOR; +export using ::AV_OPT_TYPE_CONST; +export using ::AV_OPT_TYPE_DICT; +export using ::AV_OPT_TYPE_DOUBLE; +export using ::AV_OPT_TYPE_DURATION; +export using ::AV_OPT_TYPE_FLAGS; +export using ::AV_OPT_TYPE_FLAG_ARRAY; +export using ::AV_OPT_TYPE_FLOAT; +export using ::AV_OPT_TYPE_IMAGE_SIZE; +export using ::AV_OPT_TYPE_INT; +export using ::AV_OPT_TYPE_INT64; +export using ::AV_OPT_TYPE_PIXEL_FMT; +export using ::AV_OPT_TYPE_RATIONAL; +export using ::AV_OPT_TYPE_SAMPLE_FMT; +export using ::AV_OPT_TYPE_STRING; +export using ::AV_OPT_TYPE_UINT; +export using ::AV_OPT_TYPE_UINT64; +export using ::AV_OPT_TYPE_VIDEO_RATE; +export using ::AV_PICTURE_TYPE_B; +export using ::AV_PICTURE_TYPE_BI; +export using ::AV_PICTURE_TYPE_I; +export using ::AV_PICTURE_TYPE_NONE; +export using ::AV_PICTURE_TYPE_P; +export using ::AV_PICTURE_TYPE_S; +export using ::AV_PICTURE_TYPE_SI; +export using ::AV_PICTURE_TYPE_SP; +export using ::AV_PIX_FMT_0BGR; +export using ::AV_PIX_FMT_0RGB; +export using ::AV_PIX_FMT_ABGR; +export using ::AV_PIX_FMT_AMF_SURFACE; +export using ::AV_PIX_FMT_ARGB; +export using ::AV_PIX_FMT_AYUV; +export using ::AV_PIX_FMT_AYUV64BE; +export using ::AV_PIX_FMT_AYUV64LE; +export using ::AV_PIX_FMT_BAYER_BGGR16BE; +export using ::AV_PIX_FMT_BAYER_BGGR16LE; +export using ::AV_PIX_FMT_BAYER_BGGR8; +export using ::AV_PIX_FMT_BAYER_GBRG16BE; +export using ::AV_PIX_FMT_BAYER_GBRG16LE; +export using ::AV_PIX_FMT_BAYER_GBRG8; +export using ::AV_PIX_FMT_BAYER_GRBG16BE; +export using ::AV_PIX_FMT_BAYER_GRBG16LE; +export using ::AV_PIX_FMT_BAYER_GRBG8; +export using ::AV_PIX_FMT_BAYER_RGGB16BE; +export using ::AV_PIX_FMT_BAYER_RGGB16LE; +export using ::AV_PIX_FMT_BAYER_RGGB8; +export using ::AV_PIX_FMT_BGR0; +export using ::AV_PIX_FMT_BGR24; +export using ::AV_PIX_FMT_BGR4; +export using ::AV_PIX_FMT_BGR444BE; +export using ::AV_PIX_FMT_BGR444LE; +export using ::AV_PIX_FMT_BGR48BE; +export using ::AV_PIX_FMT_BGR48LE; +export using ::AV_PIX_FMT_BGR4_BYTE; +export using ::AV_PIX_FMT_BGR555BE; +export using ::AV_PIX_FMT_BGR555LE; +export using ::AV_PIX_FMT_BGR565BE; +export using ::AV_PIX_FMT_BGR565LE; +export using ::AV_PIX_FMT_BGR8; +export using ::AV_PIX_FMT_BGRA; +export using ::AV_PIX_FMT_BGRA64BE; +export using ::AV_PIX_FMT_BGRA64LE; +export using ::AV_PIX_FMT_CUDA; +export using ::AV_PIX_FMT_D3D11; +export using ::AV_PIX_FMT_D3D11VA_VLD; +export using ::AV_PIX_FMT_D3D12; +export using ::AV_PIX_FMT_DRM_PRIME; +export using ::AV_PIX_FMT_DXVA2_VLD; +export using ::AV_PIX_FMT_GBR24P; +export using ::AV_PIX_FMT_GBRAP; +export using ::AV_PIX_FMT_GBRAP10BE; +export using ::AV_PIX_FMT_GBRAP10LE; +export using ::AV_PIX_FMT_GBRAP12BE; +export using ::AV_PIX_FMT_GBRAP12LE; +export using ::AV_PIX_FMT_GBRAP14BE; +export using ::AV_PIX_FMT_GBRAP14LE; +export using ::AV_PIX_FMT_GBRAP16BE; +export using ::AV_PIX_FMT_GBRAP16LE; +export using ::AV_PIX_FMT_GBRAP32BE; +export using ::AV_PIX_FMT_GBRAP32LE; +export using ::AV_PIX_FMT_GBRAPF16BE; +export using ::AV_PIX_FMT_GBRAPF16LE; +export using ::AV_PIX_FMT_GBRAPF32BE; +export using ::AV_PIX_FMT_GBRAPF32LE; +export using ::AV_PIX_FMT_GBRP; +export using ::AV_PIX_FMT_GBRP10BE; +export using ::AV_PIX_FMT_GBRP10LE; +export using ::AV_PIX_FMT_GBRP10MSBBE; +export using ::AV_PIX_FMT_GBRP10MSBLE; +export using ::AV_PIX_FMT_GBRP12BE; +export using ::AV_PIX_FMT_GBRP12LE; +export using ::AV_PIX_FMT_GBRP12MSBBE; +export using ::AV_PIX_FMT_GBRP12MSBLE; +export using ::AV_PIX_FMT_GBRP14BE; +export using ::AV_PIX_FMT_GBRP14LE; +export using ::AV_PIX_FMT_GBRP16BE; +export using ::AV_PIX_FMT_GBRP16LE; +export using ::AV_PIX_FMT_GBRP9BE; +export using ::AV_PIX_FMT_GBRP9LE; +export using ::AV_PIX_FMT_GBRPF16BE; +export using ::AV_PIX_FMT_GBRPF16LE; +export using ::AV_PIX_FMT_GBRPF32BE; +export using ::AV_PIX_FMT_GBRPF32LE; +export using ::AV_PIX_FMT_GRAY10BE; +export using ::AV_PIX_FMT_GRAY10LE; +export using ::AV_PIX_FMT_GRAY12BE; +export using ::AV_PIX_FMT_GRAY12LE; +export using ::AV_PIX_FMT_GRAY14BE; +export using ::AV_PIX_FMT_GRAY14LE; +export using ::AV_PIX_FMT_GRAY16BE; +export using ::AV_PIX_FMT_GRAY16LE; +export using ::AV_PIX_FMT_GRAY32BE; +export using ::AV_PIX_FMT_GRAY32LE; +export using ::AV_PIX_FMT_GRAY8; +export using ::AV_PIX_FMT_GRAY8A; +export using ::AV_PIX_FMT_GRAY9BE; +export using ::AV_PIX_FMT_GRAY9LE; +export using ::AV_PIX_FMT_GRAYF16BE; +export using ::AV_PIX_FMT_GRAYF16LE; +export using ::AV_PIX_FMT_GRAYF32BE; +export using ::AV_PIX_FMT_GRAYF32LE; +export using ::AV_PIX_FMT_MEDIACODEC; +export using ::AV_PIX_FMT_MMAL; +export using ::AV_PIX_FMT_MONOBLACK; +export using ::AV_PIX_FMT_MONOWHITE; +export using ::AV_PIX_FMT_NB; +export using ::AV_PIX_FMT_NONE; +export using ::AV_PIX_FMT_NV12; +export using ::AV_PIX_FMT_NV16; +export using ::AV_PIX_FMT_NV20BE; +export using ::AV_PIX_FMT_NV20LE; +export using ::AV_PIX_FMT_NV21; +export using ::AV_PIX_FMT_NV24; +export using ::AV_PIX_FMT_NV42; +export using ::AV_PIX_FMT_OHCODEC; +export using ::AV_PIX_FMT_OPENCL; +export using ::AV_PIX_FMT_P010BE; +export using ::AV_PIX_FMT_P010LE; +export using ::AV_PIX_FMT_P012BE; +export using ::AV_PIX_FMT_P012LE; +export using ::AV_PIX_FMT_P016BE; +export using ::AV_PIX_FMT_P016LE; +export using ::AV_PIX_FMT_P210BE; +export using ::AV_PIX_FMT_P210LE; +export using ::AV_PIX_FMT_P212BE; +export using ::AV_PIX_FMT_P212LE; +export using ::AV_PIX_FMT_P216BE; +export using ::AV_PIX_FMT_P216LE; +export using ::AV_PIX_FMT_P410BE; +export using ::AV_PIX_FMT_P410LE; +export using ::AV_PIX_FMT_P412BE; +export using ::AV_PIX_FMT_P412LE; +export using ::AV_PIX_FMT_P416BE; +export using ::AV_PIX_FMT_P416LE; +export using ::AV_PIX_FMT_PAL8; +export using ::AV_PIX_FMT_QSV; +export using ::AV_PIX_FMT_RGB0; +export using ::AV_PIX_FMT_RGB24; +export using ::AV_PIX_FMT_RGB4; +export using ::AV_PIX_FMT_RGB444BE; +export using ::AV_PIX_FMT_RGB444LE; +export using ::AV_PIX_FMT_RGB48BE; +export using ::AV_PIX_FMT_RGB48LE; +export using ::AV_PIX_FMT_RGB4_BYTE; +export using ::AV_PIX_FMT_RGB555BE; +export using ::AV_PIX_FMT_RGB555LE; +export using ::AV_PIX_FMT_RGB565BE; +export using ::AV_PIX_FMT_RGB565LE; +export using ::AV_PIX_FMT_RGB8; +export using ::AV_PIX_FMT_RGB96BE; +export using ::AV_PIX_FMT_RGB96LE; +export using ::AV_PIX_FMT_RGBA; +export using ::AV_PIX_FMT_RGBA128BE; +export using ::AV_PIX_FMT_RGBA128LE; +export using ::AV_PIX_FMT_RGBA64BE; +export using ::AV_PIX_FMT_RGBA64LE; +export using ::AV_PIX_FMT_RGBAF16BE; +export using ::AV_PIX_FMT_RGBAF16LE; +export using ::AV_PIX_FMT_RGBAF32BE; +export using ::AV_PIX_FMT_RGBAF32LE; +export using ::AV_PIX_FMT_RGBF16BE; +export using ::AV_PIX_FMT_RGBF16LE; +export using ::AV_PIX_FMT_RGBF32BE; +export using ::AV_PIX_FMT_RGBF32LE; +export using ::AV_PIX_FMT_UYVA; +export using ::AV_PIX_FMT_UYVY422; +export using ::AV_PIX_FMT_UYYVYY411; +export using ::AV_PIX_FMT_V30XBE; +export using ::AV_PIX_FMT_V30XLE; +export using ::AV_PIX_FMT_VAAPI; +export using ::AV_PIX_FMT_VDPAU; +export using ::AV_PIX_FMT_VIDEOTOOLBOX; +export using ::AV_PIX_FMT_VULKAN; +export using ::AV_PIX_FMT_VUYA; +export using ::AV_PIX_FMT_VUYX; +export using ::AV_PIX_FMT_VYU444; +export using ::AV_PIX_FMT_X2BGR10BE; +export using ::AV_PIX_FMT_X2BGR10LE; +export using ::AV_PIX_FMT_X2RGB10BE; +export using ::AV_PIX_FMT_X2RGB10LE; +export using ::AV_PIX_FMT_XV30BE; +export using ::AV_PIX_FMT_XV30LE; +export using ::AV_PIX_FMT_XV36BE; +export using ::AV_PIX_FMT_XV36LE; +export using ::AV_PIX_FMT_XV48BE; +export using ::AV_PIX_FMT_XV48LE; +export using ::AV_PIX_FMT_XYZ12BE; +export using ::AV_PIX_FMT_XYZ12LE; +export using ::AV_PIX_FMT_Y210BE; +export using ::AV_PIX_FMT_Y210LE; +export using ::AV_PIX_FMT_Y212BE; +export using ::AV_PIX_FMT_Y212LE; +export using ::AV_PIX_FMT_Y216BE; +export using ::AV_PIX_FMT_Y216LE; +export using ::AV_PIX_FMT_Y400A; +export using ::AV_PIX_FMT_YA16BE; +export using ::AV_PIX_FMT_YA16LE; +export using ::AV_PIX_FMT_YA8; +export using ::AV_PIX_FMT_YAF16BE; +export using ::AV_PIX_FMT_YAF16LE; +export using ::AV_PIX_FMT_YAF32BE; +export using ::AV_PIX_FMT_YAF32LE; +export using ::AV_PIX_FMT_YUV410P; +export using ::AV_PIX_FMT_YUV411P; +export using ::AV_PIX_FMT_YUV420P; +export using ::AV_PIX_FMT_YUV420P10BE; +export using ::AV_PIX_FMT_YUV420P10LE; +export using ::AV_PIX_FMT_YUV420P12BE; +export using ::AV_PIX_FMT_YUV420P12LE; +export using ::AV_PIX_FMT_YUV420P14BE; +export using ::AV_PIX_FMT_YUV420P14LE; +export using ::AV_PIX_FMT_YUV420P16BE; +export using ::AV_PIX_FMT_YUV420P16LE; +export using ::AV_PIX_FMT_YUV420P9BE; +export using ::AV_PIX_FMT_YUV420P9LE; +export using ::AV_PIX_FMT_YUV422P; +export using ::AV_PIX_FMT_YUV422P10BE; +export using ::AV_PIX_FMT_YUV422P10LE; +export using ::AV_PIX_FMT_YUV422P12BE; +export using ::AV_PIX_FMT_YUV422P12LE; +export using ::AV_PIX_FMT_YUV422P14BE; +export using ::AV_PIX_FMT_YUV422P14LE; +export using ::AV_PIX_FMT_YUV422P16BE; +export using ::AV_PIX_FMT_YUV422P16LE; +export using ::AV_PIX_FMT_YUV422P9BE; +export using ::AV_PIX_FMT_YUV422P9LE; +export using ::AV_PIX_FMT_YUV440P; +export using ::AV_PIX_FMT_YUV440P10BE; +export using ::AV_PIX_FMT_YUV440P10LE; +export using ::AV_PIX_FMT_YUV440P12BE; +export using ::AV_PIX_FMT_YUV440P12LE; +export using ::AV_PIX_FMT_YUV444P; +export using ::AV_PIX_FMT_YUV444P10BE; +export using ::AV_PIX_FMT_YUV444P10LE; +export using ::AV_PIX_FMT_YUV444P10MSBBE; +export using ::AV_PIX_FMT_YUV444P10MSBLE; +export using ::AV_PIX_FMT_YUV444P12BE; +export using ::AV_PIX_FMT_YUV444P12LE; +export using ::AV_PIX_FMT_YUV444P12MSBBE; +export using ::AV_PIX_FMT_YUV444P12MSBLE; +export using ::AV_PIX_FMT_YUV444P14BE; +export using ::AV_PIX_FMT_YUV444P14LE; +export using ::AV_PIX_FMT_YUV444P16BE; +export using ::AV_PIX_FMT_YUV444P16LE; +export using ::AV_PIX_FMT_YUV444P9BE; +export using ::AV_PIX_FMT_YUV444P9LE; +export using ::AV_PIX_FMT_YUVA420P; +export using ::AV_PIX_FMT_YUVA420P10BE; +export using ::AV_PIX_FMT_YUVA420P10LE; +export using ::AV_PIX_FMT_YUVA420P16BE; +export using ::AV_PIX_FMT_YUVA420P16LE; +export using ::AV_PIX_FMT_YUVA420P9BE; +export using ::AV_PIX_FMT_YUVA420P9LE; +export using ::AV_PIX_FMT_YUVA422P; +export using ::AV_PIX_FMT_YUVA422P10BE; +export using ::AV_PIX_FMT_YUVA422P10LE; +export using ::AV_PIX_FMT_YUVA422P12BE; +export using ::AV_PIX_FMT_YUVA422P12LE; +export using ::AV_PIX_FMT_YUVA422P16BE; +export using ::AV_PIX_FMT_YUVA422P16LE; +export using ::AV_PIX_FMT_YUVA422P9BE; +export using ::AV_PIX_FMT_YUVA422P9LE; +export using ::AV_PIX_FMT_YUVA444P; +export using ::AV_PIX_FMT_YUVA444P10BE; +export using ::AV_PIX_FMT_YUVA444P10LE; +export using ::AV_PIX_FMT_YUVA444P12BE; +export using ::AV_PIX_FMT_YUVA444P12LE; +export using ::AV_PIX_FMT_YUVA444P16BE; +export using ::AV_PIX_FMT_YUVA444P16LE; +export using ::AV_PIX_FMT_YUVA444P9BE; +export using ::AV_PIX_FMT_YUVA444P9LE; +export using ::AV_PIX_FMT_YUVJ411P; +export using ::AV_PIX_FMT_YUVJ420P; +export using ::AV_PIX_FMT_YUVJ422P; +export using ::AV_PIX_FMT_YUVJ440P; +export using ::AV_PIX_FMT_YUVJ444P; +export using ::AV_PIX_FMT_YUYV422; +export using ::AV_PIX_FMT_YVYU422; +export using ::AV_PRIMARY_EYE_LEFT; +export using ::AV_PRIMARY_EYE_NONE; +export using ::AV_PRIMARY_EYE_RIGHT; +export using ::AV_ROUND_DOWN; +export using ::AV_ROUND_INF; +export using ::AV_ROUND_NEAR_INF; +export using ::AV_ROUND_PASS_MINMAX; +export using ::AV_ROUND_UP; +export using ::AV_ROUND_ZERO; +export using ::AV_SAMPLE_FMT_DBL; +export using ::AV_SAMPLE_FMT_DBLP; +export using ::AV_SAMPLE_FMT_FLT; +export using ::AV_SAMPLE_FMT_FLTP; +export using ::AV_SAMPLE_FMT_NB; +export using ::AV_SAMPLE_FMT_NONE; +export using ::AV_SAMPLE_FMT_S16; +export using ::AV_SAMPLE_FMT_S16P; +export using ::AV_SAMPLE_FMT_S32; +export using ::AV_SAMPLE_FMT_S32P; +export using ::AV_SAMPLE_FMT_S64; +export using ::AV_SAMPLE_FMT_S64P; +export using ::AV_SAMPLE_FMT_U8; +export using ::AV_SAMPLE_FMT_U8P; +export using ::AV_SIDE_DATA_PROP_CHANNEL_DEPENDENT; +export using ::AV_SIDE_DATA_PROP_COLOR_DEPENDENT; +export using ::AV_SIDE_DATA_PROP_GLOBAL; +export using ::AV_SIDE_DATA_PROP_MULTI; +export using ::AV_SIDE_DATA_PROP_SIZE_DEPENDENT; +export using ::AV_SPHERICAL_CUBEMAP; +export using ::AV_SPHERICAL_EQUIRECTANGULAR; +export using ::AV_SPHERICAL_EQUIRECTANGULAR_TILE; +export using ::AV_SPHERICAL_FISHEYE; +export using ::AV_SPHERICAL_HALF_EQUIRECTANGULAR; +export using ::AV_SPHERICAL_PARAMETRIC_IMMERSIVE; +export using ::AV_SPHERICAL_RECTILINEAR; +export using ::AV_STEREO3D_2D; +export using ::AV_STEREO3D_CHECKERBOARD; +export using ::AV_STEREO3D_COLUMNS; +export using ::AV_STEREO3D_FRAMESEQUENCE; +export using ::AV_STEREO3D_LINES; +export using ::AV_STEREO3D_SIDEBYSIDE; +export using ::AV_STEREO3D_SIDEBYSIDE_QUINCUNX; +export using ::AV_STEREO3D_TOPBOTTOM; +export using ::AV_STEREO3D_UNSPEC; +export using ::AV_STEREO3D_VIEW_LEFT; +export using ::AV_STEREO3D_VIEW_PACKED; +export using ::AV_STEREO3D_VIEW_RIGHT; +export using ::AV_STEREO3D_VIEW_UNSPEC; +export using ::AV_THREAD_MESSAGE_NONBLOCK; +export using ::AV_TIMECODE_FLAG_24HOURSMAX; +export using ::AV_TIMECODE_FLAG_ALLOWNEGATIVE; +export using ::AV_TIMECODE_FLAG_DROPFRAME; +export using ::AV_TX_DOUBLE_DCT; +export using ::AV_TX_DOUBLE_DCT_I; +export using ::AV_TX_DOUBLE_DST_I; +export using ::AV_TX_DOUBLE_FFT; +export using ::AV_TX_DOUBLE_MDCT; +export using ::AV_TX_DOUBLE_RDFT; +export using ::AV_TX_FLOAT_DCT; +export using ::AV_TX_FLOAT_DCT_I; +export using ::AV_TX_FLOAT_DST_I; +export using ::AV_TX_FLOAT_FFT; +export using ::AV_TX_FLOAT_MDCT; +export using ::AV_TX_FLOAT_RDFT; +export using ::AV_TX_FULL_IMDCT; +export using ::AV_TX_INPLACE; +export using ::AV_TX_INT32_DCT; +export using ::AV_TX_INT32_DCT_I; +export using ::AV_TX_INT32_DST_I; +export using ::AV_TX_INT32_FFT; +export using ::AV_TX_INT32_MDCT; +export using ::AV_TX_INT32_RDFT; +export using ::AV_TX_NB; +export using ::AV_TX_REAL_TO_IMAGINARY; +export using ::AV_TX_REAL_TO_REAL; +export using ::AV_TX_UNALIGNED; +export using ::AV_VIDEO_ENC_PARAMS_H264; +export using ::AV_VIDEO_ENC_PARAMS_MPEG2; +export using ::AV_VIDEO_ENC_PARAMS_NONE; +export using ::AV_VIDEO_ENC_PARAMS_VP9; +export using ::AV_VIDEO_HINT_TYPE_CHANGED; +export using ::AV_VIDEO_HINT_TYPE_CONSTANT; +export using ::FF_CHANNEL_ORDER_NB; + +// functions (553) +export using ::av_add_q; +export using ::av_add_stable; +export using ::av_adler32_update; +export using ::av_aes_crypt; +export using ::av_aes_ctr_crypt; +export using ::av_aes_ctr_free; +export using ::av_aes_ctr_get_iv; +export using ::av_aes_ctr_increment_iv; +export using ::av_aes_ctr_init; +export using ::av_aes_ctr_set_full_iv; +export using ::av_aes_ctr_set_iv; +export using ::av_aes_ctr_set_random_iv; +export using ::av_aes_init; +export using ::av_alpha_mode_from_name; +export using ::av_alpha_mode_name; +export using ::av_ambient_viewing_environment_alloc; +export using ::av_ambient_viewing_environment_create_side_data; +export using ::av_append_path_component; +export using ::av_assert0_fpu; +export using ::av_audio_fifo_alloc; +export using ::av_audio_fifo_drain; +export using ::av_audio_fifo_free; +export using ::av_audio_fifo_peek; +export using ::av_audio_fifo_peek_at; +export using ::av_audio_fifo_read; +export using ::av_audio_fifo_realloc; +export using ::av_audio_fifo_reset; +export using ::av_audio_fifo_size; +export using ::av_audio_fifo_space; +export using ::av_audio_fifo_write; +export using ::av_base64_decode; +export using ::av_base64_encode; +export using ::av_basename; +export using ::av_bessel_i0; +export using ::av_blowfish_alloc; +export using ::av_blowfish_crypt; +export using ::av_blowfish_crypt_ecb; +export using ::av_blowfish_init; +export using ::av_bprint_append_data; +export using ::av_bprint_chars; +export using ::av_bprint_clear; +export using ::av_bprint_escape; +export using ::av_bprint_get_buffer; +export using ::av_bprint_init; +export using ::av_bprint_init_for_buffer; +export using ::av_bprint_strftime; +export using ::av_bprintf; +export using ::av_buffer_alloc; +export using ::av_buffer_allocz; +export using ::av_buffer_create; +export using ::av_buffer_default_free; +export using ::av_buffer_get_opaque; +export using ::av_buffer_get_ref_count; +export using ::av_buffer_is_writable; +export using ::av_buffer_make_writable; +export using ::av_buffer_pool_buffer_get_opaque; +export using ::av_buffer_pool_get; +export using ::av_buffer_pool_init; +export using ::av_buffer_pool_init2; +export using ::av_buffer_pool_uninit; +export using ::av_buffer_realloc; +export using ::av_buffer_ref; +export using ::av_buffer_replace; +export using ::av_buffer_unref; +export using ::av_calloc; +export using ::av_camellia_crypt; +export using ::av_camellia_init; +export using ::av_cast5_crypt; +export using ::av_cast5_crypt2; +export using ::av_cast5_init; +export using ::av_channel_description; +export using ::av_channel_description_bprint; +export using ::av_channel_from_string; +export using ::av_channel_layout_ambisonic_order; +export using ::av_channel_layout_channel_from_index; +export using ::av_channel_layout_channel_from_string; +export using ::av_channel_layout_check; +export using ::av_channel_layout_compare; +export using ::av_channel_layout_copy; +export using ::av_channel_layout_custom_init; +export using ::av_channel_layout_default; +export using ::av_channel_layout_describe; +export using ::av_channel_layout_describe_bprint; +export using ::av_channel_layout_from_mask; +export using ::av_channel_layout_from_string; +export using ::av_channel_layout_index_from_channel; +export using ::av_channel_layout_index_from_string; +export using ::av_channel_layout_retype; +export using ::av_channel_layout_standard; +export using ::av_channel_layout_subset; +export using ::av_channel_layout_uninit; +export using ::av_channel_name; +export using ::av_channel_name_bprint; +export using ::av_chroma_location_enum_to_pos; +export using ::av_chroma_location_from_name; +export using ::av_chroma_location_name; +export using ::av_chroma_location_pos_to_enum; +export using ::av_color_primaries_from_name; +export using ::av_color_primaries_name; +export using ::av_color_range_from_name; +export using ::av_color_range_name; +export using ::av_color_space_from_name; +export using ::av_color_space_name; +export using ::av_color_transfer_from_name; +export using ::av_color_transfer_name; +export using ::av_compare_mod; +export using ::av_compare_ts; +export using ::av_container_fifo_alloc; +export using ::av_container_fifo_alloc_avframe; +export using ::av_container_fifo_can_read; +export using ::av_container_fifo_drain; +export using ::av_container_fifo_free; +export using ::av_container_fifo_peek; +export using ::av_container_fifo_read; +export using ::av_container_fifo_write; +export using ::av_content_light_metadata_alloc; +export using ::av_content_light_metadata_create_side_data; +export using ::av_cpu_count; +export using ::av_cpu_force_count; +export using ::av_cpu_max_align; +export using ::av_crc; +export using ::av_crc_get_table; +export using ::av_crc_init; +export using ::av_csp_approximate_eotf_gamma; +export using ::av_csp_approximate_trc_gamma; +export using ::av_csp_itu_eotf; +export using ::av_csp_itu_eotf_inv; +export using ::av_csp_luma_coeffs_from_avcsp; +export using ::av_csp_primaries_desc_from_id; +export using ::av_csp_primaries_id_from_desc; +export using ::av_csp_trc_func_from_id; +export using ::av_csp_trc_func_inv_from_id; +export using ::av_default_get_category; +export using ::av_default_item_name; +export using ::av_des_alloc; +export using ::av_des_crypt; +export using ::av_des_init; +export using ::av_des_mac; +export using ::av_detection_bbox_create_side_data; +export using ::av_dict_copy; +export using ::av_dict_count; +export using ::av_dict_free; +export using ::av_dict_get; +export using ::av_dict_get_string; +export using ::av_dict_iterate; +export using ::av_dict_parse_string; +export using ::av_dict_set; +export using ::av_dict_set_int; +export using ::av_dirname; +export using ::av_display_matrix_flip; +export using ::av_display_rotation_get; +export using ::av_display_rotation_set; +export using ::av_div_q; +export using ::av_dovi_alloc; +export using ::av_dovi_metadata_alloc; +export using ::av_downmix_info_update_side_data; +export using ::av_dynamic_hdr_plus_alloc; +export using ::av_dynamic_hdr_plus_create_side_data; +export using ::av_dynamic_hdr_plus_from_t35; +export using ::av_dynamic_hdr_plus_to_t35; +export using ::av_dynamic_hdr_vivid_alloc; +export using ::av_dynamic_hdr_vivid_create_side_data; +export using ::av_dynarray2_add; +export using ::av_dynarray_add; +export using ::av_dynarray_add_nofree; +export using ::av_encryption_info_add_side_data; +export using ::av_encryption_info_alloc; +export using ::av_encryption_info_clone; +export using ::av_encryption_info_free; +export using ::av_encryption_info_get_side_data; +export using ::av_encryption_init_info_add_side_data; +export using ::av_encryption_init_info_alloc; +export using ::av_encryption_init_info_free; +export using ::av_encryption_init_info_get_side_data; +export using ::av_escape; +export using ::av_executor_alloc; +export using ::av_executor_execute; +export using ::av_executor_free; +export using ::av_expr_count_func; +export using ::av_expr_count_vars; +export using ::av_expr_eval; +export using ::av_expr_free; +export using ::av_expr_parse; +export using ::av_expr_parse_and_eval; +export using ::av_fast_malloc; +export using ::av_fast_mallocz; +export using ::av_fast_realloc; +export using ::av_fifo_alloc2; +export using ::av_fifo_auto_grow_limit; +export using ::av_fifo_can_read; +export using ::av_fifo_can_write; +export using ::av_fifo_drain2; +export using ::av_fifo_elem_size; +export using ::av_fifo_freep2; +export using ::av_fifo_grow2; +export using ::av_fifo_peek; +export using ::av_fifo_peek_to_cb; +export using ::av_fifo_read; +export using ::av_fifo_read_to_cb; +export using ::av_fifo_reset2; +export using ::av_fifo_write; +export using ::av_fifo_write_from_cb; +export using ::av_file_map; +export using ::av_file_unmap; +export using ::av_film_grain_params_alloc; +export using ::av_film_grain_params_create_side_data; +export using ::av_film_grain_params_select; +export using ::av_find_best_pix_fmt_of_2; +export using ::av_find_info_tag; +export using ::av_find_nearest_q_idx; +export using ::av_force_cpu_flags; +export using ::av_fourcc_make_string; +export using ::av_frame_alloc; +export using ::av_frame_apply_cropping; +export using ::av_frame_clone; +export using ::av_frame_copy; +export using ::av_frame_copy_props; +export using ::av_frame_free; +export using ::av_frame_get_buffer; +export using ::av_frame_get_plane_buffer; +export using ::av_frame_get_side_data; +export using ::av_frame_is_writable; +export using ::av_frame_make_writable; +export using ::av_frame_move_ref; +export using ::av_frame_new_side_data; +export using ::av_frame_new_side_data_from_buf; +export using ::av_frame_ref; +export using ::av_frame_remove_side_data; +export using ::av_frame_replace; +export using ::av_frame_side_data_add; +export using ::av_frame_side_data_clone; +export using ::av_frame_side_data_desc; +export using ::av_frame_side_data_free; +export using ::av_frame_side_data_get_c; +export using ::av_frame_side_data_name; +export using ::av_frame_side_data_new; +export using ::av_frame_side_data_remove_by_props; +export using ::av_frame_unref; +export using ::av_free; +export using ::av_freep; +export using ::av_gcd; +export using ::av_gcd_q; +export using ::av_get_alt_sample_fmt; +export using ::av_get_bits_per_pixel; +export using ::av_get_bytes_per_sample; +export using ::av_get_cpu_flags; +export using ::av_get_known_color_name; +export using ::av_get_media_type_string; +export using ::av_get_packed_sample_fmt; +export using ::av_get_padded_bits_per_pixel; +export using ::av_get_picture_type_char; +export using ::av_get_pix_fmt; +export using ::av_get_pix_fmt_loss; +export using ::av_get_pix_fmt_name; +export using ::av_get_pix_fmt_string; +export using ::av_get_planar_sample_fmt; +export using ::av_get_random_seed; +export using ::av_get_sample_fmt; +export using ::av_get_sample_fmt_name; +export using ::av_get_sample_fmt_string; +export using ::av_get_time_base_q; +export using ::av_get_token; +export using ::av_gettime; +export using ::av_gettime_relative; +export using ::av_gettime_relative_is_monotonic; +export using ::av_hash_alloc; +export using ::av_hash_final; +export using ::av_hash_final_b64; +export using ::av_hash_final_bin; +export using ::av_hash_final_hex; +export using ::av_hash_freep; +export using ::av_hash_get_name; +export using ::av_hash_get_size; +export using ::av_hash_init; +export using ::av_hash_names; +export using ::av_hash_update; +export using ::av_hmac_alloc; +export using ::av_hmac_calc; +export using ::av_hmac_final; +export using ::av_hmac_free; +export using ::av_hmac_init; +export using ::av_hmac_update; +export using ::av_hwdevice_ctx_alloc; +export using ::av_hwdevice_ctx_create; +export using ::av_hwdevice_ctx_create_derived; +export using ::av_hwdevice_ctx_create_derived_opts; +export using ::av_hwdevice_ctx_init; +export using ::av_hwdevice_find_type_by_name; +export using ::av_hwdevice_get_hwframe_constraints; +export using ::av_hwdevice_get_type_name; +export using ::av_hwdevice_hwconfig_alloc; +export using ::av_hwdevice_iterate_types; +export using ::av_hwframe_constraints_free; +export using ::av_hwframe_ctx_alloc; +export using ::av_hwframe_ctx_create_derived; +export using ::av_hwframe_ctx_init; +export using ::av_hwframe_get_buffer; +export using ::av_hwframe_map; +export using ::av_hwframe_transfer_data; +export using ::av_hwframe_transfer_get_formats; +export using ::av_iamf_audio_element_add_layer; +export using ::av_iamf_audio_element_alloc; +export using ::av_iamf_audio_element_free; +export using ::av_iamf_audio_element_get_class; +export using ::av_iamf_mix_presentation_add_submix; +export using ::av_iamf_mix_presentation_alloc; +export using ::av_iamf_mix_presentation_free; +export using ::av_iamf_mix_presentation_get_class; +export using ::av_iamf_param_definition_alloc; +export using ::av_iamf_param_definition_get_class; +export using ::av_iamf_submix_add_element; +export using ::av_iamf_submix_add_layout; +export using ::av_image_alloc; +export using ::av_image_check_sar; +export using ::av_image_check_size; +export using ::av_image_check_size2; +export using ::av_image_copy; +export using ::av_image_copy_plane; +export using ::av_image_copy_plane_uc_from; +export using ::av_image_copy_to_buffer; +export using ::av_image_fill_arrays; +export using ::av_image_fill_black; +export using ::av_image_fill_color; +export using ::av_image_fill_linesizes; +export using ::av_image_fill_max_pixsteps; +export using ::av_image_fill_plane_sizes; +export using ::av_image_fill_pointers; +export using ::av_image_get_buffer_size; +export using ::av_image_get_linesize; +export using ::av_lfg_init; +export using ::av_lfg_init_from_data; +export using ::av_log; +export using ::av_log2; +export using ::av_log2_16bit; +export using ::av_log_default_callback; +export using ::av_log_format_line; +export using ::av_log_format_line2; +export using ::av_log_get_flags; +export using ::av_log_get_level; +export using ::av_log_once; +export using ::av_log_set_callback; +export using ::av_log_set_flags; +export using ::av_log_set_level; +export using ::av_lzo1x_decode; +export using ::av_malloc; +export using ::av_mallocz; +export using ::av_mastering_display_metadata_alloc; +export using ::av_mastering_display_metadata_alloc_size; +export using ::av_mastering_display_metadata_create_side_data; +export using ::av_match_list; +export using ::av_match_name; +export using ::av_max_alloc; +export using ::av_md5_final; +export using ::av_md5_init; +export using ::av_md5_sum; +export using ::av_md5_update; +export using ::av_memcpy_backptr; +export using ::av_memdup; +export using ::av_mul_q; +export using ::av_murmur3_final; +export using ::av_murmur3_init; +export using ::av_murmur3_init_seeded; +export using ::av_murmur3_update; +export using ::av_nearer_q; +export using ::av_opt_child_class_iterate; +export using ::av_opt_child_next; +export using ::av_opt_copy; +export using ::av_opt_eval_double; +export using ::av_opt_eval_flags; +export using ::av_opt_eval_float; +export using ::av_opt_eval_int; +export using ::av_opt_eval_int64; +export using ::av_opt_eval_q; +export using ::av_opt_eval_uint; +export using ::av_opt_find; +export using ::av_opt_find2; +export using ::av_opt_flag_is_set; +export using ::av_opt_free; +export using ::av_opt_freep_ranges; +export using ::av_opt_get; +export using ::av_opt_get_array; +export using ::av_opt_get_array_size; +export using ::av_opt_get_chlayout; +export using ::av_opt_get_dict_val; +export using ::av_opt_get_double; +export using ::av_opt_get_image_size; +export using ::av_opt_get_int; +export using ::av_opt_get_key_value; +export using ::av_opt_get_pixel_fmt; +export using ::av_opt_get_q; +export using ::av_opt_get_sample_fmt; +export using ::av_opt_get_video_rate; +export using ::av_opt_is_set_to_default; +export using ::av_opt_is_set_to_default_by_name; +export using ::av_opt_next; +export using ::av_opt_ptr; +export using ::av_opt_query_ranges; +export using ::av_opt_query_ranges_default; +export using ::av_opt_serialize; +export using ::av_opt_set; +export using ::av_opt_set_array; +export using ::av_opt_set_bin; +export using ::av_opt_set_chlayout; +export using ::av_opt_set_defaults; +export using ::av_opt_set_defaults2; +export using ::av_opt_set_dict; +export using ::av_opt_set_dict2; +export using ::av_opt_set_dict_val; +export using ::av_opt_set_double; +export using ::av_opt_set_from_string; +export using ::av_opt_set_image_size; +export using ::av_opt_set_int; +export using ::av_opt_set_pixel_fmt; +export using ::av_opt_set_q; +export using ::av_opt_set_sample_fmt; +export using ::av_opt_set_video_rate; +export using ::av_opt_show2; +export using ::av_parse_color; +export using ::av_parse_cpu_caps; +export using ::av_parse_ratio; +export using ::av_parse_time; +export using ::av_parse_video_rate; +export using ::av_parse_video_size; +export using ::av_pix_fmt_count_planes; +export using ::av_pix_fmt_desc_get; +export using ::av_pix_fmt_desc_get_id; +export using ::av_pix_fmt_desc_next; +export using ::av_pix_fmt_get_chroma_sub_sample; +export using ::av_pix_fmt_swap_endianness; +export using ::av_pixelutils_get_sad_fn; +export using ::av_q2intfloat; +export using ::av_random_bytes; +export using ::av_rc4_alloc; +export using ::av_rc4_crypt; +export using ::av_rc4_init; +export using ::av_read_image_line; +export using ::av_read_image_line2; +export using ::av_realloc; +export using ::av_realloc_f; +export using ::av_reallocp; +export using ::av_reallocp_array; +export using ::av_refstruct_alloc_ext_c; +export using ::av_refstruct_exclusive; +export using ::av_refstruct_pool_alloc; +export using ::av_refstruct_pool_alloc_ext_c; +export using ::av_refstruct_ref; +export using ::av_refstruct_ref_c; +export using ::av_refstruct_replace; +export using ::av_rescale; +export using ::av_rescale_delta; +export using ::av_rescale_q; +export using ::av_rescale_q_rnd; +export using ::av_rescale_rnd; +export using ::av_ripemd_final; +export using ::av_ripemd_init; +export using ::av_ripemd_update; +export using ::av_sample_fmt_is_planar; +export using ::av_samples_alloc; +export using ::av_samples_alloc_array_and_samples; +export using ::av_samples_copy; +export using ::av_samples_fill_arrays; +export using ::av_samples_get_buffer_size; +export using ::av_samples_set_silence; +export using ::av_set_options_string; +export using ::av_sha512_final; +export using ::av_sha512_init; +export using ::av_sha512_update; +export using ::av_sha_final; +export using ::av_sha_init; +export using ::av_sha_update; +export using ::av_size_mult; +export using ::av_small_strptime; +export using ::av_spherical_alloc; +export using ::av_spherical_from_name; +export using ::av_spherical_projection_name; +export using ::av_spherical_tile_bounds; +export using ::av_sscanf; +export using ::av_stereo3d_alloc; +export using ::av_stereo3d_alloc_size; +export using ::av_stereo3d_create_side_data; +export using ::av_stereo3d_from_name; +export using ::av_stereo3d_primary_eye_from_name; +export using ::av_stereo3d_primary_eye_name; +export using ::av_stereo3d_type_name; +export using ::av_stereo3d_view_from_name; +export using ::av_stereo3d_view_name; +export using ::av_strdup; +export using ::av_strerror; +export using ::av_strireplace; +export using ::av_stristart; +export using ::av_stristr; +export using ::av_strlcat; +export using ::av_strlcatf; +export using ::av_strlcpy; +export using ::av_strncasecmp; +export using ::av_strndup; +export using ::av_strnstr; +export using ::av_strstart; +export using ::av_strtod; +export using ::av_strtok; +export using ::av_sub_q; +export using ::av_tea_crypt; +export using ::av_tea_init; +export using ::av_thread_message_flush; +export using ::av_thread_message_queue_alloc; +export using ::av_thread_message_queue_free; +export using ::av_thread_message_queue_nb_elems; +export using ::av_thread_message_queue_recv; +export using ::av_thread_message_queue_send; +export using ::av_thread_message_queue_set_err_recv; +export using ::av_thread_message_queue_set_err_send; +export using ::av_thread_message_queue_set_free_func; +export using ::av_timecode_adjust_ntsc_framenum2; +export using ::av_timecode_check_frame_rate; +export using ::av_timecode_get_smpte; +export using ::av_timecode_get_smpte_from_framenum; +export using ::av_timecode_init; +export using ::av_timecode_init_from_components; +export using ::av_timecode_init_from_string; +export using ::av_timecode_make_mpeg_tc_string; +export using ::av_timecode_make_smpte_tc_string; +export using ::av_timecode_make_smpte_tc_string2; +export using ::av_timecode_make_string; +export using ::av_timegm; +export using ::av_tree_destroy; +export using ::av_tree_enumerate; +export using ::av_tree_find; +export using ::av_tree_insert; +export using ::av_twofish_crypt; +export using ::av_twofish_init; +export using ::av_tx_init; +export using ::av_tx_uninit; +export using ::av_usleep; +export using ::av_utf8_decode; +export using ::av_uuid_parse; +export using ::av_uuid_parse_range; +export using ::av_uuid_unparse; +export using ::av_uuid_urn_parse; +export using ::av_vbprintf; +export using ::av_version_info; +export using ::av_video_enc_params_create_side_data; +export using ::av_video_hint_create_side_data; +export using ::av_vlog; +export using ::av_write_image_line; +export using ::av_write_image_line2; +export using ::av_xtea_alloc; +export using ::av_xtea_crypt; +export using ::av_xtea_init; +export using ::av_xtea_le_crypt; +export using ::av_xtea_le_init; +export using ::avutil_configuration; +export using ::avutil_license; +export using ::avutil_version; diff --git a/src/gen_exports/avutil.includes.inc b/src/gen_exports/avutil.includes.inc new file mode 100644 index 0000000..dffaece --- /dev/null +++ b/src/gen_exports/avutil.includes.inc @@ -0,0 +1,87 @@ +// Auto-generated by tools/gen_exports.py — installed public headers of libavutil. + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include diff --git a/src/gen_exports/avutil.skipped.txt b/src/gen_exports/avutil.skipped.txt new file mode 100644 index 0000000..88bf682 --- /dev/null +++ b/src/gen_exports/avutil.skipped.txt @@ -0,0 +1,808 @@ +(macro-clash) av_alloc_size +adler32.h: macro AVUTIL_ADLER32_H +aes.h: macro AVUTIL_AES_H +aes_ctr.h: macro AES_CTR_IV_SIZE +aes_ctr.h: macro AES_CTR_KEY_SIZE +aes_ctr.h: macro AVUTIL_AES_CTR_H +ambient_viewing_environment.h: macro AVUTIL_AMBIENT_VIEWING_ENVIRONMENT_H +attributes.h: macro AVUTIL_ATTRIBUTES_H +attributes.h: macro AV_GCC_VERSION_AT_LEAST +attributes.h: macro AV_GCC_VERSION_AT_MOST +attributes.h: macro AV_HAS_ATTRIBUTE +attributes.h: macro AV_HAS_BUILTIN +attributes.h: macro AV_HAS_STD_ATTRIBUTE +attributes.h: macro AV_NOWARN_DEPRECATED +attributes.h: macro AV_PRINTF_FMT +attributes.h: macro AV_SCANF_FMT +attributes.h: macro attribute_deprecated +attributes.h: macro av_alias +attributes.h: macro av_always_inline +attributes.h: macro av_builtin_constant_p +attributes.h: macro av_cold +attributes.h: macro av_const +attributes.h: macro av_extern_inline +attributes.h: macro av_flatten +attributes.h: macro av_noinline +attributes.h: macro av_noreturn +attributes.h: macro av_printf_format +attributes.h: macro av_pure +attributes.h: macro av_scanf_format +attributes.h: macro av_uninit +attributes.h: macro av_unused +attributes.h: macro av_used +attributes.h: macro av_warn_unused_result +audio_fifo.h: macro AVUTIL_AUDIO_FIFO_H +avassert.h: macro AVUTIL_AVASSERT_H +avassert.h: macro av_assert0 +avassert.h: macro av_assert1 +avassert.h: macro av_assert2 +avassert.h: macro av_assert2_fpu +avassert.h: macro av_assume +avassert.h: macro av_unreachable +avstring.h: macro AVUTIL_AVSTRING_H +avstring.h: macro AV_ESCAPE_FLAG_STRICT +avstring.h: macro AV_ESCAPE_FLAG_WHITESPACE +avstring.h: macro AV_ESCAPE_FLAG_XML_DOUBLE_QUOTES +avstring.h: macro AV_ESCAPE_FLAG_XML_SINGLE_QUOTES +avstring.h: macro AV_UTF8_FLAG_ACCEPT_ALL +avstring.h: macro AV_UTF8_FLAG_ACCEPT_INVALID_BIG_CODES +avstring.h: macro AV_UTF8_FLAG_ACCEPT_NON_CHARACTERS +avstring.h: macro AV_UTF8_FLAG_ACCEPT_SURROGATES +avstring.h: macro AV_UTF8_FLAG_EXCLUDE_XML_INVALID_CONTROL_CODES +avstring.h: static-inline av_isdigit +avstring.h: static-inline av_strnlen +avutil.h: macro AVUTIL_AVUTIL_H +avutil.h: macro AV_FOURCC_MAX_STRING_SIZE +avutil.h: macro AV_NOPTS_VALUE +avutil.h: macro AV_TIME_BASE +avutil.h: macro AV_TIME_BASE_Q +avutil.h: macro FF_LAMBDA_MAX +avutil.h: macro FF_LAMBDA_SCALE +avutil.h: macro FF_LAMBDA_SHIFT +avutil.h: macro FF_QP2LAMBDA +avutil.h: macro FF_QUALITY_SCALE +avutil.h: macro av_fourcc2str +avutil.h: macro av_int_list_length +avutil.h: static-inline av_x_if_null +base64.h: macro AVUTIL_BASE64_H +base64.h: macro AV_BASE64_DECODE_SIZE +base64.h: macro AV_BASE64_SIZE +blowfish.h: macro AVUTIL_BLOWFISH_H +blowfish.h: macro AV_BF_ROUNDS +bprint.h: macro AVUTIL_BPRINT_H +bprint.h: macro AV_BPRINT_SIZE_AUTOMATIC +bprint.h: macro AV_BPRINT_SIZE_COUNT_ONLY +bprint.h: macro AV_BPRINT_SIZE_UNLIMITED +bprint.h: macro FF_PAD_STRUCTURE +bprint.h: static-inline av_bprint_is_complete +bswap.h: macro AVUTIL_BSWAP_H +bswap.h: macro AV_BE2NE16C +bswap.h: macro AV_BE2NE32C +bswap.h: macro AV_BE2NE64C +bswap.h: macro AV_BE2NEC +bswap.h: macro AV_BSWAP16C +bswap.h: macro AV_BSWAP32C +bswap.h: macro AV_BSWAP64C +bswap.h: macro AV_BSWAPC +bswap.h: macro AV_LE2NE16C +bswap.h: macro AV_LE2NE32C +bswap.h: macro AV_LE2NE64C +bswap.h: macro AV_LE2NEC +bswap.h: macro av_be2ne16 +bswap.h: macro av_be2ne32 +bswap.h: macro av_be2ne64 +bswap.h: macro av_le2ne16 +bswap.h: macro av_le2ne32 +bswap.h: macro av_le2ne64 +buffer.h: macro AVUTIL_BUFFER_H +buffer.h: macro AV_BUFFER_FLAG_READONLY +camellia.h: macro AVUTIL_CAMELLIA_H +cast5.h: macro AVUTIL_CAST5_H +channel_layout.h: macro AVUTIL_CHANNEL_LAYOUT_H +channel_layout.h: macro AV_CHANNEL_LAYOUT_22POINT2 +channel_layout.h: macro AV_CHANNEL_LAYOUT_2POINT1 +channel_layout.h: macro AV_CHANNEL_LAYOUT_2_1 +channel_layout.h: macro AV_CHANNEL_LAYOUT_2_2 +channel_layout.h: macro AV_CHANNEL_LAYOUT_3POINT1 +channel_layout.h: macro AV_CHANNEL_LAYOUT_3POINT1POINT2 +channel_layout.h: macro AV_CHANNEL_LAYOUT_4POINT0 +channel_layout.h: macro AV_CHANNEL_LAYOUT_4POINT1 +channel_layout.h: macro AV_CHANNEL_LAYOUT_5POINT0 +channel_layout.h: macro AV_CHANNEL_LAYOUT_5POINT0_BACK +channel_layout.h: macro AV_CHANNEL_LAYOUT_5POINT1 +channel_layout.h: macro AV_CHANNEL_LAYOUT_5POINT1POINT2 +channel_layout.h: macro AV_CHANNEL_LAYOUT_5POINT1POINT2_BACK +channel_layout.h: macro AV_CHANNEL_LAYOUT_5POINT1POINT4_BACK +channel_layout.h: macro AV_CHANNEL_LAYOUT_5POINT1_BACK +channel_layout.h: macro AV_CHANNEL_LAYOUT_6POINT0 +channel_layout.h: macro AV_CHANNEL_LAYOUT_6POINT0_FRONT +channel_layout.h: macro AV_CHANNEL_LAYOUT_6POINT1 +channel_layout.h: macro AV_CHANNEL_LAYOUT_6POINT1_BACK +channel_layout.h: macro AV_CHANNEL_LAYOUT_6POINT1_FRONT +channel_layout.h: macro AV_CHANNEL_LAYOUT_7POINT0 +channel_layout.h: macro AV_CHANNEL_LAYOUT_7POINT0_FRONT +channel_layout.h: macro AV_CHANNEL_LAYOUT_7POINT1 +channel_layout.h: macro AV_CHANNEL_LAYOUT_7POINT1POINT2 +channel_layout.h: macro AV_CHANNEL_LAYOUT_7POINT1POINT4_BACK +channel_layout.h: macro AV_CHANNEL_LAYOUT_7POINT1_TOP_BACK +channel_layout.h: macro AV_CHANNEL_LAYOUT_7POINT1_WIDE +channel_layout.h: macro AV_CHANNEL_LAYOUT_7POINT1_WIDE_BACK +channel_layout.h: macro AV_CHANNEL_LAYOUT_7POINT2POINT3 +channel_layout.h: macro AV_CHANNEL_LAYOUT_9POINT1POINT4_BACK +channel_layout.h: macro AV_CHANNEL_LAYOUT_9POINT1POINT6 +channel_layout.h: macro AV_CHANNEL_LAYOUT_AMBISONIC_FIRST_ORDER +channel_layout.h: macro AV_CHANNEL_LAYOUT_BINAURAL +channel_layout.h: macro AV_CHANNEL_LAYOUT_CUBE +channel_layout.h: macro AV_CHANNEL_LAYOUT_HEXADECAGONAL +channel_layout.h: macro AV_CHANNEL_LAYOUT_HEXAGONAL +channel_layout.h: macro AV_CHANNEL_LAYOUT_MASK +channel_layout.h: macro AV_CHANNEL_LAYOUT_MONO +channel_layout.h: macro AV_CHANNEL_LAYOUT_OCTAGONAL +channel_layout.h: macro AV_CHANNEL_LAYOUT_QUAD +channel_layout.h: macro AV_CHANNEL_LAYOUT_RETYPE_FLAG_CANONICAL +channel_layout.h: macro AV_CHANNEL_LAYOUT_RETYPE_FLAG_LOSSLESS +channel_layout.h: macro AV_CHANNEL_LAYOUT_STEREO +channel_layout.h: macro AV_CHANNEL_LAYOUT_STEREO_DOWNMIX +channel_layout.h: macro AV_CHANNEL_LAYOUT_SURROUND +channel_layout.h: macro AV_CH_BACK_CENTER +channel_layout.h: macro AV_CH_BACK_LEFT +channel_layout.h: macro AV_CH_BACK_RIGHT +channel_layout.h: macro AV_CH_BINAURAL_LEFT +channel_layout.h: macro AV_CH_BINAURAL_RIGHT +channel_layout.h: macro AV_CH_BOTTOM_FRONT_CENTER +channel_layout.h: macro AV_CH_BOTTOM_FRONT_LEFT +channel_layout.h: macro AV_CH_BOTTOM_FRONT_RIGHT +channel_layout.h: macro AV_CH_FRONT_CENTER +channel_layout.h: macro AV_CH_FRONT_LEFT +channel_layout.h: macro AV_CH_FRONT_LEFT_OF_CENTER +channel_layout.h: macro AV_CH_FRONT_RIGHT +channel_layout.h: macro AV_CH_FRONT_RIGHT_OF_CENTER +channel_layout.h: macro AV_CH_LAYOUT_22POINT2 +channel_layout.h: macro AV_CH_LAYOUT_2POINT1 +channel_layout.h: macro AV_CH_LAYOUT_2_1 +channel_layout.h: macro AV_CH_LAYOUT_2_2 +channel_layout.h: macro AV_CH_LAYOUT_3POINT1 +channel_layout.h: macro AV_CH_LAYOUT_3POINT1POINT2 +channel_layout.h: macro AV_CH_LAYOUT_4POINT0 +channel_layout.h: macro AV_CH_LAYOUT_4POINT1 +channel_layout.h: macro AV_CH_LAYOUT_5POINT0 +channel_layout.h: macro AV_CH_LAYOUT_5POINT0_BACK +channel_layout.h: macro AV_CH_LAYOUT_5POINT1 +channel_layout.h: macro AV_CH_LAYOUT_5POINT1POINT2 +channel_layout.h: macro AV_CH_LAYOUT_5POINT1POINT2_BACK +channel_layout.h: macro AV_CH_LAYOUT_5POINT1POINT4_BACK +channel_layout.h: macro AV_CH_LAYOUT_5POINT1_BACK +channel_layout.h: macro AV_CH_LAYOUT_6POINT0 +channel_layout.h: macro AV_CH_LAYOUT_6POINT0_FRONT +channel_layout.h: macro AV_CH_LAYOUT_6POINT1 +channel_layout.h: macro AV_CH_LAYOUT_6POINT1_BACK +channel_layout.h: macro AV_CH_LAYOUT_6POINT1_FRONT +channel_layout.h: macro AV_CH_LAYOUT_7POINT0 +channel_layout.h: macro AV_CH_LAYOUT_7POINT0_FRONT +channel_layout.h: macro AV_CH_LAYOUT_7POINT1 +channel_layout.h: macro AV_CH_LAYOUT_7POINT1POINT2 +channel_layout.h: macro AV_CH_LAYOUT_7POINT1POINT4_BACK +channel_layout.h: macro AV_CH_LAYOUT_7POINT1_TOP_BACK +channel_layout.h: macro AV_CH_LAYOUT_7POINT1_WIDE +channel_layout.h: macro AV_CH_LAYOUT_7POINT1_WIDE_BACK +channel_layout.h: macro AV_CH_LAYOUT_7POINT2POINT3 +channel_layout.h: macro AV_CH_LAYOUT_9POINT1POINT4_BACK +channel_layout.h: macro AV_CH_LAYOUT_9POINT1POINT6 +channel_layout.h: macro AV_CH_LAYOUT_BINAURAL +channel_layout.h: macro AV_CH_LAYOUT_CUBE +channel_layout.h: macro AV_CH_LAYOUT_HEXADECAGONAL +channel_layout.h: macro AV_CH_LAYOUT_HEXAGONAL +channel_layout.h: macro AV_CH_LAYOUT_MONO +channel_layout.h: macro AV_CH_LAYOUT_OCTAGONAL +channel_layout.h: macro AV_CH_LAYOUT_QUAD +channel_layout.h: macro AV_CH_LAYOUT_STEREO +channel_layout.h: macro AV_CH_LAYOUT_STEREO_DOWNMIX +channel_layout.h: macro AV_CH_LAYOUT_SURROUND +channel_layout.h: macro AV_CH_LOW_FREQUENCY +channel_layout.h: macro AV_CH_LOW_FREQUENCY_2 +channel_layout.h: macro AV_CH_SIDE_LEFT +channel_layout.h: macro AV_CH_SIDE_RIGHT +channel_layout.h: macro AV_CH_SIDE_SURROUND_LEFT +channel_layout.h: macro AV_CH_SIDE_SURROUND_RIGHT +channel_layout.h: macro AV_CH_STEREO_LEFT +channel_layout.h: macro AV_CH_STEREO_RIGHT +channel_layout.h: macro AV_CH_SURROUND_DIRECT_LEFT +channel_layout.h: macro AV_CH_SURROUND_DIRECT_RIGHT +channel_layout.h: macro AV_CH_TOP_BACK_CENTER +channel_layout.h: macro AV_CH_TOP_BACK_LEFT +channel_layout.h: macro AV_CH_TOP_BACK_RIGHT +channel_layout.h: macro AV_CH_TOP_CENTER +channel_layout.h: macro AV_CH_TOP_FRONT_CENTER +channel_layout.h: macro AV_CH_TOP_FRONT_LEFT +channel_layout.h: macro AV_CH_TOP_FRONT_RIGHT +channel_layout.h: macro AV_CH_TOP_SIDE_LEFT +channel_layout.h: macro AV_CH_TOP_SIDE_RIGHT +channel_layout.h: macro AV_CH_TOP_SURROUND_LEFT +channel_layout.h: macro AV_CH_TOP_SURROUND_RIGHT +channel_layout.h: macro AV_CH_WIDE_LEFT +channel_layout.h: macro AV_CH_WIDE_RIGHT +common.h: macro AVUTIL_COMMON_H +common.h: macro AV_CEIL_RSHIFT +common.h: macro FFABS +common.h: macro FFABS64U +common.h: macro FFABSU +common.h: macro FFNABS +common.h: macro FFSIGN +common.h: macro FFUDIV +common.h: macro FFUMOD +common.h: macro FF_CEIL_RSHIFT +common.h: macro GET_UTF16 +common.h: macro GET_UTF8 +common.h: macro PUT_UTF16 +common.h: macro PUT_UTF8 +common.h: macro ROUNDED_DIV +common.h: macro RSHIFT +common.h: macro av_ceil_log2 +common.h: macro av_clip +common.h: macro av_clip64 +common.h: macro av_clip_int16 +common.h: macro av_clip_int8 +common.h: macro av_clip_intp2 +common.h: macro av_clip_uint16 +common.h: macro av_clip_uint8 +common.h: macro av_clip_uintp2 +common.h: macro av_clipd +common.h: macro av_clipf +common.h: macro av_clipl_int32 +common.h: macro av_mod_uintp2 +common.h: macro av_parity +common.h: macro av_popcount +common.h: macro av_popcount64 +common.h: macro av_sat_add32 +common.h: macro av_sat_add64 +common.h: macro av_sat_dadd32 +common.h: macro av_sat_dsub32 +common.h: macro av_sat_sub32 +common.h: macro av_sat_sub64 +common.h: macro av_zero_extend +container_fifo.h: macro AVUTIL_CONTAINER_FIFO_H +cpu.h: macro AVUTIL_CPU_H +cpu.h: macro AV_CPU_FLAG_3DNOW +cpu.h: macro AV_CPU_FLAG_3DNOWEXT +cpu.h: macro AV_CPU_FLAG_AESNI +cpu.h: macro AV_CPU_FLAG_ALTIVEC +cpu.h: macro AV_CPU_FLAG_ARMV5TE +cpu.h: macro AV_CPU_FLAG_ARMV6 +cpu.h: macro AV_CPU_FLAG_ARMV6T2 +cpu.h: macro AV_CPU_FLAG_ARMV8 +cpu.h: macro AV_CPU_FLAG_ARM_CRC +cpu.h: macro AV_CPU_FLAG_ATOM +cpu.h: macro AV_CPU_FLAG_AVX +cpu.h: macro AV_CPU_FLAG_AVX2 +cpu.h: macro AV_CPU_FLAG_AVX512 +cpu.h: macro AV_CPU_FLAG_AVX512ICL +cpu.h: macro AV_CPU_FLAG_AVXSLOW +cpu.h: macro AV_CPU_FLAG_BMI1 +cpu.h: macro AV_CPU_FLAG_BMI2 +cpu.h: macro AV_CPU_FLAG_CLMUL +cpu.h: macro AV_CPU_FLAG_CMOV +cpu.h: macro AV_CPU_FLAG_DOTPROD +cpu.h: macro AV_CPU_FLAG_FMA3 +cpu.h: macro AV_CPU_FLAG_FMA4 +cpu.h: macro AV_CPU_FLAG_FORCE +cpu.h: macro AV_CPU_FLAG_I8MM +cpu.h: macro AV_CPU_FLAG_LASX +cpu.h: macro AV_CPU_FLAG_LSX +cpu.h: macro AV_CPU_FLAG_MMI +cpu.h: macro AV_CPU_FLAG_MMX +cpu.h: macro AV_CPU_FLAG_MMX2 +cpu.h: macro AV_CPU_FLAG_MMXEXT +cpu.h: macro AV_CPU_FLAG_MSA +cpu.h: macro AV_CPU_FLAG_NEON +cpu.h: macro AV_CPU_FLAG_POWER8 +cpu.h: macro AV_CPU_FLAG_RVB +cpu.h: macro AV_CPU_FLAG_RVB_ADDR +cpu.h: macro AV_CPU_FLAG_RVB_BASIC +cpu.h: macro AV_CPU_FLAG_RVD +cpu.h: macro AV_CPU_FLAG_RVF +cpu.h: macro AV_CPU_FLAG_RVI +cpu.h: macro AV_CPU_FLAG_RVV_F32 +cpu.h: macro AV_CPU_FLAG_RVV_F64 +cpu.h: macro AV_CPU_FLAG_RVV_I32 +cpu.h: macro AV_CPU_FLAG_RVV_I64 +cpu.h: macro AV_CPU_FLAG_RV_MISALIGNED +cpu.h: macro AV_CPU_FLAG_RV_ZVBB +cpu.h: macro AV_CPU_FLAG_SETEND +cpu.h: macro AV_CPU_FLAG_SIMD128 +cpu.h: macro AV_CPU_FLAG_SLOW_GATHER +cpu.h: macro AV_CPU_FLAG_SME +cpu.h: macro AV_CPU_FLAG_SME2 +cpu.h: macro AV_CPU_FLAG_SME_I16I64 +cpu.h: macro AV_CPU_FLAG_SSE +cpu.h: macro AV_CPU_FLAG_SSE2 +cpu.h: macro AV_CPU_FLAG_SSE2SLOW +cpu.h: macro AV_CPU_FLAG_SSE3 +cpu.h: macro AV_CPU_FLAG_SSE3SLOW +cpu.h: macro AV_CPU_FLAG_SSE4 +cpu.h: macro AV_CPU_FLAG_SSE42 +cpu.h: macro AV_CPU_FLAG_SSSE3 +cpu.h: macro AV_CPU_FLAG_SSSE3SLOW +cpu.h: macro AV_CPU_FLAG_SVE +cpu.h: macro AV_CPU_FLAG_SVE2 +cpu.h: macro AV_CPU_FLAG_VFP +cpu.h: macro AV_CPU_FLAG_VFPV3 +cpu.h: macro AV_CPU_FLAG_VFP_VM +cpu.h: macro AV_CPU_FLAG_VSX +cpu.h: macro AV_CPU_FLAG_XOP +crc.h: macro AVUTIL_CRC_H +csp.h: macro AVUTIL_CSP_H +des.h: macro AVUTIL_DES_H +detection_bbox.h: macro AVUTIL_DETECTION_BBOX_H +detection_bbox.h: macro AV_DETECTION_BBOX_LABEL_NAME_MAX_SIZE +detection_bbox.h: macro AV_NUM_DETECTION_BBOX_CLASSIFY +detection_bbox.h: static-inline av_get_detection_bbox +dict.h: macro AVUTIL_DICT_H +dict.h: macro AV_DICT_APPEND +dict.h: macro AV_DICT_DEDUP +dict.h: macro AV_DICT_DONT_OVERWRITE +dict.h: macro AV_DICT_DONT_STRDUP_KEY +dict.h: macro AV_DICT_DONT_STRDUP_VAL +dict.h: macro AV_DICT_IGNORE_SUFFIX +dict.h: macro AV_DICT_MATCH_CASE +dict.h: macro AV_DICT_MULTIKEY +display.h: macro AVUTIL_DISPLAY_H +dovi_meta.h: macro AVUTIL_DOVI_META_H +dovi_meta.h: macro AV_DOVI_MAX_EXT_BLOCKS +dovi_meta.h: macro AV_DOVI_MAX_PIECES +dovi_meta.h: static-inline av_dovi_get_header +downmix_info.h: macro AVUTIL_DOWNMIX_INFO_H +encryption_info.h: macro AVUTIL_ENCRYPTION_INFO_H +error.h: macro AVERROR +error.h: macro AVERROR_BSF_NOT_FOUND +error.h: macro AVERROR_BUFFER_TOO_SMALL +error.h: macro AVERROR_BUG +error.h: macro AVERROR_BUG2 +error.h: macro AVERROR_DECODER_NOT_FOUND +error.h: macro AVERROR_DEMUXER_NOT_FOUND +error.h: macro AVERROR_ENCODER_NOT_FOUND +error.h: macro AVERROR_EOF +error.h: macro AVERROR_EXIT +error.h: macro AVERROR_EXPERIMENTAL +error.h: macro AVERROR_EXTERNAL +error.h: macro AVERROR_FILTER_NOT_FOUND +error.h: macro AVERROR_HTTP_BAD_REQUEST +error.h: macro AVERROR_HTTP_FORBIDDEN +error.h: macro AVERROR_HTTP_NOT_FOUND +error.h: macro AVERROR_HTTP_OTHER_4XX +error.h: macro AVERROR_HTTP_SERVER_ERROR +error.h: macro AVERROR_HTTP_TOO_MANY_REQUESTS +error.h: macro AVERROR_HTTP_UNAUTHORIZED +error.h: macro AVERROR_INPUT_CHANGED +error.h: macro AVERROR_INVALIDDATA +error.h: macro AVERROR_MUXER_NOT_FOUND +error.h: macro AVERROR_OPTION_NOT_FOUND +error.h: macro AVERROR_OUTPUT_CHANGED +error.h: macro AVERROR_PATCHWELCOME +error.h: macro AVERROR_PROTOCOL_NOT_FOUND +error.h: macro AVERROR_STREAM_NOT_FOUND +error.h: macro AVERROR_UNKNOWN +error.h: macro AVUNERROR +error.h: macro AVUTIL_ERROR_H +error.h: macro AV_ERROR_MAX_STRING_SIZE +error.h: macro FFERRTAG +error.h: macro av_err2str +eval.h: macro AVUTIL_EVAL_H +executor.h: macro AVUTIL_EXECUTOR_H +fifo.h: macro AVUTIL_FIFO_H +fifo.h: macro AV_FIFO_FLAG_AUTO_GROW +file.h: macro AVUTIL_FILE_H +film_grain_params.h: macro AVUTIL_FILM_GRAIN_PARAMS_H +frame.h: macro AVUTIL_FRAME_H +frame.h: macro AV_FRAME_FLAG_CORRUPT +frame.h: macro AV_FRAME_FLAG_DISCARD +frame.h: macro AV_FRAME_FLAG_INTERLACED +frame.h: macro AV_FRAME_FLAG_KEY +frame.h: macro AV_FRAME_FLAG_LOSSLESS +frame.h: macro AV_FRAME_FLAG_TOP_FIELD_FIRST +frame.h: macro AV_FRAME_SIDE_DATA_FLAG_NEW_REF +frame.h: macro AV_FRAME_SIDE_DATA_FLAG_REPLACE +frame.h: macro AV_FRAME_SIDE_DATA_FLAG_UNIQUE +frame.h: macro AV_NUM_DATA_POINTERS +frame.h: macro FF_DECODE_ERROR_CONCEALMENT_ACTIVE +frame.h: macro FF_DECODE_ERROR_DECODE_SLICES +frame.h: macro FF_DECODE_ERROR_INVALID_BITSTREAM +frame.h: macro FF_DECODE_ERROR_MISSING_REFERENCE +frame.h: static-inline av_frame_side_data_get +hash.h: macro AVUTIL_HASH_H +hash.h: macro AV_HASH_MAX_SIZE +hdr_dynamic_metadata.h: macro AVUTIL_HDR_DYNAMIC_METADATA_H +hdr_dynamic_metadata.h: macro AV_HDR_PLUS_MAX_PAYLOAD_SIZE +hdr_dynamic_vivid_metadata.h: macro AVUTIL_HDR_DYNAMIC_VIVID_METADATA_H +hmac.h: macro AVUTIL_HMAC_H +hwcontext.h: macro AVUTIL_HWCONTEXT_H +iamf.h: macro AVUTIL_IAMF_H +iamf.h: macro AV_IAMF_LAYER_FLAG_RECON_GAIN +iamf.h: static-inline av_iamf_param_definition_get_subblock +imgutils.h: macro AVUTIL_IMGUTILS_H +imgutils.h: static-inline av_image_copy2 +intfloat.h: macro AVUTIL_INTFLOAT_H +intreadwrite.h: macro AVUTIL_INTREADWRITE_H +intreadwrite.h: macro AV_COPY +intreadwrite.h: macro AV_COPY128 +intreadwrite.h: macro AV_COPY128U +intreadwrite.h: macro AV_COPY16 +intreadwrite.h: macro AV_COPY16U +intreadwrite.h: macro AV_COPY32 +intreadwrite.h: macro AV_COPY32U +intreadwrite.h: macro AV_COPY64 +intreadwrite.h: macro AV_COPY64U +intreadwrite.h: macro AV_COPYU +intreadwrite.h: macro AV_RB +intreadwrite.h: macro AV_RB16 +intreadwrite.h: macro AV_RB16A +intreadwrite.h: macro AV_RB24 +intreadwrite.h: macro AV_RB32 +intreadwrite.h: macro AV_RB32A +intreadwrite.h: macro AV_RB48 +intreadwrite.h: macro AV_RB64 +intreadwrite.h: macro AV_RB64A +intreadwrite.h: macro AV_RB8 +intreadwrite.h: macro AV_RBA +intreadwrite.h: macro AV_RL +intreadwrite.h: macro AV_RL16 +intreadwrite.h: macro AV_RL16A +intreadwrite.h: macro AV_RL24 +intreadwrite.h: macro AV_RL32 +intreadwrite.h: macro AV_RL32A +intreadwrite.h: macro AV_RL48 +intreadwrite.h: macro AV_RL64 +intreadwrite.h: macro AV_RL64A +intreadwrite.h: macro AV_RL8 +intreadwrite.h: macro AV_RLA +intreadwrite.h: macro AV_RN +intreadwrite.h: macro AV_RN16 +intreadwrite.h: macro AV_RN16A +intreadwrite.h: macro AV_RN24 +intreadwrite.h: macro AV_RN32 +intreadwrite.h: macro AV_RN32A +intreadwrite.h: macro AV_RN48 +intreadwrite.h: macro AV_RN64 +intreadwrite.h: macro AV_RN64A +intreadwrite.h: macro AV_RNA +intreadwrite.h: macro AV_SWAP +intreadwrite.h: macro AV_SWAP64 +intreadwrite.h: macro AV_WB +intreadwrite.h: macro AV_WB16 +intreadwrite.h: macro AV_WB16A +intreadwrite.h: macro AV_WB24 +intreadwrite.h: macro AV_WB32 +intreadwrite.h: macro AV_WB32A +intreadwrite.h: macro AV_WB48 +intreadwrite.h: macro AV_WB64 +intreadwrite.h: macro AV_WB64A +intreadwrite.h: macro AV_WB8 +intreadwrite.h: macro AV_WBA +intreadwrite.h: macro AV_WL +intreadwrite.h: macro AV_WL16 +intreadwrite.h: macro AV_WL16A +intreadwrite.h: macro AV_WL24 +intreadwrite.h: macro AV_WL32 +intreadwrite.h: macro AV_WL32A +intreadwrite.h: macro AV_WL48 +intreadwrite.h: macro AV_WL64 +intreadwrite.h: macro AV_WL64A +intreadwrite.h: macro AV_WL8 +intreadwrite.h: macro AV_WLA +intreadwrite.h: macro AV_WN +intreadwrite.h: macro AV_WN16 +intreadwrite.h: macro AV_WN16A +intreadwrite.h: macro AV_WN24 +intreadwrite.h: macro AV_WN32 +intreadwrite.h: macro AV_WN32A +intreadwrite.h: macro AV_WN48 +intreadwrite.h: macro AV_WN64 +intreadwrite.h: macro AV_WN64A +intreadwrite.h: macro AV_WNA +intreadwrite.h: macro AV_ZERO +intreadwrite.h: macro AV_ZERO128 +intreadwrite.h: macro AV_ZERO16 +intreadwrite.h: macro AV_ZERO32 +intreadwrite.h: macro AV_ZERO64 +lfg.h: macro AVUTIL_LFG_H +lfg.h: static-inline av_lfg_get +log.h: macro AVUTIL_LOG_H +log.h: macro AV_IS_INPUT_DEVICE +log.h: macro AV_IS_OUTPUT_DEVICE +log.h: macro AV_LOG_C +log.h: macro AV_LOG_DEBUG +log.h: macro AV_LOG_ERROR +log.h: macro AV_LOG_FATAL +log.h: macro AV_LOG_INFO +log.h: macro AV_LOG_MAX_OFFSET +log.h: macro AV_LOG_PANIC +log.h: macro AV_LOG_PRINT_DATETIME +log.h: macro AV_LOG_PRINT_LEVEL +log.h: macro AV_LOG_PRINT_TIME +log.h: macro AV_LOG_QUIET +log.h: macro AV_LOG_SKIP_REPEATED +log.h: macro AV_LOG_TRACE +log.h: macro AV_LOG_VERBOSE +log.h: macro AV_LOG_WARNING +lzo.h: macro AVUTIL_LZO_H +lzo.h: macro AV_LZO_ERROR +lzo.h: macro AV_LZO_INPUT_DEPLETED +lzo.h: macro AV_LZO_INPUT_PADDING +lzo.h: macro AV_LZO_INVALID_BACKPTR +lzo.h: macro AV_LZO_OUTPUT_FULL +lzo.h: macro AV_LZO_OUTPUT_PADDING +macros.h: macro AVUTIL_MACROS_H +macros.h: macro AV_GLUE +macros.h: macro AV_JOIN +macros.h: macro AV_NE +macros.h: macro AV_PRAGMA +macros.h: macro AV_STRINGIFY +macros.h: macro AV_TOSTRING +macros.h: macro FFALIGN +macros.h: macro FFDIFFSIGN +macros.h: macro FFMAX +macros.h: macro FFMAX3 +macros.h: macro FFMIN +macros.h: macro FFMIN3 +macros.h: macro FFSWAP +macros.h: macro FF_ARRAY_ELEMS +macros.h: macro MKBETAG +macros.h: macro MKTAG +mastering_display_metadata.h: macro AVUTIL_MASTERING_DISPLAY_METADATA_H +mathematics.h: macro AVUTIL_MATHEMATICS_H +mathematics.h: macro INFINITY +mathematics.h: macro M_1_PI +mathematics.h: macro M_1_PIf +mathematics.h: macro M_2_PI +mathematics.h: macro M_2_PIf +mathematics.h: macro M_2_SQRTPI +mathematics.h: macro M_2_SQRTPIf +mathematics.h: macro M_E +mathematics.h: macro M_Ef +mathematics.h: macro M_LN10 +mathematics.h: macro M_LN10f +mathematics.h: macro M_LN2 +mathematics.h: macro M_LN2f +mathematics.h: macro M_LOG2_10 +mathematics.h: macro M_LOG2_10f +mathematics.h: macro M_PHI +mathematics.h: macro M_PHIf +mathematics.h: macro M_PI +mathematics.h: macro M_PI_2 +mathematics.h: macro M_PI_2f +mathematics.h: macro M_PI_4 +mathematics.h: macro M_PI_4f +mathematics.h: macro M_PIf +mathematics.h: macro M_SQRT1_2 +mathematics.h: macro M_SQRT1_2f +mathematics.h: macro M_SQRT2 +mathematics.h: macro M_SQRT2f +mathematics.h: macro NAN +md5.h: macro AVUTIL_MD5_H +mem.h: macro AVUTIL_MEM_H +mem.h: macro av_alloc_size +mem.h: macro av_malloc_attrib +motion_vector.h: macro AVUTIL_MOTION_VECTOR_H +murmur3.h: macro AVUTIL_MURMUR3_H +opt.h: macro AVUTIL_OPT_H +opt.h: macro AV_OPT_ALLOW_NULL +opt.h: macro AV_OPT_ARRAY_REPLACE +opt.h: macro AV_OPT_FLAG_AUDIO_PARAM +opt.h: macro AV_OPT_FLAG_BSF_PARAM +opt.h: macro AV_OPT_FLAG_CHILD_CONSTS +opt.h: macro AV_OPT_FLAG_DECODING_PARAM +opt.h: macro AV_OPT_FLAG_DEPRECATED +opt.h: macro AV_OPT_FLAG_ENCODING_PARAM +opt.h: macro AV_OPT_FLAG_EXPORT +opt.h: macro AV_OPT_FLAG_FILTERING_PARAM +opt.h: macro AV_OPT_FLAG_READONLY +opt.h: macro AV_OPT_FLAG_RUNTIME_PARAM +opt.h: macro AV_OPT_FLAG_SUBTITLE_PARAM +opt.h: macro AV_OPT_FLAG_VIDEO_PARAM +opt.h: macro AV_OPT_MULTI_COMPONENT_RANGE +opt.h: macro AV_OPT_SEARCH_CHILDREN +opt.h: macro AV_OPT_SEARCH_FAKE_OBJ +opt.h: macro AV_OPT_SERIALIZE_OPT_FLAGS_EXACT +opt.h: macro AV_OPT_SERIALIZE_SEARCH_CHILDREN +opt.h: macro AV_OPT_SERIALIZE_SKIP_DEFAULTS +opt.h: macro av_opt_set_int_list +parseutils.h: macro AVUTIL_PARSEUTILS_H +parseutils.h: macro av_parse_ratio_quiet +pixdesc.h: macro AVUTIL_PIXDESC_H +pixdesc.h: macro AV_PIX_FMT_FLAG_ALPHA +pixdesc.h: macro AV_PIX_FMT_FLAG_BAYER +pixdesc.h: macro AV_PIX_FMT_FLAG_BE +pixdesc.h: macro AV_PIX_FMT_FLAG_BITSTREAM +pixdesc.h: macro AV_PIX_FMT_FLAG_FLOAT +pixdesc.h: macro AV_PIX_FMT_FLAG_HWACCEL +pixdesc.h: macro AV_PIX_FMT_FLAG_PAL +pixdesc.h: macro AV_PIX_FMT_FLAG_PLANAR +pixdesc.h: macro AV_PIX_FMT_FLAG_RGB +pixdesc.h: macro AV_PIX_FMT_FLAG_XYZ +pixdesc.h: macro FF_LOSS_ALPHA +pixdesc.h: macro FF_LOSS_CHROMA +pixdesc.h: macro FF_LOSS_COLORQUANT +pixdesc.h: macro FF_LOSS_COLORSPACE +pixdesc.h: macro FF_LOSS_DEPTH +pixdesc.h: macro FF_LOSS_EXCESS_DEPTH +pixdesc.h: macro FF_LOSS_EXCESS_RESOLUTION +pixdesc.h: macro FF_LOSS_RESOLUTION +pixelutils.h: macro AVUTIL_PIXELUTILS_H +pixfmt.h: macro AVPALETTE_COUNT +pixfmt.h: macro AVPALETTE_SIZE +pixfmt.h: macro AVUTIL_PIXFMT_H +pixfmt.h: macro AV_PIX_FMT_0BGR32 +pixfmt.h: macro AV_PIX_FMT_0RGB32 +pixfmt.h: macro AV_PIX_FMT_AYUV64 +pixfmt.h: macro AV_PIX_FMT_BAYER_BGGR16 +pixfmt.h: macro AV_PIX_FMT_BAYER_GBRG16 +pixfmt.h: macro AV_PIX_FMT_BAYER_GRBG16 +pixfmt.h: macro AV_PIX_FMT_BAYER_RGGB16 +pixfmt.h: macro AV_PIX_FMT_BGR32 +pixfmt.h: macro AV_PIX_FMT_BGR32_1 +pixfmt.h: macro AV_PIX_FMT_BGR444 +pixfmt.h: macro AV_PIX_FMT_BGR48 +pixfmt.h: macro AV_PIX_FMT_BGR555 +pixfmt.h: macro AV_PIX_FMT_BGR565 +pixfmt.h: macro AV_PIX_FMT_BGRA64 +pixfmt.h: macro AV_PIX_FMT_GBRAP10 +pixfmt.h: macro AV_PIX_FMT_GBRAP12 +pixfmt.h: macro AV_PIX_FMT_GBRAP14 +pixfmt.h: macro AV_PIX_FMT_GBRAP16 +pixfmt.h: macro AV_PIX_FMT_GBRAP32 +pixfmt.h: macro AV_PIX_FMT_GBRAPF16 +pixfmt.h: macro AV_PIX_FMT_GBRAPF32 +pixfmt.h: macro AV_PIX_FMT_GBRP10 +pixfmt.h: macro AV_PIX_FMT_GBRP10MSB +pixfmt.h: macro AV_PIX_FMT_GBRP12 +pixfmt.h: macro AV_PIX_FMT_GBRP12MSB +pixfmt.h: macro AV_PIX_FMT_GBRP14 +pixfmt.h: macro AV_PIX_FMT_GBRP16 +pixfmt.h: macro AV_PIX_FMT_GBRP9 +pixfmt.h: macro AV_PIX_FMT_GBRPF16 +pixfmt.h: macro AV_PIX_FMT_GBRPF32 +pixfmt.h: macro AV_PIX_FMT_GRAY10 +pixfmt.h: macro AV_PIX_FMT_GRAY12 +pixfmt.h: macro AV_PIX_FMT_GRAY14 +pixfmt.h: macro AV_PIX_FMT_GRAY16 +pixfmt.h: macro AV_PIX_FMT_GRAY32 +pixfmt.h: macro AV_PIX_FMT_GRAY9 +pixfmt.h: macro AV_PIX_FMT_GRAYF16 +pixfmt.h: macro AV_PIX_FMT_GRAYF32 +pixfmt.h: macro AV_PIX_FMT_NE +pixfmt.h: macro AV_PIX_FMT_NV20 +pixfmt.h: macro AV_PIX_FMT_P010 +pixfmt.h: macro AV_PIX_FMT_P012 +pixfmt.h: macro AV_PIX_FMT_P016 +pixfmt.h: macro AV_PIX_FMT_P210 +pixfmt.h: macro AV_PIX_FMT_P212 +pixfmt.h: macro AV_PIX_FMT_P216 +pixfmt.h: macro AV_PIX_FMT_P410 +pixfmt.h: macro AV_PIX_FMT_P412 +pixfmt.h: macro AV_PIX_FMT_P416 +pixfmt.h: macro AV_PIX_FMT_RGB32 +pixfmt.h: macro AV_PIX_FMT_RGB32_1 +pixfmt.h: macro AV_PIX_FMT_RGB444 +pixfmt.h: macro AV_PIX_FMT_RGB48 +pixfmt.h: macro AV_PIX_FMT_RGB555 +pixfmt.h: macro AV_PIX_FMT_RGB565 +pixfmt.h: macro AV_PIX_FMT_RGB96 +pixfmt.h: macro AV_PIX_FMT_RGBA128 +pixfmt.h: macro AV_PIX_FMT_RGBA64 +pixfmt.h: macro AV_PIX_FMT_RGBAF16 +pixfmt.h: macro AV_PIX_FMT_RGBAF32 +pixfmt.h: macro AV_PIX_FMT_RGBF16 +pixfmt.h: macro AV_PIX_FMT_RGBF32 +pixfmt.h: macro AV_PIX_FMT_V30X +pixfmt.h: macro AV_PIX_FMT_X2BGR10 +pixfmt.h: macro AV_PIX_FMT_X2RGB10 +pixfmt.h: macro AV_PIX_FMT_XV30 +pixfmt.h: macro AV_PIX_FMT_XV36 +pixfmt.h: macro AV_PIX_FMT_XV48 +pixfmt.h: macro AV_PIX_FMT_XYZ12 +pixfmt.h: macro AV_PIX_FMT_Y210 +pixfmt.h: macro AV_PIX_FMT_Y212 +pixfmt.h: macro AV_PIX_FMT_Y216 +pixfmt.h: macro AV_PIX_FMT_YA16 +pixfmt.h: macro AV_PIX_FMT_YAF16 +pixfmt.h: macro AV_PIX_FMT_YAF32 +pixfmt.h: macro AV_PIX_FMT_YUV420P10 +pixfmt.h: macro AV_PIX_FMT_YUV420P12 +pixfmt.h: macro AV_PIX_FMT_YUV420P14 +pixfmt.h: macro AV_PIX_FMT_YUV420P16 +pixfmt.h: macro AV_PIX_FMT_YUV420P9 +pixfmt.h: macro AV_PIX_FMT_YUV422P10 +pixfmt.h: macro AV_PIX_FMT_YUV422P12 +pixfmt.h: macro AV_PIX_FMT_YUV422P14 +pixfmt.h: macro AV_PIX_FMT_YUV422P16 +pixfmt.h: macro AV_PIX_FMT_YUV422P9 +pixfmt.h: macro AV_PIX_FMT_YUV440P10 +pixfmt.h: macro AV_PIX_FMT_YUV440P12 +pixfmt.h: macro AV_PIX_FMT_YUV444P10 +pixfmt.h: macro AV_PIX_FMT_YUV444P10MSB +pixfmt.h: macro AV_PIX_FMT_YUV444P12 +pixfmt.h: macro AV_PIX_FMT_YUV444P12MSB +pixfmt.h: macro AV_PIX_FMT_YUV444P14 +pixfmt.h: macro AV_PIX_FMT_YUV444P16 +pixfmt.h: macro AV_PIX_FMT_YUV444P9 +pixfmt.h: macro AV_PIX_FMT_YUVA420P10 +pixfmt.h: macro AV_PIX_FMT_YUVA420P16 +pixfmt.h: macro AV_PIX_FMT_YUVA420P9 +pixfmt.h: macro AV_PIX_FMT_YUVA422P10 +pixfmt.h: macro AV_PIX_FMT_YUVA422P12 +pixfmt.h: macro AV_PIX_FMT_YUVA422P16 +pixfmt.h: macro AV_PIX_FMT_YUVA422P9 +pixfmt.h: macro AV_PIX_FMT_YUVA444P10 +pixfmt.h: macro AV_PIX_FMT_YUVA444P12 +pixfmt.h: macro AV_PIX_FMT_YUVA444P16 +pixfmt.h: macro AV_PIX_FMT_YUVA444P9 +pixfmt.h: macro AV_VIDEO_MAX_PLANES +random_seed.h: macro AVUTIL_RANDOM_SEED_H +rational.h: macro AVUTIL_RATIONAL_H +rational.h: static-inline av_inv_q +rational.h: static-inline av_make_q +rc4.h: macro AVUTIL_RC4_H +refstruct.h: macro AVUTIL_REFSTRUCT_H +refstruct.h: macro AV_REFSTRUCT_FLAG_NO_ZEROING +refstruct.h: macro AV_REFSTRUCT_POOL_FLAG_FREE_ON_INIT_ERROR +refstruct.h: macro AV_REFSTRUCT_POOL_FLAG_NO_ZEROING +refstruct.h: macro AV_REFSTRUCT_POOL_FLAG_RESET_ON_INIT_ERROR +refstruct.h: macro AV_REFSTRUCT_POOL_FLAG_ZERO_EVERY_TIME +refstruct.h: static-inline av_refstruct_alloc_ext +refstruct.h: static-inline av_refstruct_pool_alloc_ext +replaygain.h: macro AVUTIL_REPLAYGAIN_H +ripemd.h: macro AVUTIL_RIPEMD_H +samplefmt.h: macro AVUTIL_SAMPLEFMT_H +sha.h: macro AVUTIL_SHA_H +sha512.h: macro AVUTIL_SHA512_H +spherical.h: macro AVUTIL_SPHERICAL_H +stereo3d.h: macro AVUTIL_STEREO3D_H +stereo3d.h: macro AV_STEREO3D_FLAG_INVERT +tdrdi.h: macro AVUTIL_TDRDI_H +tdrdi.h: macro AV_TDRDI_MAX_NUM_REF_DISPLAY +tdrdi.h: static-inline av_tdrdi_get_display +tea.h: macro AVUTIL_TEA_H +threadmessage.h: macro AVUTIL_THREADMESSAGE_H +time.h: macro AVUTIL_TIME_H +timecode.h: macro AVUTIL_TIMECODE_H +timecode.h: macro AV_TIMECODE_STR_SIZE +timestamp.h: macro AVUTIL_TIMESTAMP_H +timestamp.h: macro AV_TS_MAX_STRING_SIZE +timestamp.h: macro av_ts2str +timestamp.h: macro av_ts2timestr +timestamp.h: static-inline av_ts_make_string +tree.h: macro AVUTIL_TREE_H +twofish.h: macro AVUTIL_TWOFISH_H +tx.h: macro AVUTIL_TX_H +uuid.h: macro AVUTIL_UUID_H +uuid.h: macro AV_PRI_URN_UUID +uuid.h: macro AV_PRI_UUID +uuid.h: macro AV_UUID_ARG +uuid.h: macro AV_UUID_LEN +version.h: macro AVUTIL_VERSION_H +version.h: macro AV_VERSION +version.h: macro AV_VERSION_DOT +version.h: macro AV_VERSION_INT +version.h: macro AV_VERSION_MAJOR +version.h: macro AV_VERSION_MICRO +version.h: macro AV_VERSION_MINOR +version.h: macro FF_API_ASSERT_FPU +version.h: macro FF_API_CPU_FLAG_FORCE +version.h: macro FF_API_DOVI_L11_INVALID_PROPS +version.h: macro FF_API_MOD_UINTP2 +version.h: macro FF_API_OPT_INT_LIST +version.h: macro FF_API_OPT_PTR +version.h: macro FF_API_RISCV_FD_ZBA +version.h: macro FF_API_VULKAN_FIXED_QUEUES +version.h: macro FF_API_VULKAN_SYNC_QUEUES +version.h: macro LIBAVUTIL_BUILD +version.h: macro LIBAVUTIL_IDENT +version.h: macro LIBAVUTIL_VERSION +version.h: macro LIBAVUTIL_VERSION_INT +version.h: macro LIBAVUTIL_VERSION_MAJOR +version.h: macro LIBAVUTIL_VERSION_MICRO +version.h: macro LIBAVUTIL_VERSION_MINOR +video_enc_params.h: macro AVUTIL_VIDEO_ENC_PARAMS_H +video_enc_params.h: static-inline av_video_enc_params_block +video_hint.h: macro AVUTIL_VIDEO_HINT_H +video_hint.h: static-inline av_video_hint_rects +xtea.h: macro AVUTIL_XTEA_H diff --git a/src/gen_exports/swresample.inc b/src/gen_exports/swresample.inc new file mode 100644 index 0000000..97d7993 --- /dev/null +++ b/src/gen_exports/swresample.inc @@ -0,0 +1,54 @@ +// Auto-generated by tools/gen_exports.py from libswresample +// public headers (3 files) — do not edit by hand. + +// structs (1) +export using ::SwrContext; + +// enums (3) +export using ::SwrDitherType; +export using ::SwrEngine; +export using ::SwrFilterType; + +// enumerators (19) +export using ::SWR_DITHER_NB; +export using ::SWR_DITHER_NONE; +export using ::SWR_DITHER_NS; +export using ::SWR_DITHER_NS_F_WEIGHTED; +export using ::SWR_DITHER_NS_HIGH_SHIBATA; +export using ::SWR_DITHER_NS_IMPROVED_E_WEIGHTED; +export using ::SWR_DITHER_NS_LIPSHITZ; +export using ::SWR_DITHER_NS_LOW_SHIBATA; +export using ::SWR_DITHER_NS_MODIFIED_E_WEIGHTED; +export using ::SWR_DITHER_NS_SHIBATA; +export using ::SWR_DITHER_RECTANGULAR; +export using ::SWR_DITHER_TRIANGULAR; +export using ::SWR_DITHER_TRIANGULAR_HIGHPASS; +export using ::SWR_ENGINE_NB; +export using ::SWR_ENGINE_SOXR; +export using ::SWR_ENGINE_SWR; +export using ::SWR_FILTER_TYPE_BLACKMAN_NUTTALL; +export using ::SWR_FILTER_TYPE_CUBIC; +export using ::SWR_FILTER_TYPE_KAISER; + +// functions (21) +export using ::swr_alloc_set_opts2; +export using ::swr_build_matrix2; +export using ::swr_close; +export using ::swr_config_frame; +export using ::swr_convert; +export using ::swr_convert_frame; +export using ::swr_drop_output; +export using ::swr_free; +export using ::swr_get_class; +export using ::swr_get_delay; +export using ::swr_get_out_samples; +export using ::swr_init; +export using ::swr_inject_silence; +export using ::swr_is_initialized; +export using ::swr_next_pts; +export using ::swr_set_channel_mapping; +export using ::swr_set_compensation; +export using ::swr_set_matrix; +export using ::swresample_configuration; +export using ::swresample_license; +export using ::swresample_version; diff --git a/src/gen_exports/swresample.includes.inc b/src/gen_exports/swresample.includes.inc new file mode 100644 index 0000000..61af048 --- /dev/null +++ b/src/gen_exports/swresample.includes.inc @@ -0,0 +1,5 @@ +// Auto-generated by tools/gen_exports.py — installed public headers of libswresample. + +#include +#include +#include diff --git a/src/gen_exports/swresample.skipped.txt b/src/gen_exports/swresample.skipped.txt new file mode 100644 index 0000000..3070776 --- /dev/null +++ b/src/gen_exports/swresample.skipped.txt @@ -0,0 +1,11 @@ +swresample.h: macro SWRESAMPLE_SWRESAMPLE_H +swresample.h: macro SWR_FLAG_RESAMPLE +version.h: macro LIBSWRESAMPLE_BUILD +version.h: macro LIBSWRESAMPLE_IDENT +version.h: macro LIBSWRESAMPLE_VERSION +version.h: macro LIBSWRESAMPLE_VERSION_INT +version.h: macro LIBSWRESAMPLE_VERSION_MICRO +version.h: macro LIBSWRESAMPLE_VERSION_MINOR +version.h: macro SWRESAMPLE_VERSION_H +version_major.h: macro LIBSWRESAMPLE_VERSION_MAJOR +version_major.h: macro SWRESAMPLE_VERSION_MAJOR_H diff --git a/src/gen_exports/swscale.inc b/src/gen_exports/swscale.inc new file mode 100644 index 0000000..9ce1036 --- /dev/null +++ b/src/gen_exports/swscale.inc @@ -0,0 +1,95 @@ +// Auto-generated by tools/gen_exports.py from libswscale +// public headers (3 files) — do not edit by hand. + +// structs (3) +export using ::SwsContext; +export using ::SwsFilter; +export using ::SwsVector; + +// enums (4) +export using ::SwsAlphaBlend; +export using ::SwsDither; +export using ::SwsFlags; +export using ::SwsIntent; + +// enumerators (38) +export using ::SWS_ACCURATE_RND; +export using ::SWS_ALPHA_BLEND_CHECKERBOARD; +export using ::SWS_ALPHA_BLEND_MAX_ENUM; +export using ::SWS_ALPHA_BLEND_NB; +export using ::SWS_ALPHA_BLEND_NONE; +export using ::SWS_ALPHA_BLEND_UNIFORM; +export using ::SWS_AREA; +export using ::SWS_BICUBIC; +export using ::SWS_BICUBLIN; +export using ::SWS_BILINEAR; +export using ::SWS_BITEXACT; +export using ::SWS_DIRECT_BGR; +export using ::SWS_DITHER_AUTO; +export using ::SWS_DITHER_A_DITHER; +export using ::SWS_DITHER_BAYER; +export using ::SWS_DITHER_ED; +export using ::SWS_DITHER_MAX_ENUM; +export using ::SWS_DITHER_NB; +export using ::SWS_DITHER_NONE; +export using ::SWS_DITHER_X_DITHER; +export using ::SWS_ERROR_DIFFUSION; +export using ::SWS_FAST_BILINEAR; +export using ::SWS_FULL_CHR_H_INP; +export using ::SWS_FULL_CHR_H_INT; +export using ::SWS_GAUSS; +export using ::SWS_INTENT_ABSOLUTE_COLORIMETRIC; +export using ::SWS_INTENT_NB; +export using ::SWS_INTENT_PERCEPTUAL; +export using ::SWS_INTENT_RELATIVE_COLORIMETRIC; +export using ::SWS_INTENT_SATURATION; +export using ::SWS_LANCZOS; +export using ::SWS_POINT; +export using ::SWS_PRINT_INFO; +export using ::SWS_SINC; +export using ::SWS_SPLINE; +export using ::SWS_STRICT; +export using ::SWS_UNSTABLE; +export using ::SWS_X; + +// functions (40) +export using ::sws_allocVec; +export using ::sws_alloc_context; +export using ::sws_convertPalette8ToPacked24; +export using ::sws_convertPalette8ToPacked32; +export using ::sws_frame_end; +export using ::sws_frame_setup; +export using ::sws_frame_start; +export using ::sws_freeContext; +export using ::sws_freeFilter; +export using ::sws_freeVec; +export using ::sws_free_context; +export using ::sws_getCachedContext; +export using ::sws_getCoefficients; +export using ::sws_getColorspaceDetails; +export using ::sws_getContext; +export using ::sws_getDefaultFilter; +export using ::sws_getGaussianVec; +export using ::sws_get_class; +export using ::sws_init_context; +export using ::sws_isSupportedEndiannessConversion; +export using ::sws_isSupportedInput; +export using ::sws_isSupportedOutput; +export using ::sws_is_noop; +export using ::sws_normalizeVec; +export using ::sws_receive_slice; +export using ::sws_receive_slice_alignment; +export using ::sws_scale; +export using ::sws_scaleVec; +export using ::sws_scale_frame; +export using ::sws_send_slice; +export using ::sws_setColorspaceDetails; +export using ::sws_test_colorspace; +export using ::sws_test_format; +export using ::sws_test_frame; +export using ::sws_test_hw_format; +export using ::sws_test_primaries; +export using ::sws_test_transfer; +export using ::swscale_configuration; +export using ::swscale_license; +export using ::swscale_version; diff --git a/src/gen_exports/swscale.includes.inc b/src/gen_exports/swscale.includes.inc new file mode 100644 index 0000000..92dff26 --- /dev/null +++ b/src/gen_exports/swscale.includes.inc @@ -0,0 +1,5 @@ +// Auto-generated by tools/gen_exports.py — installed public headers of libswscale. + +#include +#include +#include diff --git a/src/gen_exports/swscale.skipped.txt b/src/gen_exports/swscale.skipped.txt new file mode 100644 index 0000000..3e2a3bb --- /dev/null +++ b/src/gen_exports/swscale.skipped.txt @@ -0,0 +1,22 @@ +swscale.h: macro SWSCALE_SWSCALE_H +swscale.h: macro SWS_CS_BT2020 +swscale.h: macro SWS_CS_DEFAULT +swscale.h: macro SWS_CS_FCC +swscale.h: macro SWS_CS_ITU601 +swscale.h: macro SWS_CS_ITU624 +swscale.h: macro SWS_CS_ITU709 +swscale.h: macro SWS_CS_SMPTE170M +swscale.h: macro SWS_CS_SMPTE240M +swscale.h: macro SWS_MAX_REDUCE_CUTOFF +swscale.h: macro SWS_PARAM_DEFAULT +swscale.h: macro SWS_SRC_V_CHR_DROP_MASK +swscale.h: macro SWS_SRC_V_CHR_DROP_SHIFT +version.h: macro LIBSWSCALE_BUILD +version.h: macro LIBSWSCALE_IDENT +version.h: macro LIBSWSCALE_VERSION +version.h: macro LIBSWSCALE_VERSION_INT +version.h: macro LIBSWSCALE_VERSION_MICRO +version.h: macro LIBSWSCALE_VERSION_MINOR +version.h: macro SWSCALE_VERSION_H +version_major.h: macro LIBSWSCALE_VERSION_MAJOR +version_major.h: macro SWSCALE_VERSION_MAJOR_H diff --git a/src/swresample.cppm b/src/swresample.cppm new file mode 100644 index 0000000..d71f7d9 --- /dev/null +++ b/src/swresample.cppm @@ -0,0 +1,12 @@ +// ffmpeg.swresample — libswresample re-exported as a C++ module (C API unchanged). +module; + +extern "C" { +#include "gen_exports/swresample.includes.inc" +} + +export module ffmpeg.swresample; + +export import ffmpeg.avutil; + +#include "gen_exports/swresample.inc" diff --git a/src/swscale.cppm b/src/swscale.cppm new file mode 100644 index 0000000..f342278 --- /dev/null +++ b/src/swscale.cppm @@ -0,0 +1,12 @@ +// ffmpeg.swscale — libswscale re-exported as a C++ module (C API unchanged). +module; + +extern "C" { +#include "gen_exports/swscale.includes.inc" +} + +export module ffmpeg.swscale; + +export import ffmpeg.avutil; + +#include "gen_exports/swscale.inc" diff --git a/templates/decode/mcpp.toml.in b/templates/decode/mcpp.toml.in new file mode 100644 index 0000000..ba6c3dd --- /dev/null +++ b/templates/decode/mcpp.toml.in @@ -0,0 +1,6 @@ +[package] +name = "{{project.name}}" +version = "0.1.0" + +[dependencies] +{{self.name}} = "{{self.version}}" diff --git a/templates/decode/src/main.cpp.in b/templates/decode/src/main.cpp.in new file mode 100644 index 0000000..327f2f8 --- /dev/null +++ b/templates/decode/src/main.cpp.in @@ -0,0 +1,42 @@ +// Decode every video frame of the given file — plain FFmpeg C API, no headers. +import std; +import ffmpeg.av; + +int main(int argc, char** argv) { + if (argc < 2) { + std::println("usage: {} ", argv[0]); + return 64; + } + + AVFormatContext* fmt { nullptr }; + if (avformat_open_input(&fmt, argv[1], nullptr, nullptr) < 0) { + std::println("cannot open {}", argv[1]); + return 1; + } + avformat_find_stream_info(fmt, nullptr); + + int video { av_find_best_stream(fmt, AVMEDIA_TYPE_VIDEO, -1, -1, nullptr, 0) }; + const AVCodec* codec { avcodec_find_decoder(fmt->streams[video]->codecpar->codec_id) }; + AVCodecContext* dec { avcodec_alloc_context3(codec) }; + avcodec_parameters_to_context(dec, fmt->streams[video]->codecpar); + avcodec_open2(dec, codec, nullptr); + + AVPacket* packet { av_packet_alloc() }; + AVFrame* frame { av_frame_alloc() }; + long frames { 0 }; + while (av_read_frame(fmt, packet) >= 0) { + if (packet->stream_index == video && avcodec_send_packet(dec, packet) >= 0) + while (avcodec_receive_frame(dec, frame) >= 0) ++frames; + av_packet_unref(packet); + } + avcodec_send_packet(dec, nullptr); + while (avcodec_receive_frame(dec, frame) >= 0) ++frames; + + std::println("{}: {} ({}x{}), {} frames decoded", + argv[1], codec->name, dec->width, dec->height, frames); + + av_frame_free(&frame); + av_packet_free(&packet); + avcodec_free_context(&dec); + avformat_close_input(&fmt); +} diff --git a/templates/decode/template.toml b/templates/decode/template.toml new file mode 100644 index 0000000..6de44e0 --- /dev/null +++ b/templates/decode/template.toml @@ -0,0 +1,4 @@ +[template] +description = "Decode a video file's frames with import ffmpeg.av" +default = true +post_message = "cd into the project and run `mcpp run -- `." diff --git a/tests/api_surface_test.cpp b/tests/api_surface_test.cpp new file mode 100644 index 0000000..bef6497 --- /dev/null +++ b/tests/api_surface_test.cpp @@ -0,0 +1,50 @@ +// API-surface smoke tests: the imported module layer must expose the C API +// unchanged (names, enums, versions), and the optional macros side header +// must coexist with the import in one TU. +#include + +#include +#include + +// Canonical mixing order: textual includes BEFORE the import (the reverse is +// compiler-hostile territory across the ecosystem). +#include + +import ffmpeg.av; + +TEST(ApiSurface, VersionsMatchVendoredRelease) { + EXPECT_EQ(avutil_version() >> 16, 60u); // n8.1.x: libavutil major 60 + EXPECT_EQ(avcodec_version() >> 16, 62u); + EXPECT_EQ(avformat_version() >> 16, 62u); +} + +TEST(ApiSurface, FullDecoderSetIsPresent) { + EXPECT_NE(avcodec_find_decoder(AV_CODEC_ID_H264), nullptr); + EXPECT_NE(avcodec_find_decoder(AV_CODEC_ID_HEVC), nullptr); + EXPECT_NE(avcodec_find_decoder(AV_CODEC_ID_AV1), nullptr); + EXPECT_NE(avcodec_find_decoder(AV_CODEC_ID_VP9), nullptr); + EXPECT_NE(avcodec_find_decoder(AV_CODEC_ID_AAC), nullptr); + EXPECT_NE(avcodec_find_decoder(AV_CODEC_ID_OPUS), nullptr); + EXPECT_NE(avcodec_find_decoder(AV_CODEC_ID_FLAC), nullptr); +} + +TEST(ApiSurface, EnumsAndTypesAreUsable) { + AVRational half { 1, 2 }; + EXPECT_EQ(half.num, 1); + AVMediaType type { AVMEDIA_TYPE_VIDEO }; + EXPECT_EQ(type, AVMEDIA_TYPE_VIDEO); + AVPixelFormat fmt { AV_PIX_FMT_YUV420P }; + EXPECT_EQ(av_get_pix_fmt_name(fmt), std::string_view { "yuv420p" }); +} + +TEST(ApiSurface, MacroSideHeaderCoexistsWithImport) { + EXPECT_LT(AVERROR(EAGAIN), 0); // function-like macro + EXPECT_EQ(AV_NOPTS_VALUE, AV_NOPTS); // macro vs module constant + EXPECT_DOUBLE_EQ(av_q2d(AVRational { 1, 4 }), 0.25); // static-inline helper + EXPECT_EQ(AV_TIME_BASE_Q.num, av_time_base_q().num); +} + +TEST(ApiSurface, ErrorStringReplacementWorks) { + auto text = av_err2string(AVERROR(ENOENT)); + EXPECT_GT(std::string_view { text.c_str() }.size(), 0u); +} diff --git a/tests/roundtrip_test.cpp b/tests/roundtrip_test.cpp new file mode 100644 index 0000000..7c03743 --- /dev/null +++ b/tests/roundtrip_test.cpp @@ -0,0 +1,164 @@ +// End-to-end proof that the module layer drives real FFmpeg: encode a small +// MJPEG/Matroska clip through the imported API, then demux + decode it back +// and verify the frames. No external sample files needed. +// +// (Matroska, not MOV: the mov demuxer drops the final sample of this +// synthetic clip — an upstream container quirk unrelated to the module +// layer; mkv round-trips all frames.) +#include + +#include +#include +#include + +#include + +import ffmpeg.av; + +namespace { + +constexpr int WIDTH { 64 }; +constexpr int HEIGHT { 64 }; +constexpr int FRAMES { 5 }; + +std::string test_file_path() { + return "target/roundtrip_test.mkv"; +} + +// Frame i is a diagonal luma gradient x+y+16*i (no wraparound for i < 8), +// so its mean luma is exactly 63 + 16*i. Chroma is neutral. +void fill_frame(AVFrame* frame, int index) { + for (int y { 0 }; y < HEIGHT; ++y) + for (int x { 0 }; x < WIDTH; ++x) + frame->data[0][y * frame->linesize[0] + x] = + static_cast(x + y + index * 16); + for (int y { 0 }; y < HEIGHT / 2; ++y) + for (int x { 0 }; x < WIDTH / 2; ++x) { + frame->data[1][y * frame->linesize[1] + x] = 128; + frame->data[2][y * frame->linesize[2] + x] = 128; + } +} + +double expected_mean(int index) { + return 63.0 + 16.0 * index; +} + +void encode_clip(const std::string& path) { + const AVCodec* codec { avcodec_find_encoder_by_name("mjpeg") }; + ASSERT_NE(codec, nullptr); + + AVFormatContext* fmt { nullptr }; + ASSERT_GE(avformat_alloc_output_context2(&fmt, nullptr, "matroska", path.c_str()), 0); + + AVCodecContext* enc { avcodec_alloc_context3(codec) }; + enc->width = WIDTH; + enc->height = HEIGHT; + enc->pix_fmt = AV_PIX_FMT_YUVJ420P; + enc->time_base = AVRational { 1, 25 }; + enc->color_range = AVCOL_RANGE_JPEG; + ASSERT_GE(avcodec_open2(enc, codec, nullptr), 0); + + AVStream* stream { avformat_new_stream(fmt, nullptr) }; + stream->time_base = enc->time_base; + ASSERT_GE(avcodec_parameters_from_context(stream->codecpar, enc), 0); + + ASSERT_GE(avio_open(&fmt->pb, path.c_str(), AVIO_FLAG_WRITE), 0); + ASSERT_GE(avformat_write_header(fmt, nullptr), 0); + + AVFrame* frame { av_frame_alloc() }; + frame->format = enc->pix_fmt; + frame->width = WIDTH; + frame->height = HEIGHT; + ASSERT_GE(av_frame_get_buffer(frame, 0), 0); + + AVPacket* packet { av_packet_alloc() }; + int written { 0 }; + for (int i { 0 }; i <= FRAMES; ++i) { + if (i < FRAMES) { + ASSERT_GE(av_frame_make_writable(frame), 0); + fill_frame(frame, i); + frame->pts = i; + frame->duration = 1; + ASSERT_GE(avcodec_send_frame(enc, frame), 0); + } else { + ASSERT_GE(avcodec_send_frame(enc, nullptr), 0); // flush + } + while (avcodec_receive_packet(enc, packet) >= 0) { + av_packet_rescale_ts(packet, enc->time_base, stream->time_base); + ++written; + ASSERT_GE(av_interleaved_write_frame(fmt, packet), 0); + } + } + EXPECT_EQ(written, FRAMES); + ASSERT_GE(av_write_trailer(fmt), 0); + + av_packet_free(&packet); + av_frame_free(&frame); + avcodec_free_context(&enc); + avio_closep(&fmt->pb); + avformat_free_context(fmt); +} + +} // namespace + +TEST(Roundtrip, EncodeThenDecode) { + const std::string path { test_file_path() }; + encode_clip(path); + + AVFormatContext* fmt { nullptr }; + ASSERT_EQ(avformat_open_input(&fmt, path.c_str(), nullptr, nullptr), 0); + ASSERT_GE(avformat_find_stream_info(fmt, nullptr), 0); + + int streamIndex { av_find_best_stream(fmt, AVMEDIA_TYPE_VIDEO, -1, -1, nullptr, 0) }; + ASSERT_GE(streamIndex, 0); + EXPECT_EQ(fmt->streams[streamIndex]->codecpar->codec_id, AV_CODEC_ID_MJPEG); + + const AVCodec* codec { + avcodec_find_decoder(fmt->streams[streamIndex]->codecpar->codec_id) }; + ASSERT_NE(codec, nullptr); + + AVCodecContext* dec { avcodec_alloc_context3(codec) }; + ASSERT_GE(avcodec_parameters_to_context(dec, fmt->streams[streamIndex]->codecpar), 0); + ASSERT_GE(avcodec_open2(dec, codec, nullptr), 0); + + AVPacket* packet { av_packet_alloc() }; + AVFrame* frame { av_frame_alloc() }; + int decoded { 0 }; + auto drain = [&] { + while (avcodec_receive_frame(dec, frame) >= 0) { + EXPECT_EQ(frame->width, WIDTH); + EXPECT_EQ(frame->height, HEIGHT); + std::int64_t sum { 0 }; + for (int y { 0 }; y < HEIGHT; ++y) + for (int x { 0 }; x < WIDTH; ++x) + sum += frame->data[0][y * frame->linesize[0] + x]; + double mean { static_cast(sum) / (WIDTH * HEIGHT) }; + EXPECT_NEAR(mean, expected_mean(decoded), 3.0); // MJPEG is lossy + ++decoded; + } + }; + while (av_read_frame(fmt, packet) >= 0) { + if (packet->stream_index == streamIndex) { + ASSERT_GE(avcodec_send_packet(dec, packet), 0); + drain(); + } + av_packet_unref(packet); + } + avcodec_send_packet(dec, nullptr); // flush + drain(); + EXPECT_EQ(decoded, FRAMES); + + av_frame_free(&frame); + av_packet_free(&packet); + avcodec_free_context(&dec); + avformat_close_input(&fmt); + std::remove(test_file_path().c_str()); +} + +TEST(Roundtrip, SwscaleConvertsFrame) { + SwsContext* sws { sws_getContext(WIDTH, HEIGHT, AV_PIX_FMT_YUV420P, + WIDTH / 2, HEIGHT / 2, AV_PIX_FMT_RGB24, + SWS_BILINEAR, nullptr, nullptr, nullptr) }; + ASSERT_NE(sws, nullptr); + sws_freeContext(sws); +} diff --git a/tools/fetch_upstream.sh b/tools/fetch_upstream.sh new file mode 100755 index 0000000..4f77882 --- /dev/null +++ b/tools/fetch_upstream.sh @@ -0,0 +1,23 @@ +#!/bin/sh +# fetch_upstream.sh — download + extract the pinned official FFmpeg tarball +# for maintainer-time regeneration of the export lists (gen_exports.py). +# Consumers never need this: they get FFmpeg via the compat.ffmpeg package. +# +# Prints the extracted source root on stdout. +set -eu + +version="${FFMPEG_VERSION:-8.1.2}" +sha256="${FFMPEG_SHA256:-32faba5ef67340d54724941eae1425580791195312a4fd13bf6f820a2818bf22}" +cache="${XDG_CACHE_HOME:-$HOME/.cache}/ffmpeg-m" +tarball="$cache/ffmpeg-$version.tar.gz" +srcdir="$cache/ffmpeg-$version" + +mkdir -p "$cache" +if [ ! -f "$tarball" ]; then + curl -L -fsS -o "$tarball" "https://ffmpeg.org/releases/ffmpeg-$version.tar.gz" >&2 +fi +echo "$sha256 $tarball" | sha256sum -c - >&2 +if [ ! -d "$srcdir" ]; then + tar -xzf "$tarball" -C "$cache" +fi +echo "$srcdir" diff --git a/tools/gen_exports.py b/tools/gen_exports.py new file mode 100644 index 0000000..76e20f3 --- /dev/null +++ b/tools/gen_exports.py @@ -0,0 +1,229 @@ +#!/usr/bin/env python3 +"""gen_exports.py — generate `export using ::name;` lists from FFmpeg headers. + +For each library, the INSTALLED public headers (the `HEADERS` block in the +lib's Makefile) are scanned and every re-exportable name is emitted into +src/gen_exports/.inc, which the matching src/.cppm textually +includes inside its module purview. Categories: + + exported — non-inline API functions, struct/union tags, typedefs, enum + tags, enumerators (all have linkage / are types → valid + targets for an exported using-declaration per + [module.interface]/5; enumerator re-export verified on GCC 16) + skipped — `static inline` helpers (internal linkage — not exportable; + reachable via include/ffmpeg-m/macros.h textual include) and + object-like/function-like macros (never exportable) + +The skip list is written to src/gen_exports/.skipped.txt so the macros.h +curation stays reviewable. + +Usage: gen_exports.py [ffmpeg-root] (default: pinned official tarball + via tools/fetch_upstream.sh) +""" + +import re +import sys +from pathlib import Path + +LIBS = { + "avutil": "libavutil", + "avcodec": "libavcodec", + "avformat": "libavformat", + "avfilter": "libavfilter", + "avdevice": "libavdevice", + "swscale": "libswscale", + "swresample": "libswresample", +} + +# Public-symbol families; anything else in a header is infrastructure. +NAME_RE = re.compile(r"^(?:av|sws|swr)[a-z0-9_]*$", re.IGNORECASE) +IDENT = r"[A-Za-z_][A-Za-z0-9_]*" + +# Installed headers that require external SDK headers (CUDA, VAAPI, D3D, …). +# FFmpeg installs them unconditionally, but they cannot be compiled in the +# hermetic profile and their APIs are unusable without the SDK anyway. +# Consumers with the SDK can textually #include them next to the import. +EXCLUDED_HEADER = re.compile( + r"^hwcontext_(?!$).+\.h$|^(vdpau|qsv|videotoolbox|dxva2|d3d11va|d3d12va" + r"|mediacodec|jni|xvmc|vulkan|vulkan_functions|vorbis_parser)\.h$") + + +def installed_headers(lib_dir: Path) -> list[Path]: + text = (lib_dir / "Makefile").read_text() + match = re.search(r"^HEADERS\s*=((?:[^\n]*\\\n)*[^\n]*)", text, re.M) + if not match: + return [] + names = match.group(1).replace("\\\n", " ").split() + return [lib_dir / n for n in names + if (lib_dir / n).exists() and not EXCLUDED_HEADER.match(n)] + + +def strip_comments(src: str) -> str: + src = re.sub(r"/\*.*?\*/", " ", src, flags=re.S) + return re.sub(r"//[^\n]*", " ", src) + + +def strip_preprocessor(src: str) -> tuple[str, list[str]]: + """Remove preprocessor lines; return (code, macro names defined).""" + macros: list[str] = [] + kept: list[str] = [] + for line in src.replace("\\\n", " ").split("\n"): + stripped = line.lstrip() + if stripped.startswith("#"): + m = re.match(r"#\s*define\s+(" + IDENT + ")", stripped) + if m: + macros.append(m.group(1)) + else: + kept.append(line) + return "\n".join(kept), macros + + +def top_level_statements(code: str): + """Yield (statement, had_body) at brace depth 0.""" + depth = 0 + buf: list[str] = [] + had_body = False + for ch in code: + buf.append(ch) + if ch == "{": + depth += 1 + had_body = True + elif ch == "}": + depth -= 1 + elif ch == ";" and depth == 0: + yield "".join(buf).strip(), had_body + buf, had_body = [], False + + +def parse_header(path: Path): + exported: dict[str, str] = {} # name -> kind + skipped: list[str] = [] + + raw = strip_comments(path.read_text(errors="replace")) + code, macros = strip_preprocessor(raw) + skipped += [f"macro {m}" for m in macros] + + for stmt, had_body in top_level_statements(code): + flat = " ".join(stmt.split()) + if not flat or flat.startswith("extern \"C\""): + continue + + # -- enums: tag + enumerators ------------------------------------ + m = re.match(r"(?:typedef\s+)?enum\s+(" + IDENT + r")?\s*{(.*)}\s*(" + IDENT + r")?\s*;$", + flat, re.S) + if m: + tag, body, alias = m.group(1), m.group(2), m.group(3) + for name in (tag, alias): + if name: + exported[name] = "enum" + for entry in body.split(","): + em = re.match(r"\s*(" + IDENT + ")", entry) + if em and not em.group(1).startswith("__"): + exported[em.group(1)] = "enumerator" + continue + + # -- typedefs ---------------------------------------------------- + if flat.startswith("typedef"): + # Function-pointer typedef — but only when there is no braced body: + # a struct typedef whose FIELDS are function pointers must fall + # through to the alias branch (`} AVCodecContext;`). + fp = re.search(r"\(\s*\*\s*(" + IDENT + r")\s*\)", flat) + if fp and not had_body: + exported[fp.group(1)] = "typedef" + continue + m = re.search(r"(" + IDENT + r")\s*(?:\[[^\]]*\]\s*)?;$", flat) + if m: + exported[m.group(1)] = "typedef" + tag = re.match(r"typedef\s+(?:struct|union)\s+(" + IDENT + ")", flat) + if tag: + exported[tag.group(1)] = "struct" + continue + + # -- bare struct/union definitions or forward declarations ------- + m = re.match(r"(?:struct|union)\s+(" + IDENT + ")", flat) + if m and (had_body or flat.endswith(";")): + exported[m.group(1)] = "struct" + continue + + # -- functions --------------------------------------------------- + if "(" in flat and not had_body: + m = re.search(r"\b(" + IDENT + r")\s*\(", flat) + if m: + name = m.group(1) + if re.search(r"\bstatic\b", flat.split("(")[0]): + skipped.append(f"static-inline {name}") + elif NAME_RE.match(name): + exported[name] = "function" + continue + if "(" in flat and had_body: # static inline definition + m = re.search(r"\b(" + IDENT + r")\s*\(", flat.split("{")[0]) + if m: + skipped.append(f"static-inline {m.group(1)}") + + # Only surface public-family names. + exported = {n: k for n, k in exported.items() + if NAME_RE.match(n) or n.startswith(("AV", "Sws", "Swr", "FF"))} + return exported, skipped + + +def main() -> None: + if len(sys.argv) > 1: + root = Path(sys.argv[1]) + else: + import subprocess + fetch = Path(__file__).resolve().parent / "fetch_upstream.sh" + root = Path(subprocess.check_output(["sh", str(fetch)], text=True).strip()) + out_dir = Path(__file__).resolve().parent.parent / "src" / "gen_exports" + out_dir.mkdir(parents=True, exist_ok=True) + + parsed = {} # lib -> (headers, exported, skipped) + all_macros: set[str] = set() + for lib, lib_dir_name in LIBS.items(): + lib_dir = root / lib_dir_name + exported: dict[str, str] = {} + skipped: list[str] = [] + headers = installed_headers(lib_dir) + for header in headers: + exp, skip = parse_header(header) + exported.update(exp) + skipped += [f"{header.name}: {s}" for s in skip] + parsed[lib] = (headers, exported, skipped) + all_macros |= {s.split()[-1] for s in skipped if " macro " in f" {s} "} + + for lib, lib_dir_name in LIBS.items(): + headers, exported, skipped = parsed[lib] + + # A name that is ALSO an object-/function-like macro anywhere in the + # public headers cannot appear in an export using-declaration — the + # macro would expand inside our own module TU. Route those through + # include/ffmpeg-m/macros.h instead. + macro_clashes = sorted(set(exported) & all_macros) + for name in macro_clashes: + del exported[name] + skipped.append(f"(macro-clash) {name}") + + # The GMF include set: every installed public header of this library. + inc_lines = [f"// Auto-generated by tools/gen_exports.py — installed " + f"public headers of {lib_dir_name}.", ""] + inc_lines += [f"#include <{lib_dir_name}/{h.name}>" for h in headers] + (out_dir / f"{lib}.includes.inc").write_text("\n".join(inc_lines) + "\n") + + lines = [f"// Auto-generated by tools/gen_exports.py from {lib_dir_name}", + f"// public headers ({len(headers)} files) — do not edit by hand.", + ""] + for kind in ("struct", "typedef", "enum", "enumerator", "function"): + names = sorted(n for n, k in exported.items() if k == kind) + if names: + lines.append(f"// {kind}s ({len(names)})") + lines += [f"export using ::{n};" for n in names] + lines.append("") + + (out_dir / f"{lib}.inc").write_text("\n".join(lines)) + (out_dir / f"{lib}.skipped.txt").write_text("\n".join(sorted(set(skipped))) + "\n") + counts = {k: sum(1 for v in exported.values() if v == k) + for k in ("function", "struct", "typedef", "enum", "enumerator")} + print(f"{lib}: {counts} skipped={len(set(skipped))}") + + +if __name__ == "__main__": + main()