// Copyright 2023 The Android Open Source Project
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//      http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

package {
    default_applicable_licenses: ["external_libdav1d_license"],
}

license {
    name: "external_libdav1d_license",
    visibility: [":__subpackages__"],
    license_kinds: [
        "SPDX-license-identifier-Apache-2.0",
    ],
    license_text: [
        "LICENSE",
    ],
}

cc_defaults {
    name: "libdav1d_defaults",
    host_supported: true,
    vendor_available: true,

    export_include_dirs: [
        "include",
    ],

    local_include_dirs: [
        "include",
        "include/common",
        "include/dav1d",
        "src",
    ],

    cflags: [
        "-D_FILE_OFFSET_BITS=64",
        "-D_ISOC99_SOURCE",
        "-Wall",
        "-Werror",
        "-Werror=vla",
        "-Wextra",
        "-Winvalid-pch",
        "-Wno-error=unused-parameter",
        "-Wno-incompatible-pointer-types",
        "-Wno-missing-field-initializers",
        "-Wundef",
        "-fPIC",
        "-ffast-math",
        "-std=c99",
    ],

    arch: {
        arm64: {
            local_include_dirs: [
                "config/arm64",
                "src/arm",
            ],
        },

        arm: {
            local_include_dirs: [
                "config/arm32",
                "src/arm",
            ],
        },

        x86_64: {
            local_include_dirs: [
                "config/x86_64",
                "src/x86",
            ],
        },

        x86: {
            local_include_dirs: [
                "config/x86_32",
                "src/x86",
            ],
        },

        riscv64: {
            local_include_dirs: [
                "config/riscv64",
            ],
        },
    },

    sanitize: {
        integer_overflow: true,
        misc_undefined: ["bounds"],
        cfi: true,
        config: {
            cfi_assembly_support: true,
        },
        blocklist: "libdav1d_blocklist.txt",
    },

    min_sdk_version: "29",
    apex_available: [
        "//apex_available:platform",
        "com.android.media.swcodec",
    ],
}

libdav1d_tmpl_srcs = [
    "src/cdef_apply_tmpl.c",
    "src/cdef_tmpl.c",
    "src/fg_apply_tmpl.c",
    "src/filmgrain_tmpl.c",
    "src/ipred_prepare_tmpl.c",
    "src/ipred_tmpl.c",
    "src/itx_tmpl.c",
    "src/lf_apply_tmpl.c",
    "src/loopfilter_tmpl.c",
    "src/looprestoration_tmpl.c",
    "src/lr_apply_tmpl.c",
    "src/mc_tmpl.c",
    "src/recon_tmpl.c",
]

cc_library_static {
    name: "libdav1d_dotprod_i8mm",
    defaults: [
        "libdav1d_defaults",
    ],
    vendor_available: true,
    visibility: ["//visibility:private"],

    cflags: [
        "-Xclang -target-feature",
        // This comment prevents bpfmt from sorting the flags incorrectly.
        "-Xclang +dotprod",
        // This comment prevents bpfmt from sorting the flags incorrectly.
        "-Xclang -target-feature",
        // This comment prevents bpfmt from sorting the flags incorrectly.
        "-Xclang +i8mm",
    ],

    arch: {
        arm64: {
            srcs: [
                "src/arm/64/mc_dotprod.S",
            ],
        },
    },
}

cc_library_static {
    name: "libdav1d_sve2",
    defaults: [
        "libdav1d_defaults",
    ],
    vendor_available: true,
    visibility: ["//visibility:private"],

    cflags: [
        "-Xclang -target-feature",
        // This comment prevents bpfmt from sorting the flags incorrectly.
        "-Xclang +sve2",
    ],

    arch: {
        arm64: {
            srcs: [
                "src/arm/64/mc16_sve.S",
            ],
        },
    },
}

cc_library_static {
    name: "libdav1d_8bit",
    defaults: [
        "libdav1d_defaults",
    ],
    cflags: [
        "-DBITDEPTH=8",
    ],
    srcs: libdav1d_tmpl_srcs,

    arch: {
        arm64: {
            srcs: [
                "src/arm/64/cdef.S",
                "src/arm/64/filmgrain.S",
                "src/arm/64/ipred.S",
                "src/arm/64/itx.S",
                "src/arm/64/loopfilter.S",
                "src/arm/64/looprestoration.S",
                "src/arm/64/mc.S",
            ],
        },

        arm: {
            srcs: [
                "src/arm/32/cdef.S",
                "src/arm/32/filmgrain.S",
                "src/arm/32/ipred.S",
                "src/arm/32/itx.S",
                "src/arm/32/loopfilter.S",
                "src/arm/32/looprestoration.S",
                "src/arm/32/mc.S",
            ],
        },
    },
}

