tools/gen_wedge_masks_data.py - aom - Git at Google


            
            #!/usr/bin/env python3

            
            ## Copyright (c) 2026, Alliance for Open Media. All rights reserved.

            
            ##

            
            ## This source code is subject to the terms of the BSD 2 Clause License and

            
            ## the Alliance for Open Media Patent License 1.0. If the BSD 2 Clause License

            
            ## was not distributed with this source code in the LICENSE file, you can

            
            ## obtain it at www.aomedia.org/license/software. If the Alliance for Open

            
            ## Media Patent License 1.0 was not distributed with this source code in the

            
            ## PATENTS file, you can obtain it at www.aomedia.org/license/patent.

            
            ##

            
            # Precompute libaom AV1 wedge / inter-intra blending masks at codegen time

            
            # so they can live in `.rdata` and be COW shared across processes instead

            
            # of being computed at runtime into writable `.data` buffers.

            
            #

            
            # Output is a header fragment included by av1/common/reconinter.c that

            
            # defines:

            
            #   - wedge_mask_obl            (input to wedge_mask_buf generation)

            
            #   - wedge_mask_buf            (compound prediction masks, indexed by offset)

            
            #   - smooth_interintra_mask_buf

            
            #   - wedge_masks               (offsets into wedge_mask_buf)

            
            #

            
            # The algorithms in this file mirror init_wedge_master_masks(),

            
            # init_wedge_masks() and init_smooth_interintra_masks() in

            
            # av1/common/reconinter.c. They must stay in sync with that source. If those

            
            # helpers, the master tables, the wedge codebooks, the block-size enum, or

            
            # ii_weights1d ever change upstream, regenerate the .inc by running this

            
            # script and committing the result.

            
            #

            
            # Regenerate:

            
            #   python3 source/libaom/tools/gen_wedge_masks_data.py

            
            #       --output source/libaom/av1/common/wedge_masks_data.inc


            import argparse

            
            import os

            
            import sys

            
            import textwrap


            # -----------------------------------------------------------------------------

            
            # Constants (must match reconinter.h / enums.h).

            
            # -----------------------------------------------------------------------------

            
            MAX_WEDGE_TYPES = 16

            
            MAX_WEDGE_SIZE_LOG2 = 5

            
            MAX_WEDGE_SIZE = 1 << MAX_WEDGE_SIZE_LOG2  # 32

            
            MAX_WEDGE_SQUARE = MAX_WEDGE_SIZE * MAX_WEDGE_SIZE  # 1024

            
            MASK_MASTER_SIZE = MAX_WEDGE_SIZE << 1  # 64

            
            MASK_MASTER_STRIDE = MASK_MASTER_SIZE

            
            WEDGE_WEIGHT_BITS = 6

            
            INTERINTRA_MODES = 4

            
            MAX_SB_SIZE_LOG2 = 7

            
            MAX_SB_SIZE = 1 << MAX_SB_SIZE_LOG2  # 128


            # WedgeDirectionType.

            
            WEDGE_HORIZONTAL = 0

            
            WEDGE_VERTICAL = 1

            
            WEDGE_OBLIQUE27 = 2

            
            WEDGE_OBLIQUE63 = 3

            
            WEDGE_OBLIQUE117 = 4

            
            WEDGE_OBLIQUE153 = 5

            
            WEDGE_DIRECTIONS = 6


            # BLOCK_SIZE enum order (must match enums.h).

            
            BLOCK_NAMES = [

            
                "BLOCK_4X4",     "BLOCK_4X8",     "BLOCK_8X4",     "BLOCK_8X8",

            
                "BLOCK_8X16",    "BLOCK_16X8",    "BLOCK_16X16",   "BLOCK_16X32",

            
                "BLOCK_32X16",   "BLOCK_32X32",   "BLOCK_32X64",   "BLOCK_64X32",

            
                "BLOCK_64X64",   "BLOCK_64X128",  "BLOCK_128X64",  "BLOCK_128X128",

            
                "BLOCK_4X16",    "BLOCK_16X4",    "BLOCK_8X32",    "BLOCK_32X8",

            
                "BLOCK_16X64",   "BLOCK_64X16",

            
            ]

            
            BLOCK_SIZES_ALL = len(BLOCK_NAMES)


            def _parse_block_dims(name):

            
                # e.g. "BLOCK_8X16" -> (8, 16)

            
                body = name.split("_", 1)[1]

            
                w, h = body.split("X")

            
                return int(w), int(h)


            BLOCK_WIDTH = [_parse_block_dims(n)[0] for n in BLOCK_NAMES]

            
            BLOCK_HEIGHT = [_parse_block_dims(n)[1] for n in BLOCK_NAMES]


            def _bi(name):

            
                return BLOCK_NAMES.index(name)


            # Inter-intra modes (must match enums.h).

            
            II_DC_PRED, II_V_PRED, II_H_PRED, II_SMOOTH_PRED = 0, 1, 2, 3


            # -----------------------------------------------------------------------------

            
            # Master mask tables (see wedge_master_oblique_odd / _even / _vertical in

            
            # av1/common/reconinter.c).

            
            # -----------------------------------------------------------------------------

            
            WEDGE_MASTER_OBLIQUE_ODD = [

            
                0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,

            
                0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  1,  2,  6,  18,

            
                37, 53, 60, 63, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64,

            
                64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64,

            
            ]

            
            WEDGE_MASTER_OBLIQUE_EVEN = [

            
                0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,

            
                0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  1,  4,  11, 27,

            
                46, 58, 62, 63, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64,

            
                64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64,

            
            ]

            
            WEDGE_MASTER_VERTICAL = [

            
                0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,

            
                0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  2,  7,  21,

            
                43, 57, 62, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64,

            
                64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64,

            
            ]


            # wedge_signflip_lookup (see av1/common/reconinter.c).

            
            WEDGE_SIGNFLIP_LOOKUP = [

            
                [0]*16, [0]*16, [0]*16,

            
                [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1],  # BLOCK_8X8

            
                [1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1],  # BLOCK_8X16

            
                [1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1],  # BLOCK_16X8

            
                [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1],  # BLOCK_16X16

            
                [1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1],  # BLOCK_16X32

            
                [1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1],  # BLOCK_32X16

            
                [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1],  # BLOCK_32X32

            
                [0]*16, [0]*16, [0]*16, [0]*16, [0]*16, [0]*16, [0]*16, [0]*16,

            
                [1, 1, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 1, 0, 1],  # BLOCK_8X32

            
                [1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 0, 1, 0, 1],  # BLOCK_32X8

            
                [0]*16, [0]*16,

            
            ]

            
            assert len(WEDGE_SIGNFLIP_LOOKUP) == BLOCK_SIZES_ALL


            # Wedge codebooks (see wedge_codebook_16_* in av1/common/reconinter.c).

            
            # Each entry is

            
            # (direction, x_offset, y_offset).

            
            WEDGE_CODEBOOK_16_HGTW = [

            
                (WEDGE_OBLIQUE27, 4, 4),  (WEDGE_OBLIQUE63, 4, 4),

            
                (WEDGE_OBLIQUE117, 4, 4), (WEDGE_OBLIQUE153, 4, 4),

            
                (WEDGE_HORIZONTAL, 4, 2), (WEDGE_HORIZONTAL, 4, 4),

            
                (WEDGE_HORIZONTAL, 4, 6), (WEDGE_VERTICAL, 4, 4),

            
                (WEDGE_OBLIQUE27, 4, 2),  (WEDGE_OBLIQUE27, 4, 6),

            
                (WEDGE_OBLIQUE153, 4, 2), (WEDGE_OBLIQUE153, 4, 6),

            
                (WEDGE_OBLIQUE63, 2, 4),  (WEDGE_OBLIQUE63, 6, 4),

            
                (WEDGE_OBLIQUE117, 2, 4), (WEDGE_OBLIQUE117, 6, 4),

            
            ]

            
            WEDGE_CODEBOOK_16_HLTW = [

            
                (WEDGE_OBLIQUE27, 4, 4),  (WEDGE_OBLIQUE63, 4, 4),

            
                (WEDGE_OBLIQUE117, 4, 4), (WEDGE_OBLIQUE153, 4, 4),

            
                (WEDGE_VERTICAL, 2, 4),   (WEDGE_VERTICAL, 4, 4),

            
                (WEDGE_VERTICAL, 6, 4),   (WEDGE_HORIZONTAL, 4, 4),

            
                (WEDGE_OBLIQUE27, 4, 2),  (WEDGE_OBLIQUE27, 4, 6),

            
                (WEDGE_OBLIQUE153, 4, 2), (WEDGE_OBLIQUE153, 4, 6),

            
                (WEDGE_OBLIQUE63, 2, 4),  (WEDGE_OBLIQUE63, 6, 4),

            
                (WEDGE_OBLIQUE117, 2, 4), (WEDGE_OBLIQUE117, 6, 4),

            
            ]

            
            WEDGE_CODEBOOK_16_HEQW = [

            
                (WEDGE_OBLIQUE27, 4, 4),  (WEDGE_OBLIQUE63, 4, 4),

            
                (WEDGE_OBLIQUE117, 4, 4), (WEDGE_OBLIQUE153, 4, 4),

            
                (WEDGE_HORIZONTAL, 4, 2), (WEDGE_HORIZONTAL, 4, 6),

            
                (WEDGE_VERTICAL, 2, 4),   (WEDGE_VERTICAL, 6, 4),

            
                (WEDGE_OBLIQUE27, 4, 2),  (WEDGE_OBLIQUE27, 4, 6),

            
                (WEDGE_OBLIQUE153, 4, 2), (WEDGE_OBLIQUE153, 4, 6),

            
                (WEDGE_OBLIQUE63, 2, 4),  (WEDGE_OBLIQUE63, 6, 4),

            
                (WEDGE_OBLIQUE117, 2, 4), (WEDGE_OBLIQUE117, 6, 4),

            
            ]


            # av1_wedge_params_lookup. Stored here as (wtypes, codebook). The masks/

            
            # signflip pointers are reconstructed from BLOCK index. See

            
            # av1_wedge_params_lookup in av1/common/reconinter.c.

            
            WEDGE_PARAMS_LOOKUP = [

            
                (0, None),

            
                (0, None),

            
                (0, None),

            
                (MAX_WEDGE_TYPES, WEDGE_CODEBOOK_16_HEQW),  # BLOCK_8X8

            
                (MAX_WEDGE_TYPES, WEDGE_CODEBOOK_16_HGTW),  # BLOCK_8X16

            
                (MAX_WEDGE_TYPES, WEDGE_CODEBOOK_16_HLTW),  # BLOCK_16X8

            
                (MAX_WEDGE_TYPES, WEDGE_CODEBOOK_16_HEQW),  # BLOCK_16X16

            
                (MAX_WEDGE_TYPES, WEDGE_CODEBOOK_16_HGTW),  # BLOCK_16X32

            
                (MAX_WEDGE_TYPES, WEDGE_CODEBOOK_16_HLTW),  # BLOCK_32X16

            
                (MAX_WEDGE_TYPES, WEDGE_CODEBOOK_16_HEQW),  # BLOCK_32X32

            
                (0, None), (0, None), (0, None), (0, None),

            
                (0, None), (0, None), (0, None), (0, None),

            
                (MAX_WEDGE_TYPES, WEDGE_CODEBOOK_16_HGTW),  # BLOCK_8X32

            
                (MAX_WEDGE_TYPES, WEDGE_CODEBOOK_16_HLTW),  # BLOCK_32X8

            
                (0, None), (0, None),

            
            ]

            
            assert len(WEDGE_PARAMS_LOOKUP) == BLOCK_SIZES_ALL


            # ii_weights1d (see av1/common/reconinter.c).

            
            II_WEIGHTS_1D = [

            
                60, 58, 56, 54, 52, 50, 48, 47, 45, 44, 42, 41, 39, 38, 37, 35, 34, 33, 32,

            
                31, 30, 29, 28, 27, 26, 25, 24, 23, 22, 22, 21, 20, 19, 19, 18, 18, 17, 16,

            
                16, 15, 15, 14, 14, 13, 13, 12, 12, 12, 11, 11, 10, 10, 10,  9,  9,  9,  8,

            
                8,  8,  8,  7,  7,  7,  7,  6,  6,  6,  6,  6,  5,  5,  5,  5,  5,  4,  4,

            
                4,  4,  4,  4,  4,  4,  3,  3,  3,  3,  3,  3,  3,  3,  3,  2,  2,  2,  2,

            
                2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  1,  1,  1,  1,  1,  1,  1,  1,

            
                1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,

            
            ]

            
            assert len(II_WEIGHTS_1D) == MAX_SB_SIZE


            # ii_size_scales (see av1/common/reconinter.c).

            
            II_SIZE_SCALES = [

            
                32, 16, 16, 16, 8, 8, 8, 4,

            
                4,  4,  2,  2,  2, 1, 1, 1,

            
                8,  8,  4,  4,  2, 2,

            
            ]

            
            assert len(II_SIZE_SCALES) == BLOCK_SIZES_ALL


            # -----------------------------------------------------------------------------

            
            # Algorithm: build wedge_mask_obl (init_wedge_master_masks in reconinter.c).

            
            # -----------------------------------------------------------------------------

            
            def shift_copy(src, dst, dst_off, shift, width):

            
                """Mirrors shift_copy() in reconinter.c."""

            
                if shift >= 0:

            
                    for i in range(width - shift):

            
                        dst[dst_off + shift + i] = src[i]

            
                    for i in range(shift):

            
                        dst[dst_off + i] = src[0]

            
                else:

            
                    n = -shift

            
                    for i in range(width - n):

            
                        dst[dst_off + i] = src[n + i]

            
                    for i in range(n):

            
                        dst[dst_off + width - n + i] = src[width - 1]


            def build_wedge_mask_obl():

            
                # [negative][direction] indexed flat per direction, MASK_MASTER_SIZE^2 bytes.

            
                obl = [[[0] * (MASK_MASTER_SIZE * MASK_MASTER_SIZE)

            
                        for _ in range(WEDGE_DIRECTIONS)]

            
                       for _ in range(2)]


                w = MASK_MASTER_SIZE

            
                h = MASK_MASTER_SIZE

            
                stride = MASK_MASTER_STRIDE

            
                shift = h // 4

            
                i = 0

            
                while i < h:

            
                    shift_copy(WEDGE_MASTER_OBLIQUE_EVEN,

            
                               obl[0][WEDGE_OBLIQUE63], i * stride, shift, MASK_MASTER_SIZE)

            
                    shift -= 1

            
                    shift_copy(WEDGE_MASTER_OBLIQUE_ODD,

            
                               obl[0][WEDGE_OBLIQUE63], (i + 1) * stride, shift,

            
                               MASK_MASTER_SIZE)

            
                    # Vertical rows are just the vertical master copied each row.

            
                    for k in range(MASK_MASTER_SIZE):

            
                        obl[0][WEDGE_VERTICAL][i * stride + k] = WEDGE_MASTER_VERTICAL[k]

            
                        obl[0][WEDGE_VERTICAL][(i + 1) * stride + k] = (

            
                            WEDGE_MASTER_VERTICAL[k])

            
                    i += 2


                max_val = 1 << WEDGE_WEIGHT_BITS  # 64

            
                for i in range(h):

            
                    for j in range(w):

            
                        msk = obl[0][WEDGE_OBLIQUE63][i * stride + j]

            
                        obl[0][WEDGE_OBLIQUE27][j * stride + i] = msk

            
                        obl[0][WEDGE_OBLIQUE117][i * stride + w - 1 - j] = max_val - msk

            
                        obl[0][WEDGE_OBLIQUE153][(w - 1 - j) * stride + i] = max_val - msk

            
                        obl[1][WEDGE_OBLIQUE63][i * stride + j] = max_val - msk

            
                        obl[1][WEDGE_OBLIQUE27][j * stride + i] = max_val - msk

            
                        obl[1][WEDGE_OBLIQUE117][i * stride + w - 1 - j] = msk

            
                        obl[1][WEDGE_OBLIQUE153][(w - 1 - j) * stride + i] = msk

            
                        mskx = obl[0][WEDGE_VERTICAL][i * stride + j]

            
                        obl[0][WEDGE_HORIZONTAL][j * stride + i] = mskx

            
                        obl[1][WEDGE_VERTICAL][i * stride + j] = max_val - mskx

            
                        obl[1][WEDGE_HORIZONTAL][j * stride + i] = max_val - mskx


                return obl


            # -----------------------------------------------------------------------------

            
            # Algorithm: build wedge_mask_buf and wedge_masks offset table

            
            # (init_wedge_masks + get_wedge_mask_inplace + aom_convolve_copy).

            
            # -----------------------------------------------------------------------------

            
            def get_wedge_mask_inplace_offset(wedge_obl, w_idx, neg, bsize):

            
                """Compute the starting (row, col) into wedge_mask_obl[neg^wsignflip][dir]

            
                for a given wedge index/sign/block-size; mirrors get_wedge_mask_inplace().

            
                Returns (which_neg, direction, row_off, col_off)."""

            
                bw = BLOCK_WIDTH[bsize]

            
                bh = BLOCK_HEIGHT[bsize]

            
                wtypes, codebook = WEDGE_PARAMS_LOOKUP[bsize]

            
                assert wtypes > 0

            
                direction, x_off, y_off = codebook[w_idx]

            
                woff = (x_off * bw) >> 3

            
                hoff = (y_off * bh) >> 3

            
                wsignflip = WEDGE_SIGNFLIP_LOOKUP[bsize][w_idx]

            
                which = neg ^ wsignflip

            
                row_off = MASK_MASTER_SIZE // 2 - hoff

            
                col_off = MASK_MASTER_SIZE // 2 - woff

            
                return which, direction, row_off, col_off


            def build_wedge_mask_buf(obl):

            
                buf_size = 2 * MAX_WEDGE_TYPES * 4 * MAX_WEDGE_SQUARE

            
                buf = [0] * buf_size


                # Offset table: wedge_masks[bsize][sign][wedge_index] -> uint32 offset.

            
                offsets = [[[0] * MAX_WEDGE_TYPES for _ in range(2)]

            
                           for _ in range(BLOCK_SIZES_ALL)]


                dst = 0

            
                for bsize in range(BLOCK_SIZES_ALL):

            
                    wtypes, _ = WEDGE_PARAMS_LOOKUP[bsize]

            
                    if wtypes == 0:

            
                        continue

            
                    bw = BLOCK_WIDTH[bsize]

            
                    bh = BLOCK_HEIGHT[bsize]

            
                    for w_idx in range(wtypes):

            
                        # sign 0

            
                        which, direction, row_off, col_off = (

            
                            get_wedge_mask_inplace_offset(obl, w_idx, 0, bsize))

            
                        src = obl[which][direction]

            
                        for r in range(bh):

            
                            for c in range(bw):

            
                                buf[dst + r * bw + c] = src[

            
                                    (row_off + r) * MASK_MASTER_STRIDE + (col_off + c)]

            
                        offsets[bsize][0][w_idx] = dst

            
                        dst += bw * bh


                        # sign 1

            
                        which, direction, row_off, col_off = (

            
                            get_wedge_mask_inplace_offset(obl, w_idx, 1, bsize))

            
                        src = obl[which][direction]

            
                        for r in range(bh):

            
                            for c in range(bw):

            
                                buf[dst + r * bw + c] = src[

            
                                    (row_off + r) * MASK_MASTER_STRIDE + (col_off + c)]

            
                        offsets[bsize][1][w_idx] = dst

            
                        dst += bw * bh


                assert dst <= buf_size, (dst, buf_size)

            
                return buf, offsets


            # -----------------------------------------------------------------------------

            
            # Algorithm: build smooth_interintra_mask_buf

            
            # (init_smooth_interintra_masks + build_smooth_interintra_mask).

            
            # -----------------------------------------------------------------------------

            
            def build_smooth_interintra(mask, mask_off, stride, plane_bsize, mode):

            
                bw = BLOCK_WIDTH[plane_bsize]

            
                bh = BLOCK_HEIGHT[plane_bsize]

            
                size_scale = II_SIZE_SCALES[plane_bsize]

            
                if mode == II_V_PRED:

            
                    for i in range(bh):

            
                        row = mask_off + i * stride

            
                        val = II_WEIGHTS_1D[i * size_scale]

            
                        for j in range(bw):

            
                            mask[row + j] = val

            
                elif mode == II_H_PRED:

            
                    for i in range(bh):

            
                        row = mask_off + i * stride

            
                        for j in range(bw):

            
                            mask[row + j] = II_WEIGHTS_1D[j * size_scale]

            
                elif mode == II_SMOOTH_PRED:

            
                    for i in range(bh):

            
                        row = mask_off + i * stride

            
                        for j in range(bw):

            
                            mask[row + j] = II_WEIGHTS_1D[min(i, j) * size_scale]

            
                else:  # II_DC_PRED or default

            
                    for i in range(bh):

            
                        row = mask_off + i * stride

            
                        for j in range(bw):

            
                            mask[row + j] = 32


            def build_smooth_interintra_mask_buf():

            
                # [INTERINTRA_MODES][BLOCK_SIZES_ALL][MAX_WEDGE_SQUARE]

            
                buf = [[[0] * MAX_WEDGE_SQUARE for _ in range(BLOCK_SIZES_ALL)]

            
                       for _ in range(INTERINTRA_MODES)]

            
                for m in range(INTERINTRA_MODES):

            
                    for bs in range(BLOCK_SIZES_ALL):

            
                        bw = BLOCK_WIDTH[bs]

            
                        bh = BLOCK_HEIGHT[bs]

            
                        if bw > MAX_WEDGE_SIZE or bh > MAX_WEDGE_SIZE:

            
                            continue

            
                        build_smooth_interintra(buf[m][bs], 0, bw, bs, m)

            
                return buf


            # -----------------------------------------------------------------------------

            
            # C emission helpers.

            
            # -----------------------------------------------------------------------------

            
            def emit_bytes_block(values, indent="    ", per_line=16):

            
                lines = []

            
                for chunk_start in range(0, len(values), per_line):

            
                    chunk = values[chunk_start:chunk_start + per_line]

            
                    parts = ["{:>3d}".format(v) for v in chunk]

            
                    lines.append(indent + ", ".join(parts) + ",")

            
                return "\n".join(lines)


            def emit_wedge_mask_obl(out, obl):

            
                out.append(

            
                    "DECLARE_ALIGNED(16, static const uint8_t,")

            
                out.append(

            
                    "                wedge_mask_obl[2][WEDGE_DIRECTIONS]")

            
                out.append(

            
                    "                              [MASK_MASTER_SIZE * MASK_MASTER_SIZE]) = {")

            
                for neg in range(2):

            
                    out.append("  {")

            
                    for direction in range(WEDGE_DIRECTIONS):

            
                        out.append("    {{  // [{}][dir={}]".format(neg, direction))

            
                        out.append(emit_bytes_block(obl[neg][direction], indent="      "))

            
                        out.append("    },")

            
                    out.append("  },")

            
                out.append("};")


            def emit_wedge_mask_buf(out, buf):

            
                out.append(

            
                    "DECLARE_ALIGNED(16, static const uint8_t,")

            
                out.append(

            
                    "                wedge_mask_buf[2 * MAX_WEDGE_TYPES * 4 *"

            
                    " MAX_WEDGE_SQUARE]) = {")

            
                out.append(emit_bytes_block(buf, indent="  "))

            
                out.append("};")


            def emit_smooth_interintra(out, buf):

            
                out.append(

            
                    "DECLARE_ALIGNED(16, static const uint8_t,")

            
                out.append(

            
                    "                smooth_interintra_mask_buf[INTERINTRA_MODES]")

            
                out.append(

            
                    "                                          [BLOCK_SIZES_ALL]")

            
                out.append(

            
                    "                                          [MAX_WEDGE_SQUARE]) = {")

            
                for m in range(INTERINTRA_MODES):

            
                    out.append("  {")

            
                    for bs in range(BLOCK_SIZES_ALL):

            
                        out.append("    {{  // mode={}, bsize={}".format(m, BLOCK_NAMES[bs]))

            
                        out.append(emit_bytes_block(buf[m][bs], indent="      "))

            
                        out.append("    },")

            
                    out.append("  },")

            
                out.append("};")


            def emit_wedge_offsets(out, offsets):

            
                out.append(

            
                    "static const wedge_masks_type wedge_masks[BLOCK_SIZES_ALL][2] = {")

            
                for bs in range(BLOCK_SIZES_ALL):

            
                    out.append("  {  // " + BLOCK_NAMES[bs])

            
                    for sign in range(2):

            
                        row = offsets[bs][sign]

            
                        parts = ["{:>6d}u".format(v) for v in row]

            
                        out.append("    { " + ", ".join(parts) + " },")

            
                    out.append("  },")

            
                out.append("};")


            HEADER_BANNER = """\

            
            /*

            
             * Copyright (c) 2026, Alliance for Open Media. All rights reserved.

            
             *

            
             * This source code is subject to the terms of the BSD 2 Clause License and

            
             * the Alliance for Open Media Patent License 1.0. If the BSD 2 Clause License

            
             * was not distributed with this source code in the LICENSE file, you can

            
             * obtain it at www.aomedia.org/license/software. If the Alliance for Open

            
             * Media Patent License 1.0 was not distributed with this source code in the

            
             * PATENTS file, you can obtain it at www.aomedia.org/license/patent.

            
             */


            // This file is auto-generated by tools/gen_wedge_masks_data.py. DO NOT EDIT.

            
            //

            
            // It precomputes the libaom AV1 compound-prediction wedge masks and

            
            // inter-intra smooth blending masks so they can live in `.rdata` and be

            
            // COW-shared across processes, instead of being computed at runtime into

            
            // writable `.data` buffers via av1_init_wedge_masks().

            
            //

            
            // `wedge_masks` stores byte offsets into `wedge_mask_buf` (not pointers) so

            
            // no loader relocations are needed.

            
            //

            
            // To regenerate after upstream changes to reconinter.c (wedge codebooks,

            
            // master tables, BLOCK_SIZE enum, ii_weights1d, etc.) run:

            
            //   python3 source/libaom/tools/gen_wedge_masks_data.py

            
            //       --output source/libaom/av1/common/wedge_masks_data.inc

            
            """


            def write_output(path, obl, buf, smooth, offsets):

            
                out = []

            
                out.append(HEADER_BANNER)

            
                # Disable clang-format on the generated data tables. The emitters below

            
                # produce a deliberately column-aligned, 16-values-per-line layout so the

            
                # ~14k lines of mask data are visually scannable (you can eyeball the

            
                # wedge patterns and offset progressions). clang-format would otherwise

            
                # reflow each table to fit the project column limit, jumbling rows

            
                # together, destroying the alignment, and producing a several-thousand-

            
                # line diff every time anyone re-ran it.

            
                out.append("// The data tables below are emitted by")

            
                out.append("// tools/gen_wedge_masks_data.py with a fixed 16-values-per-row")

            
                out.append("// layout for visual readability. clang-format would reflow")

            
                out.append("// them to fit the project column limit, destroying the")

            
                out.append("// alignment and producing a many-thousand-line diff. Keep the")

            
                out.append("// formatter off until the closing `// clang-format on` below.")

            
                out.append("// clang-format off")

            
                out.append("")

            
                # `wedge_mask_obl` is intentionally not emitted: it was only used at

            
                # runtime as an intermediate to populate `wedge_mask_buf`, which is now

            
                # precomputed below. Dropping it saves ~48 KB of .rdata.

            
                _ = obl  # retained for verification harnesses; unused here.

            
                emit_wedge_mask_buf(out, buf)

            
                out.append("")

            
                emit_smooth_interintra(out, smooth)

            
                out.append("")

            
                emit_wedge_offsets(out, offsets)

            
                out.append("")

            
                out.append("// clang-format on")

            
                out.append("")

            
                text = "\n".join(out)

            
                with open(path, "w", encoding="utf-8", newline="\n") as f:

            
                    f.write(text)


            def main():

            
                parser = argparse.ArgumentParser(description=__doc__)

            
                default_out = os.path.normpath(

            
                    os.path.join(os.path.dirname(__file__), "..", "av1", "common",

            
                                 "wedge_masks_data.inc"))

            
                parser.add_argument("--output", default=default_out,

            
                                    help="Path to wedge_masks_data.inc (default: %(default)s)")

            
                args = parser.parse_args()


                obl = build_wedge_mask_obl()

            
                buf, offsets = build_wedge_mask_buf(obl)

            
                smooth = build_smooth_interintra_mask_buf()

            
                write_output(args.output, obl, buf, smooth, offsets)

            
                print("Wrote {}".format(args.output))


            if __name__ == "__main__":

            
                main()
	#!/usr/bin/env python3
	## Copyright (c) 2026, Alliance for Open Media. All rights reserved.
	##
	## This source code is subject to the terms of the BSD 2 Clause License and
	## the Alliance for Open Media Patent License 1.0. If the BSD 2 Clause License
	## was not distributed with this source code in the LICENSE file, you can
	## obtain it at www.aomedia.org/license/software. If the Alliance for Open
	## Media Patent License 1.0 was not distributed with this source code in the
	## PATENTS file, you can obtain it at www.aomedia.org/license/patent.
	##
	# Precompute libaom AV1 wedge / inter-intra blending masks at codegen time
	# so they can live in `.rdata` and be COW shared across processes instead
	# of being computed at runtime into writable `.data` buffers.
	#
	# Output is a header fragment included by av1/common/reconinter.c that
	# defines:
	# - wedge_mask_obl (input to wedge_mask_buf generation)
	# - wedge_mask_buf (compound prediction masks, indexed by offset)
	# - smooth_interintra_mask_buf
	# - wedge_masks (offsets into wedge_mask_buf)
	#
	# The algorithms in this file mirror init_wedge_master_masks(),
	# init_wedge_masks() and init_smooth_interintra_masks() in
	# av1/common/reconinter.c. They must stay in sync with that source. If those
	# helpers, the master tables, the wedge codebooks, the block-size enum, or
	# ii_weights1d ever change upstream, regenerate the .inc by running this
	# script and committing the result.
	#
	# Regenerate:
	# python3 source/libaom/tools/gen_wedge_masks_data.py
	# --output source/libaom/av1/common/wedge_masks_data.inc

	import argparse
	import os
	import sys
	import textwrap

	# -----------------------------------------------------------------------------
	# Constants (must match reconinter.h / enums.h).
	# -----------------------------------------------------------------------------
	MAX_WEDGE_TYPES = 16
	MAX_WEDGE_SIZE_LOG2 = 5
	MAX_WEDGE_SIZE = 1 << MAX_WEDGE_SIZE_LOG2 # 32
	MAX_WEDGE_SQUARE = MAX_WEDGE_SIZE * MAX_WEDGE_SIZE # 1024
	MASK_MASTER_SIZE = MAX_WEDGE_SIZE << 1 # 64
	MASK_MASTER_STRIDE = MASK_MASTER_SIZE
	WEDGE_WEIGHT_BITS = 6
	INTERINTRA_MODES = 4
	MAX_SB_SIZE_LOG2 = 7
	MAX_SB_SIZE = 1 << MAX_SB_SIZE_LOG2 # 128

	# WedgeDirectionType.
	WEDGE_HORIZONTAL = 0
	WEDGE_VERTICAL = 1
	WEDGE_OBLIQUE27 = 2
	WEDGE_OBLIQUE63 = 3
	WEDGE_OBLIQUE117 = 4
	WEDGE_OBLIQUE153 = 5
	WEDGE_DIRECTIONS = 6

	# BLOCK_SIZE enum order (must match enums.h).
	BLOCK_NAMES = [
	"BLOCK_4X4", "BLOCK_4X8", "BLOCK_8X4", "BLOCK_8X8",
	"BLOCK_8X16", "BLOCK_16X8", "BLOCK_16X16", "BLOCK_16X32",
	"BLOCK_32X16", "BLOCK_32X32", "BLOCK_32X64", "BLOCK_64X32",
	"BLOCK_64X64", "BLOCK_64X128", "BLOCK_128X64", "BLOCK_128X128",
	"BLOCK_4X16", "BLOCK_16X4", "BLOCK_8X32", "BLOCK_32X8",
	"BLOCK_16X64", "BLOCK_64X16",
	]
	BLOCK_SIZES_ALL = len(BLOCK_NAMES)


	def _parse_block_dims(name):
	# e.g. "BLOCK_8X16" -> (8, 16)
	body = name.split("_", 1)[1]
	w, h = body.split("X")
	return int(w), int(h)


	BLOCK_WIDTH = [_parse_block_dims(n)[0] for n in BLOCK_NAMES]
	BLOCK_HEIGHT = [_parse_block_dims(n)[1] for n in BLOCK_NAMES]


	def _bi(name):
	return BLOCK_NAMES.index(name)


	# Inter-intra modes (must match enums.h).
	II_DC_PRED, II_V_PRED, II_H_PRED, II_SMOOTH_PRED = 0, 1, 2, 3


	# -----------------------------------------------------------------------------
	# Master mask tables (see wedge_master_oblique_odd / _even / _vertical in
	# av1/common/reconinter.c).
	# -----------------------------------------------------------------------------
	WEDGE_MASTER_OBLIQUE_ODD = [
	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 6, 18,
	37, 53, 60, 63, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64,
	64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64,
	]
	WEDGE_MASTER_OBLIQUE_EVEN = [
	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 4, 11, 27,
	46, 58, 62, 63, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64,
	64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64,
	]
	WEDGE_MASTER_VERTICAL = [
	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 7, 21,
	43, 57, 62, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64,
	64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64,
	]

	# wedge_signflip_lookup (see av1/common/reconinter.c).
	WEDGE_SIGNFLIP_LOOKUP = [
	[0]16, [0]16, [0]*16,
	[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1], # BLOCK_8X8
	[1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1], # BLOCK_8X16
	[1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1], # BLOCK_16X8
	[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1], # BLOCK_16X16
	[1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1], # BLOCK_16X32
	[1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1], # BLOCK_32X16
	[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1], # BLOCK_32X32
	[0]16, [0]16, [0]16, [0]16, [0]16, [0]16, [0]16, [0]16,
	[1, 1, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 1, 0, 1], # BLOCK_8X32
	[1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 0, 1, 0, 1], # BLOCK_32X8
	[0]16, [0]16,
	]
	assert len(WEDGE_SIGNFLIP_LOOKUP) == BLOCK_SIZES_ALL


	# Wedge codebooks (see wedge_codebook_16_* in av1/common/reconinter.c).
	# Each entry is
	# (direction, x_offset, y_offset).
	WEDGE_CODEBOOK_16_HGTW = [
	(WEDGE_OBLIQUE27, 4, 4), (WEDGE_OBLIQUE63, 4, 4),
	(WEDGE_OBLIQUE117, 4, 4), (WEDGE_OBLIQUE153, 4, 4),
	(WEDGE_HORIZONTAL, 4, 2), (WEDGE_HORIZONTAL, 4, 4),
	(WEDGE_HORIZONTAL, 4, 6), (WEDGE_VERTICAL, 4, 4),
	(WEDGE_OBLIQUE27, 4, 2), (WEDGE_OBLIQUE27, 4, 6),
	(WEDGE_OBLIQUE153, 4, 2), (WEDGE_OBLIQUE153, 4, 6),
	(WEDGE_OBLIQUE63, 2, 4), (WEDGE_OBLIQUE63, 6, 4),
	(WEDGE_OBLIQUE117, 2, 4), (WEDGE_OBLIQUE117, 6, 4),
	]
	WEDGE_CODEBOOK_16_HLTW = [
	(WEDGE_OBLIQUE27, 4, 4), (WEDGE_OBLIQUE63, 4, 4),
	(WEDGE_OBLIQUE117, 4, 4), (WEDGE_OBLIQUE153, 4, 4),
	(WEDGE_VERTICAL, 2, 4), (WEDGE_VERTICAL, 4, 4),
	(WEDGE_VERTICAL, 6, 4), (WEDGE_HORIZONTAL, 4, 4),
	(WEDGE_OBLIQUE27, 4, 2), (WEDGE_OBLIQUE27, 4, 6),
	(WEDGE_OBLIQUE153, 4, 2), (WEDGE_OBLIQUE153, 4, 6),
	(WEDGE_OBLIQUE63, 2, 4), (WEDGE_OBLIQUE63, 6, 4),
	(WEDGE_OBLIQUE117, 2, 4), (WEDGE_OBLIQUE117, 6, 4),
	]
	WEDGE_CODEBOOK_16_HEQW = [
	(WEDGE_OBLIQUE27, 4, 4), (WEDGE_OBLIQUE63, 4, 4),
	(WEDGE_OBLIQUE117, 4, 4), (WEDGE_OBLIQUE153, 4, 4),
	(WEDGE_HORIZONTAL, 4, 2), (WEDGE_HORIZONTAL, 4, 6),
	(WEDGE_VERTICAL, 2, 4), (WEDGE_VERTICAL, 6, 4),
	(WEDGE_OBLIQUE27, 4, 2), (WEDGE_OBLIQUE27, 4, 6),
	(WEDGE_OBLIQUE153, 4, 2), (WEDGE_OBLIQUE153, 4, 6),
	(WEDGE_OBLIQUE63, 2, 4), (WEDGE_OBLIQUE63, 6, 4),
	(WEDGE_OBLIQUE117, 2, 4), (WEDGE_OBLIQUE117, 6, 4),
	]

	# av1_wedge_params_lookup. Stored here as (wtypes, codebook). The masks/
	# signflip pointers are reconstructed from BLOCK index. See
	# av1_wedge_params_lookup in av1/common/reconinter.c.
	WEDGE_PARAMS_LOOKUP = [
	(0, None),
	(0, None),
	(0, None),
	(MAX_WEDGE_TYPES, WEDGE_CODEBOOK_16_HEQW), # BLOCK_8X8
	(MAX_WEDGE_TYPES, WEDGE_CODEBOOK_16_HGTW), # BLOCK_8X16
	(MAX_WEDGE_TYPES, WEDGE_CODEBOOK_16_HLTW), # BLOCK_16X8
	(MAX_WEDGE_TYPES, WEDGE_CODEBOOK_16_HEQW), # BLOCK_16X16
	(MAX_WEDGE_TYPES, WEDGE_CODEBOOK_16_HGTW), # BLOCK_16X32
	(MAX_WEDGE_TYPES, WEDGE_CODEBOOK_16_HLTW), # BLOCK_32X16
	(MAX_WEDGE_TYPES, WEDGE_CODEBOOK_16_HEQW), # BLOCK_32X32
	(0, None), (0, None), (0, None), (0, None),
	(0, None), (0, None), (0, None), (0, None),
	(MAX_WEDGE_TYPES, WEDGE_CODEBOOK_16_HGTW), # BLOCK_8X32
	(MAX_WEDGE_TYPES, WEDGE_CODEBOOK_16_HLTW), # BLOCK_32X8
	(0, None), (0, None),
	]
	assert len(WEDGE_PARAMS_LOOKUP) == BLOCK_SIZES_ALL

	# ii_weights1d (see av1/common/reconinter.c).
	II_WEIGHTS_1D = [
	60, 58, 56, 54, 52, 50, 48, 47, 45, 44, 42, 41, 39, 38, 37, 35, 34, 33, 32,
	31, 30, 29, 28, 27, 26, 25, 24, 23, 22, 22, 21, 20, 19, 19, 18, 18, 17, 16,
	16, 15, 15, 14, 14, 13, 13, 12, 12, 12, 11, 11, 10, 10, 10, 9, 9, 9, 8,
	8, 8, 8, 7, 7, 7, 7, 6, 6, 6, 6, 6, 5, 5, 5, 5, 5, 4, 4,
	4, 4, 4, 4, 4, 4, 3, 3, 3, 3, 3, 3, 3, 3, 3, 2, 2, 2, 2,
	2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1,
	1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
	]
	assert len(II_WEIGHTS_1D) == MAX_SB_SIZE

	# ii_size_scales (see av1/common/reconinter.c).
	II_SIZE_SCALES = [
	32, 16, 16, 16, 8, 8, 8, 4,
	4, 4, 2, 2, 2, 1, 1, 1,
	8, 8, 4, 4, 2, 2,
	]
	assert len(II_SIZE_SCALES) == BLOCK_SIZES_ALL


	# -----------------------------------------------------------------------------
	# Algorithm: build wedge_mask_obl (init_wedge_master_masks in reconinter.c).
	# -----------------------------------------------------------------------------
	def shift_copy(src, dst, dst_off, shift, width):
	"""Mirrors shift_copy() in reconinter.c."""
	if shift >= 0:
	for i in range(width - shift):
	dst[dst_off + shift + i] = src[i]
	for i in range(shift):
	dst[dst_off + i] = src[0]
	else:
	n = -shift
	for i in range(width - n):
	dst[dst_off + i] = src[n + i]
	for i in range(n):
	dst[dst_off + width - n + i] = src[width - 1]


	def build_wedge_mask_obl():
	# [negative][direction] indexed flat per direction, MASK_MASTER_SIZE^2 bytes.
	obl = [[[0] * (MASK_MASTER_SIZE * MASK_MASTER_SIZE)
	for _ in range(WEDGE_DIRECTIONS)]
	for _ in range(2)]

	w = MASK_MASTER_SIZE
	h = MASK_MASTER_SIZE
	stride = MASK_MASTER_STRIDE
	shift = h // 4
	i = 0
	while i < h:
	shift_copy(WEDGE_MASTER_OBLIQUE_EVEN,
	obl[0][WEDGE_OBLIQUE63], i * stride, shift, MASK_MASTER_SIZE)
	shift -= 1
	shift_copy(WEDGE_MASTER_OBLIQUE_ODD,
	obl[0][WEDGE_OBLIQUE63], (i + 1) * stride, shift,
	MASK_MASTER_SIZE)
	# Vertical rows are just the vertical master copied each row.
	for k in range(MASK_MASTER_SIZE):
	obl[0][WEDGE_VERTICAL][i * stride + k] = WEDGE_MASTER_VERTICAL[k]
	obl[0][WEDGE_VERTICAL][(i + 1) * stride + k] = (
	WEDGE_MASTER_VERTICAL[k])
	i += 2

	max_val = 1 << WEDGE_WEIGHT_BITS # 64
	for i in range(h):
	for j in range(w):
	msk = obl[0][WEDGE_OBLIQUE63][i * stride + j]
	obl[0][WEDGE_OBLIQUE27][j * stride + i] = msk
	obl[0][WEDGE_OBLIQUE117][i * stride + w - 1 - j] = max_val - msk
	obl[0][WEDGE_OBLIQUE153][(w - 1 - j) * stride + i] = max_val - msk
	obl[1][WEDGE_OBLIQUE63][i * stride + j] = max_val - msk
	obl[1][WEDGE_OBLIQUE27][j * stride + i] = max_val - msk
	obl[1][WEDGE_OBLIQUE117][i * stride + w - 1 - j] = msk
	obl[1][WEDGE_OBLIQUE153][(w - 1 - j) * stride + i] = msk
	mskx = obl[0][WEDGE_VERTICAL][i * stride + j]
	obl[0][WEDGE_HORIZONTAL][j * stride + i] = mskx
	obl[1][WEDGE_VERTICAL][i * stride + j] = max_val - mskx
	obl[1][WEDGE_HORIZONTAL][j * stride + i] = max_val - mskx

	return obl


	# -----------------------------------------------------------------------------
	# Algorithm: build wedge_mask_buf and wedge_masks offset table
	# (init_wedge_masks + get_wedge_mask_inplace + aom_convolve_copy).
	# -----------------------------------------------------------------------------
	def get_wedge_mask_inplace_offset(wedge_obl, w_idx, neg, bsize):
	"""Compute the starting (row, col) into wedge_mask_obl[neg^wsignflip][dir]
	for a given wedge index/sign/block-size; mirrors get_wedge_mask_inplace().
	Returns (which_neg, direction, row_off, col_off)."""
	bw = BLOCK_WIDTH[bsize]
	bh = BLOCK_HEIGHT[bsize]
	wtypes, codebook = WEDGE_PARAMS_LOOKUP[bsize]
	assert wtypes > 0
	direction, x_off, y_off = codebook[w_idx]
	woff = (x_off * bw) >> 3
	hoff = (y_off * bh) >> 3
	wsignflip = WEDGE_SIGNFLIP_LOOKUP[bsize][w_idx]
	which = neg ^ wsignflip
	row_off = MASK_MASTER_SIZE // 2 - hoff
	col_off = MASK_MASTER_SIZE // 2 - woff
	return which, direction, row_off, col_off


	def build_wedge_mask_buf(obl):
	buf_size = 2 * MAX_WEDGE_TYPES * 4 * MAX_WEDGE_SQUARE
	buf = [0] * buf_size

	# Offset table: wedge_masks[bsize][sign][wedge_index] -> uint32 offset.
	offsets = [[[0] * MAX_WEDGE_TYPES for _ in range(2)]
	for _ in range(BLOCK_SIZES_ALL)]

	dst = 0
	for bsize in range(BLOCK_SIZES_ALL):
	wtypes, _ = WEDGE_PARAMS_LOOKUP[bsize]
	if wtypes == 0:
	continue
	bw = BLOCK_WIDTH[bsize]
	bh = BLOCK_HEIGHT[bsize]
	for w_idx in range(wtypes):
	# sign 0
	which, direction, row_off, col_off = (
	get_wedge_mask_inplace_offset(obl, w_idx, 0, bsize))
	src = obl[which][direction]
	for r in range(bh):
	for c in range(bw):
	buf[dst + r * bw + c] = src[
	(row_off + r) * MASK_MASTER_STRIDE + (col_off + c)]
	offsets[bsize][0][w_idx] = dst
	dst += bw * bh

	# sign 1
	which, direction, row_off, col_off = (
	get_wedge_mask_inplace_offset(obl, w_idx, 1, bsize))
	src = obl[which][direction]
	for r in range(bh):
	for c in range(bw):
	buf[dst + r * bw + c] = src[
	(row_off + r) * MASK_MASTER_STRIDE + (col_off + c)]
	offsets[bsize][1][w_idx] = dst
	dst += bw * bh

	assert dst <= buf_size, (dst, buf_size)
	return buf, offsets


	# -----------------------------------------------------------------------------
	# Algorithm: build smooth_interintra_mask_buf
	# (init_smooth_interintra_masks + build_smooth_interintra_mask).
	# -----------------------------------------------------------------------------
	def build_smooth_interintra(mask, mask_off, stride, plane_bsize, mode):
	bw = BLOCK_WIDTH[plane_bsize]
	bh = BLOCK_HEIGHT[plane_bsize]
	size_scale = II_SIZE_SCALES[plane_bsize]
	if mode == II_V_PRED:
	for i in range(bh):
	row = mask_off + i * stride
	val = II_WEIGHTS_1D[i * size_scale]
	for j in range(bw):
	mask[row + j] = val
	elif mode == II_H_PRED:
	for i in range(bh):
	row = mask_off + i * stride
	for j in range(bw):
	mask[row + j] = II_WEIGHTS_1D[j * size_scale]
	elif mode == II_SMOOTH_PRED:
	for i in range(bh):
	row = mask_off + i * stride
	for j in range(bw):
	mask[row + j] = II_WEIGHTS_1D[min(i, j) * size_scale]
	else: # II_DC_PRED or default
	for i in range(bh):
	row = mask_off + i * stride
	for j in range(bw):
	mask[row + j] = 32


	def build_smooth_interintra_mask_buf():
	# [INTERINTRA_MODES][BLOCK_SIZES_ALL][MAX_WEDGE_SQUARE]
	buf = [[[0] * MAX_WEDGE_SQUARE for _ in range(BLOCK_SIZES_ALL)]
	for _ in range(INTERINTRA_MODES)]
	for m in range(INTERINTRA_MODES):
	for bs in range(BLOCK_SIZES_ALL):
	bw = BLOCK_WIDTH[bs]
	bh = BLOCK_HEIGHT[bs]
	if bw > MAX_WEDGE_SIZE or bh > MAX_WEDGE_SIZE:
	continue
	build_smooth_interintra(buf[m][bs], 0, bw, bs, m)
	return buf


	# -----------------------------------------------------------------------------
	# C emission helpers.
	# -----------------------------------------------------------------------------
	def emit_bytes_block(values, indent=" ", per_line=16):
	lines = []
	for chunk_start in range(0, len(values), per_line):
	chunk = values[chunk_start:chunk_start + per_line]
	parts = ["{:>3d}".format(v) for v in chunk]
	lines.append(indent + ", ".join(parts) + ",")
	return "\n".join(lines)


	def emit_wedge_mask_obl(out, obl):
	out.append(
	"DECLARE_ALIGNED(16, static const uint8_t,")
	out.append(
	" wedge_mask_obl[2][WEDGE_DIRECTIONS]")
	out.append(
	" [MASK_MASTER_SIZE * MASK_MASTER_SIZE]) = {")
	for neg in range(2):
	out.append(" {")
	for direction in range(WEDGE_DIRECTIONS):
	out.append(" {{ // [{}][dir={}]".format(neg, direction))
	out.append(emit_bytes_block(obl[neg][direction], indent=" "))
	out.append(" },")
	out.append(" },")
	out.append("};")


	def emit_wedge_mask_buf(out, buf):
	out.append(
	"DECLARE_ALIGNED(16, static const uint8_t,")
	out.append(
	" wedge_mask_buf[2 * MAX_WEDGE_TYPES * 4 *"
	" MAX_WEDGE_SQUARE]) = {")
	out.append(emit_bytes_block(buf, indent=" "))
	out.append("};")


	def emit_smooth_interintra(out, buf):
	out.append(
	"DECLARE_ALIGNED(16, static const uint8_t,")
	out.append(
	" smooth_interintra_mask_buf[INTERINTRA_MODES]")
	out.append(
	" [BLOCK_SIZES_ALL]")
	out.append(
	" [MAX_WEDGE_SQUARE]) = {")
	for m in range(INTERINTRA_MODES):
	out.append(" {")
	for bs in range(BLOCK_SIZES_ALL):
	out.append(" {{ // mode={}, bsize={}".format(m, BLOCK_NAMES[bs]))
	out.append(emit_bytes_block(buf[m][bs], indent=" "))
	out.append(" },")
	out.append(" },")
	out.append("};")


	def emit_wedge_offsets(out, offsets):
	out.append(
	"static const wedge_masks_type wedge_masks[BLOCK_SIZES_ALL][2] = {")
	for bs in range(BLOCK_SIZES_ALL):
	out.append(" { // " + BLOCK_NAMES[bs])
	for sign in range(2):
	row = offsets[bs][sign]
	parts = ["{:>6d}u".format(v) for v in row]
	out.append(" { " + ", ".join(parts) + " },")
	out.append(" },")
	out.append("};")


	HEADER_BANNER = """\
	/*
	* Copyright (c) 2026, Alliance for Open Media. All rights reserved.
	*
	* This source code is subject to the terms of the BSD 2 Clause License and
	* the Alliance for Open Media Patent License 1.0. If the BSD 2 Clause License
	* was not distributed with this source code in the LICENSE file, you can
	* obtain it at www.aomedia.org/license/software. If the Alliance for Open
	* Media Patent License 1.0 was not distributed with this source code in the
	* PATENTS file, you can obtain it at www.aomedia.org/license/patent.
	*/

	// This file is auto-generated by tools/gen_wedge_masks_data.py. DO NOT EDIT.
	//
	// It precomputes the libaom AV1 compound-prediction wedge masks and
	// inter-intra smooth blending masks so they can live in `.rdata` and be
	// COW-shared across processes, instead of being computed at runtime into
	// writable `.data` buffers via av1_init_wedge_masks().
	//
	// `wedge_masks` stores byte offsets into `wedge_mask_buf` (not pointers) so
	// no loader relocations are needed.
	//
	// To regenerate after upstream changes to reconinter.c (wedge codebooks,
	// master tables, BLOCK_SIZE enum, ii_weights1d, etc.) run:
	// python3 source/libaom/tools/gen_wedge_masks_data.py
	// --output source/libaom/av1/common/wedge_masks_data.inc
	"""


	def write_output(path, obl, buf, smooth, offsets):
	out = []
	out.append(HEADER_BANNER)
	# Disable clang-format on the generated data tables. The emitters below
	# produce a deliberately column-aligned, 16-values-per-line layout so the
	# ~14k lines of mask data are visually scannable (you can eyeball the
	# wedge patterns and offset progressions). clang-format would otherwise
	# reflow each table to fit the project column limit, jumbling rows
	# together, destroying the alignment, and producing a several-thousand-
	# line diff every time anyone re-ran it.
	out.append("// The data tables below are emitted by")
	out.append("// tools/gen_wedge_masks_data.py with a fixed 16-values-per-row")
	out.append("// layout for visual readability. clang-format would reflow")
	out.append("// them to fit the project column limit, destroying the")
	out.append("// alignment and producing a many-thousand-line diff. Keep the")
	out.append("// formatter off until the closing `// clang-format on` below.")
	out.append("// clang-format off")
	out.append("")
	# `wedge_mask_obl` is intentionally not emitted: it was only used at
	# runtime as an intermediate to populate `wedge_mask_buf`, which is now
	# precomputed below. Dropping it saves ~48 KB of .rdata.
	_ = obl # retained for verification harnesses; unused here.
	emit_wedge_mask_buf(out, buf)
	out.append("")
	emit_smooth_interintra(out, smooth)
	out.append("")
	emit_wedge_offsets(out, offsets)
	out.append("")
	out.append("// clang-format on")
	out.append("")
	text = "\n".join(out)
	with open(path, "w", encoding="utf-8", newline="\n") as f:
	f.write(text)


	def main():
	parser = argparse.ArgumentParser(description=__doc__)
	default_out = os.path.normpath(
	os.path.join(os.path.dirname(__file__), "..", "av1", "common",
	"wedge_masks_data.inc"))
	parser.add_argument("--output", default=default_out,
	help="Path to wedge_masks_data.inc (default: %(default)s)")
	args = parser.parse_args()

	obl = build_wedge_mask_obl()
	buf, offsets = build_wedge_mask_buf(obl)
	smooth = build_smooth_interintra_mask_buf()
	write_output(args.output, obl, buf, smooth, offsets)
	print("Wrote {}".format(args.output))


	if __name__ == "__main__":
	main()