PR #25719 opened by Kilian (lusoris)
URL: https://code.ffmpeg.org/FFmpeg/FFmpeg/pulls/25719
Patch URL: https://code.ffmpeg.org/FFmpeg/FFmpeg/pulls/25719.patch

This series fixes two AFGS1 parser misalignments in 
`ff_aom_parse_film_grain_sets()`. Both were reported as pre-existing issues in 
the review of #25664. They were reproduced on a88838af48, the master base of 
#25664, as well as on its head.

Depends on #25664: the series extends the `fate-aom-film-grain` test that 
#25664 adds, so it is based on its head 092c2ee2b3.

What goes wrong today:

- **Explicit chroma with zero points:** the AFGS1 syntax 
(https://aomediacodec.github.io/afgs1-spec/) signals 
`point_cb_value_increment_bits_minus1`, `point_cb_scaling_bits_minus5` and 
`cb_scaling_offset` only when `num_cb_points` is nonzero, and likewise for Cr. 
The parser reads these 13 bits anyway, so every later field of the set is 
misread. Depending on the payload, that gives wrong points or 
AVERROR_INVALIDDATA.
- **Parameter sets without grain:** with `apply_grain_flag` or 
`update_grain_flag` equal to 0, the set ends early but its payload is still 
padded to `payload_size` bytes. The parser skips that padding step, so the next 
parameter set in the same payload is read from the wrong position and is lost.

What the patches do:

1. Stop after the point count when an explicit chroma plane has no points.
2. Send both early exits through the existing padding skip, and export no set 
for them.

Testing:

- New `fate-aom-film-grain` cases: explicit sets with point counts (Y, Cb, Cr) 
= (1, 0, 1), (1, 1, 0) and (1, 0, 0); a two-set payload whose first set has 
`apply_grain_flag` = 0; and the same with a padded `update_grain_flag` = 0 set.
- With the parser change of either commit reverted, its new cases differ from 
the reference output: lost points, AVERROR_INVALIDDATA, or a missing following 
set.
- At the series head, `fate-aom-film-grain`, `fate-film_grain_params` and 
`fate-source` pass. `fate-aom-film-grain` also passes with 
`--toolchain=gcc-asan`, with no sanitizer reports.

Not included: the explicit chroma scaling sum `point_cb_scaling[i] + 
cb_scaling_offset` can exceed 255, and the spec does not clip it. 
`AVFilmGrainAOMParams.uv_points` stores `uint8_t`, so the value wraps. Clipping 
or rejecting it would both depart from the spec, so that needs a separate 
decision about the public struct.



>From 092c2ee2b399a0a0cb44bb87840ffe452986d03b Mon Sep 17 00:00:00 2001
From: lusoris <[email protected]>
Date: Sat, 31 Oct 2026 23:07:32 +0100
Subject: [PATCH 1/3] avcodec/aom_film_grain: Derive predicted points without
 residual

AFGS1 derives predicted scaling points even when the residual bit width
is zero. In that case the residual contribution is zero, but the point
count and predicted values still come from the reference set.

Keeping the point count at zero also suppresses the AR coefficients and
shifts every field that follows them. Derive luma and chroma points
unconditionally and use the prediction flags in the AR conditions.

Add a generated FATE parser regression test for predicted AFGS1 sets.

Signed-off-by: lusoris <[email protected]>
---
 libavcodec/Makefile               |   1 +
 libavcodec/aom_film_grain.c       |  46 +++---
 libavcodec/tests/aom_film_grain.c | 259 ++++++++++++++++++++++++++++++
 tests/fate/libavcodec.mak         |   5 +
 tests/ref/fate/aom-film-grain     |  63 ++++++++
 5 files changed, 352 insertions(+), 22 deletions(-)
 create mode 100644 libavcodec/tests/aom_film_grain.c
 create mode 100644 tests/ref/fate/aom-film-grain

diff --git a/libavcodec/Makefile b/libavcodec/Makefile
index 2ea4f9417e6..a92a6ec23cc 100644
--- a/libavcodec/Makefile
+++ b/libavcodec/Makefile
@@ -1398,6 +1398,7 @@ TESTPROGS-$(CONFIG_AV1_VAAPI_ENCODER)     += av1_levels
 TESTPROGS-$(CONFIG_CABAC)                 += cabac
 TESTPROGS-$(CONFIG_CELP_MATH)             += celp_math
 TESTPROGS-$(CONFIG_GOLOMB)                += golomb
+TESTPROGS-$(CONFIG_ITUT_T35)              += aom_film_grain
 TESTPROGS-$(CONFIG_IDCTDSP)               += dct
 TESTPROGS-$(CONFIG_DXV_ENCODER)           += hashtable
 TESTPROGS-$(CONFIG_MJPEG_ENCODER)         += mjpegenc_huffman
diff --git a/libavcodec/aom_film_grain.c b/libavcodec/aom_film_grain.c
index bb60c557741..7ba7f143730 100644
--- a/libavcodec/aom_film_grain.c
+++ b/libavcodec/aom_film_grain.c
@@ -144,7 +144,7 @@ int ff_aom_parse_film_grain_sets(AVFilmGrainAFGS1Params *s,
     num_sets = get_bits(gb, 3) + 1;
     for (n = 0; n < num_sets; n++) {
         int payload_4byte, payload_size, set_idx, apply_units_log2, vsc_flag;
-        int predict_scaling, predict_y_scaling, predict_uv_scaling[2];
+        int predict_scaling, predict_y_scaling, predict_uv_scaling[2] = { 0 };
         int payload_bits, start_position;
         size_t fgp_size;
 
@@ -218,23 +218,23 @@ int ff_aom_parse_film_grain_sets(AVFilmGrainAFGS1Params 
*s,
 
         predict_y_scaling = predict_scaling ? get_bits1(gb) : 0;
         if (predict_y_scaling) {
-            int y_scale, y_offset, bits_res;
+            int y_scale, y_offset, bits_res, res[14], pred, granularity;
             y_scale = get_bits(gb, 9) - 256;
             y_offset = get_bits(gb, 9) - 256;
             bits_res = get_bits(gb, 3);
+            aom->num_y_points = ref->codec.aom.num_y_points;
             if (bits_res) {
-                int res[14], pred, granularity;
-                aom->num_y_points = ref->codec.aom.num_y_points;
                 for (i = 0; i < aom->num_y_points; i++)
                     res[i] = get_bits(gb, bits_res);
                 granularity = get_bits(gb, 3);
-                for (i = 0; i < aom->num_y_points; i++) {
-                    pred = ref->codec.aom.y_points[i][1];
-                    pred = ((pred * y_scale + 8) >> 4) + y_offset;
+            }
+            for (i = 0; i < aom->num_y_points; i++) {
+                pred = ref->codec.aom.y_points[i][1];
+                pred = ((pred * y_scale + 8) >> 4) + y_offset;
+                if (bits_res)
                     pred += (res[i] - (1 << (bits_res - 1))) * granularity;
-                    aom->y_points[i][0] = ref->codec.aom.y_points[i][0];
-                    aom->y_points[i][1] = av_clip_uint8(pred);
-                }
+                aom->y_points[i][0] = ref->codec.aom.y_points[i][0];
+                aom->y_points[i][1] = av_clip_uint8(pred);
             }
         } else {
             aom->num_y_points = get_bits(gb, 4);
@@ -266,26 +266,26 @@ int ff_aom_parse_film_grain_sets(AVFilmGrainAFGS1Params 
*s,
                 for (uv = 0; uv < 2; uv++) {
                     predict_uv_scaling[uv] = predict_scaling ? get_bits1(gb) : 
0;
                     if (predict_uv_scaling[uv]) {
-                        int uv_scale, uv_offset, bits_res;
+                        int uv_scale, uv_offset, bits_res, res[10], pred, 
granularity;
                         uv_scale = get_bits(gb, 9) - 256;
                         uv_offset = get_bits(gb, 9) - 256;
                         bits_res = get_bits(gb, 3);
                         aom->uv_mult[uv] = ref->codec.aom.uv_mult[uv];
                         aom->uv_mult_luma[uv] = 
ref->codec.aom.uv_mult_luma[uv];
                         aom->uv_offset[uv] = ref->codec.aom.uv_offset[uv];
+                        aom->num_uv_points[uv] = 
ref->codec.aom.num_uv_points[uv];
                         if (bits_res) {
-                            int res[10], pred, granularity;
-                            aom->num_uv_points[uv] = 
ref->codec.aom.num_uv_points[uv];
                             for (i = 0; i < aom->num_uv_points[uv]; i++)
                                 res[i] = get_bits(gb, bits_res);
                             granularity = get_bits(gb, 3);
-                            for (i = 0; i < aom->num_uv_points[uv]; i++) {
-                                pred = ref->codec.aom.uv_points[uv][i][1];
-                                pred = ((pred * uv_scale + 8) >> 4) + 
uv_offset;
+                        }
+                        for (i = 0; i < aom->num_uv_points[uv]; i++) {
+                            pred = ref->codec.aom.uv_points[uv][i][1];
+                            pred = ((pred * uv_scale + 8) >> 4) + uv_offset;
+                            if (bits_res)
                                 pred += (res[i] - (1 << (bits_res - 1))) * 
granularity;
-                                aom->uv_points[uv][i][0] = 
ref->codec.aom.uv_points[uv][i][0];
-                                aom->uv_points[uv][i][1] = av_clip_uint8(pred);
-                            }
+                            aom->uv_points[uv][i][0] = 
ref->codec.aom.uv_points[uv][i][0];
+                            aom->uv_points[uv][i][1] = av_clip_uint8(pred);
                         }
                     } else {
                         int bits_inc, bits_scaling, uv_offset;
@@ -311,15 +311,17 @@ int ff_aom_parse_film_grain_sets(AVFilmGrainAFGS1Params 
*s,
         aom->scaling_shift = get_bits(gb, 2) + 8;
         aom->ar_coeff_lag = get_bits(gb, 2);
         num_y_coeffs = 2 * aom->ar_coeff_lag * (aom->ar_coeff_lag + 1);
-        if (aom->num_y_points) {
+        if (aom->num_y_points || predict_y_scaling) {
             int ar_bits = get_bits(gb, 2) + 5;
             for (i = 0; i < num_y_coeffs; i++)
                 aom->ar_coeffs_y[i] = get_bits(gb, ar_bits) - (1 << (ar_bits - 
1));
         }
         for (uv = 0; uv < 2; uv++) {
-            if (aom->chroma_scaling_from_luma || aom->num_uv_points[uv]) {
+            if (aom->chroma_scaling_from_luma || aom->num_uv_points[uv] ||
+                predict_uv_scaling[uv]) {
                 int ar_bits = get_bits(gb, 2) + 5;
-                for (i = 0; i < num_y_coeffs + !!aom->num_y_points; i++)
+                for (i = 0; i < num_y_coeffs +
+                                (aom->num_y_points || predict_y_scaling); i++)
                     aom->ar_coeffs_uv[uv][i] = get_bits(gb, ar_bits) - (1 << 
(ar_bits - 1));
             }
         }
diff --git a/libavcodec/tests/aom_film_grain.c 
b/libavcodec/tests/aom_film_grain.c
new file mode 100644
index 00000000000..e679fa8def2
--- /dev/null
+++ b/libavcodec/tests/aom_film_grain.c
@@ -0,0 +1,259 @@
+/*
+ * Copyright (c) 2026
+ *
+ * This file is part of FFmpeg.
+ *
+ * FFmpeg is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * FFmpeg is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with FFmpeg; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#include <stdio.h>
+#include <string.h>
+
+#include "libavutil/film_grain_params.h"
+
+#include "libavcodec/aom_film_grain.h"
+
+enum {
+    Y,
+    CB,
+    CR,
+    EMPTY,
+};
+
+typedef struct BitWriter {
+    uint8_t data[128];
+    int bits;
+} BitWriter;
+
+static void put_bits(BitWriter *bw, int bits, unsigned value)
+{
+    while (bits--) {
+        int pos = bw->bits++;
+        bw->data[pos >> 3] |= ((value >> bits) & 1) << (7 - (pos & 7));
+    }
+}
+
+static void put_bits_at(BitWriter *bw, int pos, int bits, unsigned value)
+{
+    while (bits--) {
+        int bit = pos++;
+        bw->data[bit >> 3] |= ((value >> bits) & 1) << (7 - (bit & 7));
+    }
+}
+
+static void put_coeffs(BitWriter *bw, int count, int base)
+{
+    int i;
+
+    put_bits(bw, 2, 0); // 5-bit signed coefficients
+    for (i = 0; i < count; i++)
+        put_bits(bw, 5, base + i + 16);
+}
+
+static void put_points(BitWriter *bw, int uv, int empty)
+{
+    int i;
+
+    put_bits(bw, 4, empty ? 0 : 2);
+    if (empty) {
+        if (uv) {
+            put_bits(bw, 3, 3); // 4-bit point increments
+            put_bits(bw, 2, 1); // 6-bit scaling values
+            put_bits(bw, 8, 32);
+        }
+        return;
+    }
+
+    put_bits(bw, 3, 3); // 4-bit point increments
+    put_bits(bw, 2, 1); // 6-bit scaling values
+    if (uv)
+        put_bits(bw, 8, 32);
+    for (i = 0; i < 2; i++) {
+        put_bits(bw, 4, 8 + 4 * i);
+        put_bits(bw, 6, 12 + 8 * i);
+    }
+}
+
+static void put_predicted_points(BitWriter *bw, int bits_res)
+{
+    int i;
+
+    put_bits(bw, 9, 272); // scale 16
+    put_bits(bw, 9, 256); // offset 0
+    put_bits(bw, 3, bits_res);
+    if (!bits_res)
+        return;
+
+    for (i = 0; i < 2; i++)
+        put_bits(bw, bits_res, 3);
+    put_bits(bw, 3, 2);
+}
+
+static void put_set(BitWriter *bw, int component, int bits_res, int reference)
+{
+    int start = bw->bits;
+    int predict_y = !reference && (component == Y || component == EMPTY);
+    int predict_uv[2] = {
+        !reference && (component == CB || component == EMPTY),
+        !reference && (component == CR || component == EMPTY),
+    };
+    int empty = component == EMPTY;
+    int y_points = reference && !empty;
+    int uv_points[2] = {
+        reference && !empty,
+        reference && !empty,
+    };
+    int num_coeffs = 4;
+    int uv;
+
+    put_bits(bw, 1, 0); // 8-bit payload size
+    put_bits(bw, 8, 0); // patched below
+    put_bits(bw, 3, reference ? 0 : 1);
+    put_bits(bw, 1, 1); // AV1 film grain
+    put_bits(bw, 16, 1);
+    put_bits(bw, 1, 1); // update_grain
+    put_bits(bw, 4, 0);
+    put_bits(bw, 12, 64);
+    put_bits(bw, 12, 32);
+    put_bits(bw, 1, 0); // not luma only
+    put_bits(bw, 1, 1);
+    put_bits(bw, 1, 1);
+    put_bits(bw, 1, 0); // no video signal characteristics
+    put_bits(bw, 1, !reference); // predict_scaling
+
+    if (!reference) {
+        put_bits(bw, 1, predict_y);
+        if (predict_y)
+            put_predicted_points(bw, bits_res);
+    }
+    if (!predict_y)
+        put_points(bw, 0, !y_points);
+
+    put_bits(bw, 1, 0); // chroma_scaling_from_luma
+    for (uv = 0; uv < 2; uv++) {
+        if (!reference)
+            put_bits(bw, 1, predict_uv[uv]);
+        if (predict_uv[uv])
+            put_predicted_points(bw, bits_res);
+        else
+            put_points(bw, 1, !uv_points[uv]);
+    }
+
+    put_bits(bw, 2, 1); // scaling_shift = 9
+    put_bits(bw, 2, 1); // ar_coeff_lag = 1
+    if (y_points || predict_y)
+        put_coeffs(bw, num_coeffs, -4);
+    for (uv = 0; uv < 2; uv++) {
+        if (uv_points[uv] || predict_uv[uv])
+            put_coeffs(bw, num_coeffs + !!(y_points || predict_y), 4 + uv * 8);
+    }
+    put_bits(bw, 2, 1); // ar_coeff_shift = 7
+    put_bits(bw, 2, 2); // grain_scale_shift = 2
+    for (uv = 0; uv < 2; uv++) {
+        if (uv_points[uv] && !predict_uv[uv]) {
+            put_bits(bw, 8, 130 + uv);
+            put_bits(bw, 8, 127 - uv);
+            put_bits(bw, 9, 259 + uv);
+        }
+    }
+    put_bits(bw, 1, 1);
+    put_bits(bw, 1, 0);
+
+    put_bits_at(bw, start + 1, 8, (bw->bits - start + 7) / 8);
+    while (bw->bits & 7)
+        put_bits(bw, 1, 0);
+}
+
+static int build_payload(uint8_t *payload, int component, int bits_res)
+{
+    BitWriter bw = { 0 };
+
+    put_bits(&bw, 1, 1);
+    put_bits(&bw, 4, 0);
+    put_bits(&bw, 3, 1); // two parameter sets
+    put_set(&bw, component, bits_res, 1);
+    put_set(&bw, component, bits_res, 0);
+    memcpy(payload, bw.data, (bw.bits + 7) / 8);
+
+    return (bw.bits + 7) / 8;
+}
+
+static void print_points(const char *name, int count, const uint8_t 
points[][2])
+{
+    int i;
+
+    printf("  %s[%d]", name, count);
+    for (i = 0; i < count; i++)
+        printf(" %d/%d", points[i][0], points[i][1]);
+    printf("\n");
+}
+
+static void print_coeffs(const char *name, const int8_t *coeffs, int count)
+{
+    int i;
+
+    printf("  %s[%d]", name, count);
+    for (i = 0; i < count; i++)
+        printf(" %d", coeffs[i]);
+    printf("\n");
+}
+
+static void run_case(const char *name, int component, int bits_res)
+{
+    AVFilmGrainAFGS1Params sets = { 0 };
+    uint8_t payload[128];
+    AVFilmGrainAOMParams *aom;
+    int y_coeffs = (component == Y || component == EMPTY) ? 4 : 0;
+    int cb_coeffs = (component == CB || component == EMPTY) ? 4 + !!y_coeffs : 
0;
+    int cr_coeffs = (component == CR || component == EMPTY) ? 4 + !!y_coeffs : 
0;
+    int ret = ff_aom_parse_film_grain_sets(&sets, payload,
+                                            build_payload(payload, component, 
bits_res));
+
+    printf("%s: ret=%d\n", name, ret);
+    if (ret || !sets.sets[1]) {
+        printf("  set=missing\n");
+        ff_aom_uninit_film_grain_params(&sets);
+        return;
+    }
+
+    aom = &((AVFilmGrainParams *)sets.sets[1]->data)->codec.aom;
+    print_points("y", aom->num_y_points, aom->y_points);
+    print_points("cb", aom->num_uv_points[0], aom->uv_points[0]);
+    print_points("cr", aom->num_uv_points[1], aom->uv_points[1]);
+    printf("  scaling=%d lag=%d ar_shift=%d grain_shift=%d\n",
+           aom->scaling_shift, aom->ar_coeff_lag, aom->ar_coeff_shift,
+           aom->grain_scale_shift);
+    print_coeffs("y_ar", aom->ar_coeffs_y, y_coeffs);
+    print_coeffs("cb_ar", aom->ar_coeffs_uv[0], cb_coeffs);
+    print_coeffs("cr_ar", aom->ar_coeffs_uv[1], cr_coeffs);
+    printf("  cb_uv=%d/%d/%d cr_uv=%d/%d/%d overlap=%d limit=%d\n",
+           aom->uv_mult[0], aom->uv_mult_luma[0], aom->uv_offset[0],
+           aom->uv_mult[1], aom->uv_mult_luma[1], aom->uv_offset[1],
+           aom->overlap_flag, aom->limit_output_range);
+    ff_aom_uninit_film_grain_params(&sets);
+}
+
+int main(void)
+{
+    run_case("y-zero", Y, 0);
+    run_case("y-nonzero", Y, 2);
+    run_case("cb-zero", CB, 0);
+    run_case("cb-nonzero", CB, 2);
+    run_case("cr-zero", CR, 0);
+    run_case("cr-nonzero", CR, 2);
+    run_case("empty-reference", EMPTY, 0);
+
+    return 0;
+}
diff --git a/tests/fate/libavcodec.mak b/tests/fate/libavcodec.mak
index 713b1feb368..157fd6b8ce4 100644
--- a/tests/fate/libavcodec.mak
+++ b/tests/fate/libavcodec.mak
@@ -51,6 +51,11 @@ fate-golomb: libavcodec/tests/golomb$(EXESUF)
 fate-golomb: CMD = run libavcodec/tests/golomb$(EXESUF)
 fate-golomb: CMP = null
 
+FATE_LIBAVCODEC-$(CONFIG_ITUT_T35) += fate-aom-film-grain
+fate-aom-film-grain: libavcodec/tests/aom_film_grain$(EXESUF)
+fate-aom-film-grain: CMD = run libavcodec/tests/aom_film_grain$(EXESUF)
+fate-aom-film-grain: REF = $(SRC_PATH)/tests/ref/fate/aom-film-grain
+
 FATE_LIBAVCODEC-$(CONFIG_DXV_ENCODER) += fate-hashtable
 fate-hashtable: libavcodec/tests/hashtable$(EXESUF)
 fate-hashtable: CMD = run libavcodec/tests/hashtable$(EXESUF)
diff --git a/tests/ref/fate/aom-film-grain b/tests/ref/fate/aom-film-grain
new file mode 100644
index 00000000000..8e592f32c68
--- /dev/null
+++ b/tests/ref/fate/aom-film-grain
@@ -0,0 +1,63 @@
+y-zero: ret=0
+  y[2] 8/12 20/20
+  cb[0]
+  cr[0]
+  scaling=9 lag=1 ar_shift=7 grain_shift=2
+  y_ar[4] -4 -3 -2 -1
+  cb_ar[0]
+  cr_ar[0]
+  cb_uv=0/0/0 cr_uv=0/0/0 overlap=1 limit=0
+y-nonzero: ret=0
+  y[2] 8/14 20/22
+  cb[0]
+  cr[0]
+  scaling=9 lag=1 ar_shift=7 grain_shift=2
+  y_ar[4] -4 -3 -2 -1
+  cb_ar[0]
+  cr_ar[0]
+  cb_uv=0/0/0 cr_uv=0/0/0 overlap=1 limit=0
+cb-zero: ret=0
+  y[0]
+  cb[2] 8/44 20/52
+  cr[0]
+  scaling=9 lag=1 ar_shift=7 grain_shift=2
+  y_ar[0]
+  cb_ar[4] 4 5 6 7
+  cr_ar[0]
+  cb_uv=2/-1/3 cr_uv=0/0/0 overlap=1 limit=0
+cb-nonzero: ret=0
+  y[0]
+  cb[2] 8/46 20/54
+  cr[0]
+  scaling=9 lag=1 ar_shift=7 grain_shift=2
+  y_ar[0]
+  cb_ar[4] 4 5 6 7
+  cr_ar[0]
+  cb_uv=2/-1/3 cr_uv=0/0/0 overlap=1 limit=0
+cr-zero: ret=0
+  y[0]
+  cb[0]
+  cr[2] 8/44 20/52
+  scaling=9 lag=1 ar_shift=7 grain_shift=2
+  y_ar[0]
+  cb_ar[0]
+  cr_ar[4] 12 13 14 15
+  cb_uv=0/0/0 cr_uv=3/-2/4 overlap=1 limit=0
+cr-nonzero: ret=0
+  y[0]
+  cb[0]
+  cr[2] 8/46 20/54
+  scaling=9 lag=1 ar_shift=7 grain_shift=2
+  y_ar[0]
+  cb_ar[0]
+  cr_ar[4] 12 13 14 15
+  cb_uv=0/0/0 cr_uv=3/-2/4 overlap=1 limit=0
+empty-reference: ret=0
+  y[0]
+  cb[0]
+  cr[0]
+  scaling=9 lag=1 ar_shift=7 grain_shift=2
+  y_ar[4] -4 -3 -2 -1
+  cb_ar[5] 4 5 6 7 8
+  cr_ar[5] 12 13 14 15 -16
+  cb_uv=0/0/0 cr_uv=0/0/0 overlap=1 limit=0
-- 
2.54.0


>From eb2b422342e3c6c33983d817cefebe4d018faf98 Mon Sep 17 00:00:00 2001
From: lusoris <[email protected]>
Date: Tue, 3 Nov 2026 14:35:40 +0100
Subject: [PATCH 2/3] avcodec/aom_film_grain: Skip absent explicit chroma
 points

AFGS1 signals the explicit chroma point increment width, scaling width
and scaling offset only when the point count of the plane is nonzero.
Do not read those absent fields, which would misalign every following
field of the parameter set.
---
 libavcodec/aom_film_grain.c       |   2 +
 libavcodec/tests/aom_film_grain.c | 113 ++++++++++++++++++++++++++++--
 tests/ref/fate/aom-film-grain     |  12 ++++
 3 files changed, 120 insertions(+), 7 deletions(-)

diff --git a/libavcodec/aom_film_grain.c b/libavcodec/aom_film_grain.c
index 7ba7f143730..85be3f406d9 100644
--- a/libavcodec/aom_film_grain.c
+++ b/libavcodec/aom_film_grain.c
@@ -293,6 +293,8 @@ int ff_aom_parse_film_grain_sets(AVFilmGrainAFGS1Params *s,
                         aom->num_uv_points[uv] = get_bits(gb, 4);
                         if (aom->num_uv_points[uv] > 10)
                             goto error;
+                        if (!aom->num_uv_points[uv])
+                            continue;
                         bits_inc = get_bits(gb, 3) + 1;
                         bits_scaling = get_bits(gb, 2) + 5;
                         uv_offset = get_bits(gb, 8);
diff --git a/libavcodec/tests/aom_film_grain.c 
b/libavcodec/tests/aom_film_grain.c
index e679fa8def2..6d967272d52 100644
--- a/libavcodec/tests/aom_film_grain.c
+++ b/libavcodec/tests/aom_film_grain.c
@@ -67,14 +67,8 @@ static void put_points(BitWriter *bw, int uv, int empty)
     int i;
 
     put_bits(bw, 4, empty ? 0 : 2);
-    if (empty) {
-        if (uv) {
-            put_bits(bw, 3, 3); // 4-bit point increments
-            put_bits(bw, 2, 1); // 6-bit scaling values
-            put_bits(bw, 8, 32);
-        }
+    if (empty)
         return;
-    }
 
     put_bits(bw, 3, 3); // 4-bit point increments
     put_bits(bw, 2, 1); // 6-bit scaling values
@@ -101,6 +95,24 @@ static void put_predicted_points(BitWriter *bw, int 
bits_res)
     put_bits(bw, 3, 2);
 }
 
+static void put_explicit_points(BitWriter *bw, int uv, int count)
+{
+    int i;
+
+    put_bits(bw, 4, count);
+    if (!count)
+        return;
+
+    put_bits(bw, 3, 3); // 4-bit point increments
+    put_bits(bw, 2, 1); // 6-bit scaling values
+    if (uv)
+        put_bits(bw, 8, 32);
+    for (i = 0; i < count; i++) {
+        put_bits(bw, 4, 8 + 4 * i);
+        put_bits(bw, 6, 12 + 8 * i);
+    }
+}
+
 static void put_set(BitWriter *bw, int component, int bits_res, int reference)
 {
     int start = bw->bits;
@@ -190,6 +202,66 @@ static int build_payload(uint8_t *payload, int component, 
int bits_res)
     return (bw.bits + 7) / 8;
 }
 
+static int build_explicit_payload(uint8_t *payload, int y_points,
+                                  int cb_points, int cr_points)
+{
+    BitWriter bw = { 0 };
+    int uv_points[2] = { cb_points, cr_points };
+    int start;
+    int uv;
+
+    put_bits(&bw, 1, 1);
+    put_bits(&bw, 4, 0);
+    put_bits(&bw, 3, 0); // one parameter set
+
+    start = bw.bits;
+      put_bits(&bw, 1, 0); // 8-bit payload size
+      put_bits(&bw, 8, 0); // patched below
+      put_bits(&bw, 3, 0);
+      put_bits(&bw, 1, 1); // AV1 film grain
+      put_bits(&bw, 16, 1);
+      put_bits(&bw, 1, 1); // update_grain
+      put_bits(&bw, 4, 0);
+      put_bits(&bw, 12, 64);
+      put_bits(&bw, 12, 32);
+      put_bits(&bw, 1, 0); // not luma only
+      put_bits(&bw, 1, 1);
+      put_bits(&bw, 1, 1);
+      put_bits(&bw, 1, 0); // no video signal characteristics
+      put_bits(&bw, 1, 0); // no predicted scaling
+      put_explicit_points(&bw, 0, y_points);
+      put_bits(&bw, 1, 0); // chroma_scaling_from_luma
+      for (uv = 0; uv < 2; uv++)
+          put_explicit_points(&bw, 1, uv_points[uv]);
+
+      put_bits(&bw, 2, 1); // scaling_shift = 9
+      put_bits(&bw, 2, 1); // ar_coeff_lag = 1
+      if (y_points)
+          put_coeffs(&bw, 4, -4);
+      for (uv = 0; uv < 2; uv++) {
+          if (uv_points[uv])
+              put_coeffs(&bw, 4 + !!y_points, 4 + uv * 8);
+      }
+      put_bits(&bw, 2, 1); // ar_coeff_shift = 7
+      put_bits(&bw, 2, 2); // grain_scale_shift = 2
+      for (uv = 0; uv < 2; uv++) {
+          if (uv_points[uv]) {
+              put_bits(&bw, 8, 130 + uv);
+              put_bits(&bw, 8, 127 - uv);
+              put_bits(&bw, 9, 259 + uv);
+          }
+      }
+      put_bits(&bw, 1, 1);
+      put_bits(&bw, 1, 0);
+
+      put_bits_at(&bw, start + 1, 8, (bw.bits - start + 7) / 8);
+      while (bw.bits & 7)
+          put_bits(&bw, 1, 0);
+
+    memcpy(payload, bw.data, (bw.bits + 7) / 8);
+    return (bw.bits + 7) / 8;
+}
+
 static void print_points(const char *name, int count, const uint8_t 
points[][2])
 {
     int i;
@@ -245,6 +317,30 @@ static void run_case(const char *name, int component, int 
bits_res)
     ff_aom_uninit_film_grain_params(&sets);
 }
 
+static void run_explicit_case(const char *name, int y_points,
+                              int cb_points, int cr_points)
+{
+    AVFilmGrainAFGS1Params sets = { 0 };
+    uint8_t payload[128];
+    AVFilmGrainAOMParams *aom;
+    int ret = ff_aom_parse_film_grain_sets(&sets, payload,
+                                            build_explicit_payload(payload, 
y_points,
+                                                                   cb_points, 
cr_points));
+
+    printf("%s: ret=%d\n", name, ret);
+    if (ret || !sets.sets[0]) {
+        printf("  set=missing\n");
+        ff_aom_uninit_film_grain_params(&sets);
+        return;
+    }
+
+    aom = &((AVFilmGrainParams *)sets.sets[0]->data)->codec.aom;
+    print_points("y", aom->num_y_points, aom->y_points);
+    print_points("cb", aom->num_uv_points[0], aom->uv_points[0]);
+    print_points("cr", aom->num_uv_points[1], aom->uv_points[1]);
+    ff_aom_uninit_film_grain_params(&sets);
+}
+
 int main(void)
 {
     run_case("y-zero", Y, 0);
@@ -254,6 +350,9 @@ int main(void)
     run_case("cr-zero", CR, 0);
     run_case("cr-nonzero", CR, 2);
     run_case("empty-reference", EMPTY, 0);
+    run_explicit_case("explicit-y-cb0-cr", 1, 0, 1);
+    run_explicit_case("explicit-y-cb-cr0", 1, 1, 0);
+    run_explicit_case("explicit-y-cb0-cr0", 1, 0, 0);
 
     return 0;
 }
diff --git a/tests/ref/fate/aom-film-grain b/tests/ref/fate/aom-film-grain
index 8e592f32c68..4dfe9067959 100644
--- a/tests/ref/fate/aom-film-grain
+++ b/tests/ref/fate/aom-film-grain
@@ -61,3 +61,15 @@ empty-reference: ret=0
   cb_ar[5] 4 5 6 7 8
   cr_ar[5] 12 13 14 15 -16
   cb_uv=0/0/0 cr_uv=0/0/0 overlap=1 limit=0
+explicit-y-cb0-cr: ret=0
+  y[1] 8/12
+  cb[0]
+  cr[1] 8/44
+explicit-y-cb-cr0: ret=0
+  y[1] 8/12
+  cb[1] 8/44
+  cr[0]
+explicit-y-cb0-cr0: ret=0
+  y[1] 8/12
+  cb[0]
+  cr[0]
-- 
2.54.0


>From 6ed95d20d0df017d13dbe9bd2a0bc3995ba189ce Mon Sep 17 00:00:00 2001
From: lusoris <[email protected]>
Date: Tue, 3 Nov 2026 14:36:57 +0100
Subject: [PATCH 3/3] avcodec/aom_film_grain: Skip padding of parameter sets
 without grain

A parameter set with apply_grain_flag or update_grain_flag equal to 0
ends early, but its payload is still padded to payload_size bytes.
Consume that padding as for any other payload so the next parameter
set is read from the right position, and do not export a set in that
case.
---
 libavcodec/aom_film_grain.c       |  8 +++--
 libavcodec/tests/aom_film_grain.c | 54 +++++++++++++++++++++++++++++++
 tests/ref/fate/aom-film-grain     |  4 +++
 3 files changed, 64 insertions(+), 2 deletions(-)

diff --git a/libavcodec/aom_film_grain.c b/libavcodec/aom_film_grain.c
index 85be3f406d9..5cb67460c4e 100644
--- a/libavcodec/aom_film_grain.c
+++ b/libavcodec/aom_film_grain.c
@@ -161,14 +161,14 @@ int ff_aom_parse_film_grain_sets(AVFilmGrainAFGS1Params 
*s,
         fgp->type = get_bits1(gb) ? AV_FILM_GRAIN_PARAMS_AV1 : 
AV_FILM_GRAIN_PARAMS_NONE;
         if (!fgp->type) {
             av_freep(&fgp);
-            continue;
+            goto skip_payload;
         }
 
         fgp->seed = get_bits(gb, 16);
         update_grain = get_bits1(gb);
         if (!update_grain) {
             av_freep(&fgp);
-            continue;
+            goto skip_payload;
         }
 
         apply_units_log2  = get_bits(gb, 4);
@@ -343,11 +343,15 @@ int ff_aom_parse_film_grain_sets(AVFilmGrainAFGS1Params 
*s,
         if (n == 0)
             ref = fgp;
 
+skip_payload:
         payload_bits = get_bits_count(gb) - start_position;
         if (payload_bits > payload_size * 8)
             goto error;
         skip_bits(gb, payload_size * 8 - payload_bits);
 
+        if (!fgp)
+            continue;
+
         av_buffer_unref(&s->sets[set_idx]);
         s->sets[set_idx] = av_buffer_create((uint8_t *)fgp, fgp_size, NULL, 
NULL, 0);
         if (!s->sets[set_idx])
diff --git a/libavcodec/tests/aom_film_grain.c 
b/libavcodec/tests/aom_film_grain.c
index 6d967272d52..fe325de6a4d 100644
--- a/libavcodec/tests/aom_film_grain.c
+++ b/libavcodec/tests/aom_film_grain.c
@@ -262,6 +262,38 @@ static int build_explicit_payload(uint8_t *payload, int 
y_points,
     return (bw.bits + 7) / 8;
 }
 
+static void put_skipped_set(BitWriter *bw, int update_grain)
+{
+    int start = bw->bits;
+    int payload_size;
+
+    put_bits(bw, 1, !update_grain); // payload_less_than_4byte_flag
+    payload_size = update_grain ? 4 : 1;
+    put_bits(bw, update_grain ? 8 : 2, payload_size);
+    put_bits(bw, 3, 0);
+    put_bits(bw, 1, update_grain);
+    if (update_grain) {
+        put_bits(bw, 16, 1);
+        put_bits(bw, 1, 0);
+    }
+    while (bw->bits - start < payload_size * 8)
+        put_bits(bw, 1, 0);
+}
+
+static int build_padded_payload(uint8_t *payload, int update_grain)
+{
+    BitWriter bw = { 0 };
+
+    put_bits(&bw, 1, 1);
+    put_bits(&bw, 4, 0);
+    put_bits(&bw, 3, 1); // two parameter sets
+    put_skipped_set(&bw, update_grain);
+    put_set(&bw, Y, 0, 1);
+    memcpy(payload, bw.data, (bw.bits + 7) / 8);
+
+    return (bw.bits + 7) / 8;
+}
+
 static void print_points(const char *name, int count, const uint8_t 
points[][2])
 {
     int i;
@@ -341,6 +373,26 @@ static void run_explicit_case(const char *name, int 
y_points,
     ff_aom_uninit_film_grain_params(&sets);
 }
 
+static void run_padded_case(const char *name, int update_grain)
+{
+    AVFilmGrainAFGS1Params sets = { 0 };
+    uint8_t payload[128];
+    AVFilmGrainAOMParams *aom;
+    int ret = ff_aom_parse_film_grain_sets(&sets, payload,
+                                            build_padded_payload(payload, 
update_grain));
+
+    printf("%s: ret=%d\n", name, ret);
+    if (ret || !sets.sets[0]) {
+        printf("  set=missing\n");
+        ff_aom_uninit_film_grain_params(&sets);
+        return;
+    }
+
+    aom = &((AVFilmGrainParams *)sets.sets[0]->data)->codec.aom;
+    print_points("y", aom->num_y_points, aom->y_points);
+    ff_aom_uninit_film_grain_params(&sets);
+}
+
 int main(void)
 {
     run_case("y-zero", Y, 0);
@@ -353,6 +405,8 @@ int main(void)
     run_explicit_case("explicit-y-cb0-cr", 1, 0, 1);
     run_explicit_case("explicit-y-cb-cr0", 1, 1, 0);
     run_explicit_case("explicit-y-cb0-cr0", 1, 0, 0);
+    run_padded_case("padded-apply-grain-zero", 0);
+    run_padded_case("padded-update-grain-zero", 1);
 
     return 0;
 }
diff --git a/tests/ref/fate/aom-film-grain b/tests/ref/fate/aom-film-grain
index 4dfe9067959..1f7246d14e5 100644
--- a/tests/ref/fate/aom-film-grain
+++ b/tests/ref/fate/aom-film-grain
@@ -73,3 +73,7 @@ explicit-y-cb0-cr0: ret=0
   y[1] 8/12
   cb[0]
   cr[0]
+padded-apply-grain-zero: ret=0
+  y[2] 8/12 20/20
+padded-update-grain-zero: ret=0
+  y[2] 8/12 20/20
-- 
2.54.0

_______________________________________________
ffmpeg-devel mailing list -- [email protected]
To unsubscribe send an email to [email protected]

Reply via email to