From 159d275957de6211169c131b691d3b2f3d8d8387 Mon Sep 17 00:00:00 2001 From: ldm0 Date: Sat, 11 Apr 2026 04:15:25 +0800 Subject: [PATCH] chore: Update constants for FFmpeg 8.1 --- .gitignore | 1 + Cargo.toml | 6 +- skills/ffmpeg-constant-sync/SKILL.md | 85 +++++++++++++++++++ .../ffmpeg-constant-sync/agents/openai.yaml | 4 + .../references/tag-audit-commands.md | 62 ++++++++++++++ src/avutil/error.rs | 2 + src/avutil/pixfmt.rs | 71 ++++++++++++---- 7 files changed, 213 insertions(+), 18 deletions(-) create mode 100644 skills/ffmpeg-constant-sync/SKILL.md create mode 100644 skills/ffmpeg-constant-sync/agents/openai.yaml create mode 100644 skills/ffmpeg-constant-sync/references/tag-audit-commands.md diff --git a/.gitignore b/.gitignore index c787fcc..ec04fa3 100644 --- a/.gitignore +++ b/.gitignore @@ -1,3 +1,4 @@ /target Cargo.lock /.vscode +/.codex diff --git a/Cargo.toml b/Cargo.toml index d38e1ec..f59d40e 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -44,9 +44,13 @@ use_prebuilt_binding = [] ffmpeg5 = [] # FFmpeg 6.* support ffmpeg6 = ["ffmpeg5"] +# FFmpeg 6.1+ support +ffmpeg6_1 = ["ffmpeg6"] # FFmpeg 7.* support -ffmpeg7 = ["ffmpeg6"] +ffmpeg7 = ["ffmpeg6_1"] # FFmpeg 7.1+ support ffmpeg7_1 = ["ffmpeg7"] # FFmpeg 8.* support ffmpeg8 = ["ffmpeg7_1"] +# FFmpeg 8.1+ support +ffmpeg8_1 = ["ffmpeg8"] diff --git a/skills/ffmpeg-constant-sync/SKILL.md b/skills/ffmpeg-constant-sync/SKILL.md new file mode 100644 index 0000000..6b3cb80 --- /dev/null +++ b/skills/ffmpeg-constant-sync/SKILL.md @@ -0,0 +1,85 @@ +--- +name: ffmpeg-constant-sync +description: Use when auditing or updating hand-written FFmpeg constants, macro aliases, and version-gated feature flags in Rust bindings. Trigger for tasks like comparing `pixfmt.h` / `channel_layout.h` / `error.h` against `src/avutil/*.rs`, checking whether FFmpeg 8.1 added constants, determining the first FFmpeg release that introduced a symbol, or adding `ffmpegX_Y` feature gates in `Cargo.toml`. +--- + +# FFmpeg Constant Sync + +Audit upstream FFmpeg header macros against this repository's hand-written Rust constants, then gate each symbol by the earliest release tag that actually contains it. + +Prefer release tags such as `n7.1`, `n8.0`, `n8.1` when answering questions about `.0` or `.1` releases. Only use release branches to inspect current maintenance-line state; branch heads may contain later backports. + +## Use This Skill For + +- Checking whether a specific FFmpeg release added any new constants. +- Syncing `src/avutil/pixfmt.rs`, `src/avutil/channel_layout.rs`, or `src/avutil/error.rs`. +- Deciding whether a symbol belongs behind `ffmpeg6`, `ffmpeg6_1`, `ffmpeg7_1`, `ffmpeg8`, `ffmpeg8_1`, etc. +- Adding missing feature boundaries in `Cargo.toml`. +- Verifying that Rust-exported constants match upstream macro names. + +## Files To Audit + +- `Cargo.toml` +- `src/avutil/pixfmt.rs` +- `src/avutil/channel_layout.rs` +- `src/avutil/error.rs` +- Sometimes `src/lib.rs` and `src/avutil/mod.rs` if a whole module is feature-gated + +Primary upstream headers: + +- `libavutil/pixfmt.h` +- `libavutil/channel_layout.h` +- `libavutil/error.h` + +## Workflow + +1. Identify the local hand-written constants and their current `#[cfg(feature = ...)]` gates. +2. Compare upstream header macros to local Rust exports. +3. For every disputed symbol, find the earliest FFmpeg release tag that contains it. +4. Update `Cargo.toml` feature boundaries if an intermediate version boundary is missing. +5. Gate symbols by the earliest release that contains them. +6. Verify with `DOCS_RS=1 cargo check` across the relevant feature chain. + +## Rules + +- Use release tags for release questions: + - Good: `n7.1`, `n8.0`, `n8.1` + - Less reliable for `.0` / `.1` questions: `release/8.0`, `release/8.1` +- Gate by first availability, not by the first version this repository happened to support. +- If a later feature inherits an earlier one, prefer the narrowest correct gate: + - Example: if a symbol exists since FFmpeg 6.0, use `ffmpeg6`, not `any(feature = "ffmpeg6", feature = "ffmpeg7")` +- When checking whether `8.1` added constants, diff `n8.0` vs `n8.1` directly. +- Distinguish: + - Missing symbol entirely + - Symbol present but feature gate too new + - Symbol present but feature gate too broad or imprecise + - Symbol already provided by generated `binding.rs`, so do not duplicate it in hand-written code + +## Version Mapping + +Current repository feature boundaries should follow this pattern when needed: + +- `ffmpeg5` +- `ffmpeg6` +- `ffmpeg6_1` +- `ffmpeg7` +- `ffmpeg7_1` +- `ffmpeg8` +- `ffmpeg8_1` + +If the repo is missing a needed boundary, add it to `Cargo.toml` before moving symbol gates. + +## Verification + +- Run `DOCS_RS=1 cargo check --features ` for each affected boundary. +- At minimum, check the earliest feature that should expose a symbol and the previous feature that should not. +- If you need exact command patterns, read `references/tag-audit-commands.md`. + +## Output Expectations + +When reporting results: + +- State whether the release added new constants or not. +- Name the exact tag pair used for the comparison. +- Call out symbols whose gates moved. +- Separate “missing constant” from “wrong version gate”. diff --git a/skills/ffmpeg-constant-sync/agents/openai.yaml b/skills/ffmpeg-constant-sync/agents/openai.yaml new file mode 100644 index 0000000..3e07fde --- /dev/null +++ b/skills/ffmpeg-constant-sync/agents/openai.yaml @@ -0,0 +1,4 @@ +interface: + display_name: "FFmpeg Constant Sync" + short_description: "Audit and sync FFmpeg constant gates" + default_prompt: "Use $ffmpeg-constant-sync to audit hand-written FFmpeg constants and version gates against upstream release tags." diff --git a/skills/ffmpeg-constant-sync/references/tag-audit-commands.md b/skills/ffmpeg-constant-sync/references/tag-audit-commands.md new file mode 100644 index 0000000..4968f98 --- /dev/null +++ b/skills/ffmpeg-constant-sync/references/tag-audit-commands.md @@ -0,0 +1,62 @@ +# Tag Audit Commands + +Use these patterns when auditing FFmpeg constants. + +## Diff two release tags + +```bash +diff -u \ + <(git -C /path/to/ffmpeg show n8.0:libavutil/pixfmt.h | rg '^#define AV_PIX_FMT_') \ + <(git -C /path/to/ffmpeg show n8.1:libavutil/pixfmt.h | rg '^#define AV_PIX_FMT_') +``` + +Repeat with: + +- `libavutil/channel_layout.h` +- `libavutil/error.h` + +Useful filters: + +- `^#define AV_PIX_FMT_` +- `^#define AV_CH_` +- `^#define AV_CH_LAYOUT_` +- `^#define AV_CHANNEL_LAYOUT_` +- `^#define AVERROR_` + +## Find the first release tag containing a symbol + +```bash +for tag in n5.0 n6.0 n6.1 n7.0 n7.1 n8.0 n8.1; do + if git -C /path/to/ffmpeg show "$tag:libavutil/pixfmt.h" | rg -q '^#define AV_PIX_FMT_GRAY32\b'; then + echo "$tag" + break + fi +done +``` + +Switch files by symbol family: + +- `AV_PIX_FMT_*` -> `libavutil/pixfmt.h` +- `AV_CH_*`, `AV_CH_LAYOUT_*`, `AV_CHANNEL_LAYOUT_*` -> `libavutil/channel_layout.h` +- `AVERROR_*` -> `libavutil/error.h` + +## Compare local hand-written aliases with upstream macros + +```bash +comm -23 \ + <(git -C /path/to/ffmpeg show n8.1:libavutil/pixfmt.h | rg '^#define AV_PIX_FMT_[A-Z0-9_]+\s+AV_PIX_FMT_NE' | sed -E 's/^#define (AV_PIX_FMT_[A-Z0-9_]+).*/\1/' | sort -u) \ + <(rg '^AV_PIX_FMT_NE!\(' src/avutil/pixfmt.rs | sed -E 's/^AV_PIX_FMT_NE!\((AV_PIX_FMT_[A-Z0-9_]+).*/\1/' | sort -u) +``` + +## Compile checks + +```bash +DOCS_RS=1 cargo check --features ffmpeg6 +DOCS_RS=1 cargo check --features ffmpeg6_1 +DOCS_RS=1 cargo check --features ffmpeg7 +DOCS_RS=1 cargo check --features ffmpeg7_1 +DOCS_RS=1 cargo check --features ffmpeg8 +DOCS_RS=1 cargo check --features ffmpeg8_1 +``` + +Use the smallest affected subset when possible, but include the boundary before and after the symbol’s first supported version. diff --git a/src/avutil/error.rs b/src/avutil/error.rs index 0ee0f18..687d12e 100644 --- a/src/avutil/error.rs +++ b/src/avutil/error.rs @@ -45,6 +45,8 @@ pub const AVERROR_HTTP_BAD_REQUEST: c_int = FFERRTAG!(0xF8, b'4', b'0', b'0'); pub const AVERROR_HTTP_UNAUTHORIZED: c_int = FFERRTAG!(0xF8, b'4', b'0', b'1'); pub const AVERROR_HTTP_FORBIDDEN: c_int = FFERRTAG!(0xF8, b'4', b'0', b'3'); pub const AVERROR_HTTP_NOT_FOUND: c_int = FFERRTAG!(0xF8, b'4', b'0', b'4'); +#[cfg(feature = "ffmpeg7_1")] +pub const AVERROR_HTTP_TOO_MANY_REQUESTS: c_int = FFERRTAG!(0xF8, b'4', b'2', b'9'); pub const AVERROR_HTTP_OTHER_4XX: c_int = FFERRTAG!(0xF8, b'4', b'X', b'X'); pub const AVERROR_HTTP_SERVER_ERROR: c_int = FFERRTAG!(0xF8, b'5', b'X', b'X'); diff --git a/src/avutil/pixfmt.rs b/src/avutil/pixfmt.rs index 9854f8a..818e7b2 100644 --- a/src/avutil/pixfmt.rs +++ b/src/avutil/pixfmt.rs @@ -20,7 +20,10 @@ AV_PIX_FMT_NE!(AV_PIX_FMT_0BGR32, AV_PIX_FMT_0BGR, AV_PIX_FMT_RGB0); AV_PIX_FMT_NE!(AV_PIX_FMT_GRAY9, AV_PIX_FMT_GRAY9BE, AV_PIX_FMT_GRAY9LE); AV_PIX_FMT_NE!(AV_PIX_FMT_GRAY10, AV_PIX_FMT_GRAY10BE, AV_PIX_FMT_GRAY10LE); AV_PIX_FMT_NE!(AV_PIX_FMT_GRAY12, AV_PIX_FMT_GRAY12BE, AV_PIX_FMT_GRAY12LE); +AV_PIX_FMT_NE!(AV_PIX_FMT_GRAY14, AV_PIX_FMT_GRAY14BE, AV_PIX_FMT_GRAY14LE); AV_PIX_FMT_NE!(AV_PIX_FMT_GRAY16, AV_PIX_FMT_GRAY16BE, AV_PIX_FMT_GRAY16LE); +#[cfg(feature = "ffmpeg8")] +AV_PIX_FMT_NE!(AV_PIX_FMT_GRAY32, AV_PIX_FMT_GRAY32BE, AV_PIX_FMT_GRAY32LE); AV_PIX_FMT_NE!(AV_PIX_FMT_YA16, AV_PIX_FMT_YA16BE, AV_PIX_FMT_YA16LE); AV_PIX_FMT_NE!(AV_PIX_FMT_RGB48, AV_PIX_FMT_RGB48BE, AV_PIX_FMT_RGB48LE); AV_PIX_FMT_NE!(AV_PIX_FMT_RGB565, AV_PIX_FMT_RGB565BE, AV_PIX_FMT_RGB565LE); @@ -50,6 +53,10 @@ AV_PIX_FMT_NE!(AV_PIX_FMT_YUV444P14, AV_PIX_FMT_YUV444P14BE, AV_PIX_FMT_YUV444P1 AV_PIX_FMT_NE!(AV_PIX_FMT_YUV420P16, AV_PIX_FMT_YUV420P16BE, AV_PIX_FMT_YUV420P16LE); AV_PIX_FMT_NE!(AV_PIX_FMT_YUV422P16, AV_PIX_FMT_YUV422P16BE, AV_PIX_FMT_YUV422P16LE); AV_PIX_FMT_NE!(AV_PIX_FMT_YUV444P16, AV_PIX_FMT_YUV444P16BE, AV_PIX_FMT_YUV444P16LE); +#[cfg(feature = "ffmpeg8")] +AV_PIX_FMT_NE!(AV_PIX_FMT_YUV444P10MSB, AV_PIX_FMT_YUV444P10MSBBE, AV_PIX_FMT_YUV444P10MSBLE); +#[cfg(feature = "ffmpeg8")] +AV_PIX_FMT_NE!(AV_PIX_FMT_YUV444P12MSB, AV_PIX_FMT_YUV444P12MSBBE, AV_PIX_FMT_YUV444P12MSBLE); AV_PIX_FMT_NE!(AV_PIX_FMT_GBRP9, AV_PIX_FMT_GBRP9BE , AV_PIX_FMT_GBRP9LE); AV_PIX_FMT_NE!(AV_PIX_FMT_GBRP10, AV_PIX_FMT_GBRP10BE, AV_PIX_FMT_GBRP10LE); @@ -58,19 +65,35 @@ AV_PIX_FMT_NE!(AV_PIX_FMT_GBRP14, AV_PIX_FMT_GBRP14BE, AV_PIX_FMT_GBRP14LE); AV_PIX_FMT_NE!(AV_PIX_FMT_GBRP16, AV_PIX_FMT_GBRP16BE, AV_PIX_FMT_GBRP16LE); AV_PIX_FMT_NE!(AV_PIX_FMT_GBRAP10, AV_PIX_FMT_GBRAP10BE, AV_PIX_FMT_GBRAP10LE); AV_PIX_FMT_NE!(AV_PIX_FMT_GBRAP12, AV_PIX_FMT_GBRAP12BE, AV_PIX_FMT_GBRAP12LE); -#[cfg(feature = "ffmpeg7")] +#[cfg(feature = "ffmpeg6_1")] AV_PIX_FMT_NE!(AV_PIX_FMT_GBRAP14, AV_PIX_FMT_GBRAP14BE, AV_PIX_FMT_GBRAP14LE); AV_PIX_FMT_NE!(AV_PIX_FMT_GBRAP16, AV_PIX_FMT_GBRAP16BE, AV_PIX_FMT_GBRAP16LE); +#[cfg(feature = "ffmpeg8")] +AV_PIX_FMT_NE!(AV_PIX_FMT_GBRAP32, AV_PIX_FMT_GBRAP32BE, AV_PIX_FMT_GBRAP32LE); +#[cfg(feature = "ffmpeg8")] +AV_PIX_FMT_NE!(AV_PIX_FMT_GBRP10MSB, AV_PIX_FMT_GBRP10MSBBE, AV_PIX_FMT_GBRP10MSBLE); +#[cfg(feature = "ffmpeg8")] +AV_PIX_FMT_NE!(AV_PIX_FMT_GBRP12MSB, AV_PIX_FMT_GBRP12MSBBE, AV_PIX_FMT_GBRP12MSBLE); AV_PIX_FMT_NE!(AV_PIX_FMT_BAYER_BGGR16, AV_PIX_FMT_BAYER_BGGR16BE, AV_PIX_FMT_BAYER_BGGR16LE); AV_PIX_FMT_NE!(AV_PIX_FMT_BAYER_RGGB16, AV_PIX_FMT_BAYER_RGGB16BE, AV_PIX_FMT_BAYER_RGGB16LE); AV_PIX_FMT_NE!(AV_PIX_FMT_BAYER_GBRG16, AV_PIX_FMT_BAYER_GBRG16BE, AV_PIX_FMT_BAYER_GBRG16LE); AV_PIX_FMT_NE!(AV_PIX_FMT_BAYER_GRBG16, AV_PIX_FMT_BAYER_GRBG16BE, AV_PIX_FMT_BAYER_GRBG16LE); +#[cfg(feature = "ffmpeg8")] +AV_PIX_FMT_NE!(AV_PIX_FMT_GBRPF16, AV_PIX_FMT_GBRPF16BE, AV_PIX_FMT_GBRPF16LE); +#[cfg(feature = "ffmpeg8")] +AV_PIX_FMT_NE!(AV_PIX_FMT_GBRAPF16, AV_PIX_FMT_GBRAPF16BE, AV_PIX_FMT_GBRAPF16LE); AV_PIX_FMT_NE!(AV_PIX_FMT_GBRPF32, AV_PIX_FMT_GBRPF32BE, AV_PIX_FMT_GBRPF32LE); AV_PIX_FMT_NE!(AV_PIX_FMT_GBRAPF32, AV_PIX_FMT_GBRAPF32BE, AV_PIX_FMT_GBRAPF32LE); +#[cfg(feature = "ffmpeg8")] +AV_PIX_FMT_NE!(AV_PIX_FMT_GRAYF16, AV_PIX_FMT_GRAYF16BE, AV_PIX_FMT_GRAYF16LE); AV_PIX_FMT_NE!(AV_PIX_FMT_GRAYF32, AV_PIX_FMT_GRAYF32BE, AV_PIX_FMT_GRAYF32LE); +#[cfg(feature = "ffmpeg8")] +AV_PIX_FMT_NE!(AV_PIX_FMT_YAF16, AV_PIX_FMT_YAF16BE, AV_PIX_FMT_YAF16LE); +#[cfg(feature = "ffmpeg8")] +AV_PIX_FMT_NE!(AV_PIX_FMT_YAF32, AV_PIX_FMT_YAF32BE, AV_PIX_FMT_YAF32LE); AV_PIX_FMT_NE!(AV_PIX_FMT_YUVA420P9, AV_PIX_FMT_YUVA420P9BE , AV_PIX_FMT_YUVA420P9LE); AV_PIX_FMT_NE!(AV_PIX_FMT_YUVA422P9, AV_PIX_FMT_YUVA422P9BE , AV_PIX_FMT_YUVA422P9LE); @@ -78,6 +101,8 @@ AV_PIX_FMT_NE!(AV_PIX_FMT_YUVA444P9, AV_PIX_FMT_YUVA444P9BE , AV_PIX_FMT_YUVA444 AV_PIX_FMT_NE!(AV_PIX_FMT_YUVA420P10, AV_PIX_FMT_YUVA420P10BE, AV_PIX_FMT_YUVA420P10LE); AV_PIX_FMT_NE!(AV_PIX_FMT_YUVA422P10, AV_PIX_FMT_YUVA422P10BE, AV_PIX_FMT_YUVA422P10LE); AV_PIX_FMT_NE!(AV_PIX_FMT_YUVA444P10, AV_PIX_FMT_YUVA444P10BE, AV_PIX_FMT_YUVA444P10LE); +AV_PIX_FMT_NE!(AV_PIX_FMT_YUVA422P12, AV_PIX_FMT_YUVA422P12BE, AV_PIX_FMT_YUVA422P12LE); +AV_PIX_FMT_NE!(AV_PIX_FMT_YUVA444P12, AV_PIX_FMT_YUVA444P12BE, AV_PIX_FMT_YUVA444P12LE); AV_PIX_FMT_NE!(AV_PIX_FMT_YUVA420P16, AV_PIX_FMT_YUVA420P16BE, AV_PIX_FMT_YUVA420P16LE); AV_PIX_FMT_NE!(AV_PIX_FMT_YUVA422P16, AV_PIX_FMT_YUVA422P16BE, AV_PIX_FMT_YUVA422P16LE); AV_PIX_FMT_NE!(AV_PIX_FMT_YUVA444P16, AV_PIX_FMT_YUVA444P16BE, AV_PIX_FMT_YUVA444P16LE); @@ -86,40 +111,52 @@ AV_PIX_FMT_NE!(AV_PIX_FMT_XYZ12, AV_PIX_FMT_XYZ12BE, AV_PIX_FMT_XYZ12LE); AV_PIX_FMT_NE!(AV_PIX_FMT_NV20, AV_PIX_FMT_NV20BE, AV_PIX_FMT_NV20LE); AV_PIX_FMT_NE!(AV_PIX_FMT_AYUV64, AV_PIX_FMT_AYUV64BE, AV_PIX_FMT_AYUV64LE); AV_PIX_FMT_NE!(AV_PIX_FMT_P010, AV_PIX_FMT_P010BE, AV_PIX_FMT_P010LE); -#[cfg(any(feature = "ffmpeg6", feature = "ffmpeg7"))] +#[cfg(feature = "ffmpeg6")] AV_PIX_FMT_NE!(AV_PIX_FMT_P012, AV_PIX_FMT_P012BE, AV_PIX_FMT_P012LE); AV_PIX_FMT_NE!(AV_PIX_FMT_P016, AV_PIX_FMT_P016BE, AV_PIX_FMT_P016LE); -#[cfg(any(feature = "ffmpeg5", feature = "ffmpeg6", feature = "ffmpeg7"))] +#[cfg(feature = "ffmpeg5")] AV_PIX_FMT_NE!(AV_PIX_FMT_Y210, AV_PIX_FMT_Y210BE, AV_PIX_FMT_Y210LE); -#[cfg(any(feature = "ffmpeg6", feature = "ffmpeg7"))] +#[cfg(feature = "ffmpeg6")] AV_PIX_FMT_NE!(AV_PIX_FMT_Y212, AV_PIX_FMT_Y212BE, AV_PIX_FMT_Y212LE); -#[cfg(any(feature = "ffmpeg6", feature = "ffmpeg7"))] +#[cfg(feature = "ffmpeg8")] +AV_PIX_FMT_NE!(AV_PIX_FMT_Y216, AV_PIX_FMT_Y216BE, AV_PIX_FMT_Y216LE); +#[cfg(feature = "ffmpeg6")] AV_PIX_FMT_NE!(AV_PIX_FMT_XV30, AV_PIX_FMT_XV30BE, AV_PIX_FMT_XV30LE); -#[cfg(any(feature = "ffmpeg6", feature = "ffmpeg7"))] +#[cfg(feature = "ffmpeg6")] AV_PIX_FMT_NE!(AV_PIX_FMT_XV36, AV_PIX_FMT_XV36BE, AV_PIX_FMT_XV36LE); -#[cfg(any(feature = "ffmpeg5", feature = "ffmpeg6", feature = "ffmpeg7"))] +#[cfg(feature = "ffmpeg8")] +AV_PIX_FMT_NE!(AV_PIX_FMT_XV48, AV_PIX_FMT_XV48BE, AV_PIX_FMT_XV48LE); +#[cfg(feature = "ffmpeg8")] +AV_PIX_FMT_NE!(AV_PIX_FMT_V30X, AV_PIX_FMT_V30XBE, AV_PIX_FMT_V30XLE); +#[cfg(feature = "ffmpeg5")] AV_PIX_FMT_NE!(AV_PIX_FMT_X2RGB10, AV_PIX_FMT_X2RGB10BE, AV_PIX_FMT_X2RGB10LE); -#[cfg(any(feature = "ffmpeg5", feature = "ffmpeg6", feature = "ffmpeg7"))] +#[cfg(feature = "ffmpeg5")] AV_PIX_FMT_NE!(AV_PIX_FMT_X2BGR10, AV_PIX_FMT_X2BGR10BE, AV_PIX_FMT_X2BGR10LE); -#[cfg(any(feature = "ffmpeg5", feature = "ffmpeg6", feature = "ffmpeg7"))] +#[cfg(feature = "ffmpeg5")] AV_PIX_FMT_NE!(AV_PIX_FMT_P210, AV_PIX_FMT_P210BE, AV_PIX_FMT_P210LE); -#[cfg(any(feature = "ffmpeg5", feature = "ffmpeg6", feature = "ffmpeg7"))] +#[cfg(feature = "ffmpeg5")] AV_PIX_FMT_NE!(AV_PIX_FMT_P410, AV_PIX_FMT_P410BE, AV_PIX_FMT_P410LE); -#[cfg(feature = "ffmpeg7")] +#[cfg(feature = "ffmpeg6_1")] AV_PIX_FMT_NE!(AV_PIX_FMT_P212, AV_PIX_FMT_P212BE, AV_PIX_FMT_P212LE); -#[cfg(feature = "ffmpeg7")] +#[cfg(feature = "ffmpeg6_1")] AV_PIX_FMT_NE!(AV_PIX_FMT_P412, AV_PIX_FMT_P412BE, AV_PIX_FMT_P412LE); -#[cfg(any(feature = "ffmpeg5", feature = "ffmpeg6", feature = "ffmpeg7"))] +#[cfg(feature = "ffmpeg5")] AV_PIX_FMT_NE!(AV_PIX_FMT_P216, AV_PIX_FMT_P216BE, AV_PIX_FMT_P216LE); -#[cfg(any(feature = "ffmpeg5", feature = "ffmpeg6", feature = "ffmpeg7"))] +#[cfg(feature = "ffmpeg5")] AV_PIX_FMT_NE!(AV_PIX_FMT_P416, AV_PIX_FMT_P416BE, AV_PIX_FMT_P416LE); -#[cfg(any(feature = "ffmpeg6", feature = "ffmpeg7"))] +#[cfg(feature = "ffmpeg8")] +AV_PIX_FMT_NE!(AV_PIX_FMT_RGBF16, AV_PIX_FMT_RGBF16BE, AV_PIX_FMT_RGBF16LE); +#[cfg(feature = "ffmpeg6")] AV_PIX_FMT_NE!(AV_PIX_FMT_RGBAF16, AV_PIX_FMT_RGBAF16BE, AV_PIX_FMT_RGBAF16LE); -#[cfg(any(feature = "ffmpeg6", feature = "ffmpeg7"))] +#[cfg(feature = "ffmpeg6")] AV_PIX_FMT_NE!(AV_PIX_FMT_RGBF32, AV_PIX_FMT_RGBF32BE, AV_PIX_FMT_RGBF32LE); -#[cfg(any(feature = "ffmpeg6", feature = "ffmpeg7"))] +#[cfg(feature = "ffmpeg6")] AV_PIX_FMT_NE!(AV_PIX_FMT_RGBAF32, AV_PIX_FMT_RGBAF32BE, AV_PIX_FMT_RGBAF32LE); +#[cfg(feature = "ffmpeg8")] +AV_PIX_FMT_NE!(AV_PIX_FMT_RGB96, AV_PIX_FMT_RGB96BE, AV_PIX_FMT_RGB96LE); +#[cfg(feature = "ffmpeg8")] +AV_PIX_FMT_NE!(AV_PIX_FMT_RGBA128, AV_PIX_FMT_RGBA128BE, AV_PIX_FMT_RGBA128LE);