cc_library_static {
    name: "libdav1d_16bit",
    defaults: [
        "libdav1d_defaults",
    ],
    cflags: [
        "-DBITDEPTH=16",
    ],
    srcs: libdav1d_tmpl_srcs,

    arch: {
        arm64: {
            srcs: [
                "src/arm/64/cdef16.S",
                "src/arm/64/filmgrain16.S",
                "src/arm/64/ipred16.S",
                "src/arm/64/itx16.S",
                "src/arm/64/loopfilter16.S",
                "src/arm/64/looprestoration16.S",
                "src/arm/64/mc16.S",
            ],
        },

        arm: {
            srcs: [
                "src/arm/32/cdef16.S",
                "src/arm/32/filmgrain16.S",
                "src/arm/32/ipred16.S",
                "src/arm/32/itx16.S",
                "src/arm/32/loopfilter16.S",
                "src/arm/32/looprestoration16.S",
                "src/arm/32/mc16.S",
            ],
        },
    },
}

cc_library_static {
    name: "libdav1d",
    defaults: [
        "libdav1d_defaults",
    ],

    srcs: [
        "src/cdf.c",
        "src/ctx.c",
        "src/cpu.c",
        "src/data.c",
        "src/decode.c",
        "src/dequant_tables.c",
        "src/getbits.c",
        "src/intra_edge.c",
        "src/itx_1d.c",
        "src/lf_mask.c",
        "src/lib.c",
        "src/log.c",
        "src/mem.c",
        "src/msac.c",
        "src/obu.c",
        "src/pal.c",
        "src/picture.c",
        "src/qm.c",
        "src/ref.c",
        "src/refmvs.c",
        "src/scan.c",
        "src/tables.c",
        "src/thread_task.c",
        "src/warpmv.c",
        "src/wedge.c",
    ],

    arch: {
        arm64: {
            srcs: [
                "src/arm/64/looprestoration_common.S",
                "src/arm/64/msac.S",
                "src/arm/64/refmvs.S",
                "src/arm/cpu.c",
            ],
        },

        arm: {
            srcs: [
                "src/arm/32/looprestoration_common.S",
                "src/arm/32/msac.S",
                "src/arm/32/refmvs.S",
                "src/arm/cpu.c",
            ],
        },

        x86_64: {
            srcs: [
                "src/x86/cpu.c",
            ],
        },

        x86: {
            srcs: [
                "src/x86/cpu.c",
            ],
        },
    },

    whole_static_libs: [
        "libdav1d_8bit",
        "libdav1d_16bit",
        "libdav1d_dotprod_i8mm",
        "libdav1d_sve2",
    ],
}

cc_defaults {
    name: "dav1d_test_defaults",
    host_supported: true,

    cflags: [
        "-Wno-error=unused-parameter",
    ],

    local_include_dirs: [
        "include",
        "include/common",
        "include/dav1d",
        "src",
        "tests/libfuzzer",
        "tools",
        "tools/input",
        "tools/output",
    ],

    arch: {
        arm64: {
            local_include_dirs: [
                "config/arm64",
            ],

        },
        arm: {
            local_include_dirs: [
                "config/arm32",
            ],

        },
        x86_64: {
            local_include_dirs: [
                "config/x86_64",
            ],

        },
        x86: {
            local_include_dirs: [
                "config/x86_32",
            ],

        },
        riscv64: {
            local_include_dirs: [
                "config/riscv64",
            ],

        },
    },

    static_libs: [
        "libdav1d",
    ],
}

cc_defaults {
    name: "dav1d_fuzzer_defaults",
    defaults: [
        "dav1d_test_defaults",
    ],
    srcs: [
        "tests/libfuzzer/dav1d_fuzzer.c",
    ],

    fuzz_config: {
        cc: ["kyslov@google.com"],
        componentid: 25690,
    },
}

cc_fuzz {
    name: "dav1d_fuzzer",
    defaults: [
        "dav1d_fuzzer_defaults",
    ],
}

cc_fuzz {
    name: "dav1d_fuzzer_mt",
    defaults: [
        "dav1d_fuzzer_defaults",
    ],

    cflags: [
        "-DDAV1D_MT_FUZZING=1",
    ],
}

cc_binary {
    name: "dav1d",
    defaults: [
        "dav1d_test_defaults",
    ],

    srcs: [
        "tools/dav1d.c",
        "tools/dav1d_cli_parse.c",
        "tools/input/annexb.c",
        "tools/input/input.c",
        "tools/input/ivf.c",
        "tools/input/section5.c",
        "tools/output/md5.c",
        "tools/output/null.c",
        "tools/output/output.c",
        "tools/output/y4m2.c",
        "tools/output/yuv.c",
    ],
}