/*

 * Copyright (C) 2024 Niklas Haas

 *

 * 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 "libavutil/attributes.h"

#include "libavutil/avassert.h"

#include "libavutil/hdr_dynamic_metadata.h"

#include "libavutil/mastering_display_metadata.h"

#include "libavutil/refstruct.h"

#include "format.h"

#include "csputils.h"

#include "ops_internal.h"

#include "config_components.h"

#if CONFIG_UNSTABLE

#include "libavutil/hwcontext.h"

#endif

#define RET(x)                                                                 \

    do {                                                                       \

        int _ret = (x);                                                        \

        if (_ret  < 0)                                                         \

            return _ret;                                                       \

    } while (0)

typedef struct LegacyFormatEntry {

    uint8_t is_supported_in         :1;

    uint8_t is_supported_out        :1;

    uint8_t is_supported_endianness :1;

} LegacyFormatEntry;

/* Format support table for legacy swscale */

static const LegacyFormatEntry legacy_format_entries[] = {

    [AV_PIX_FMT_YUV420P]        = { 1, 1 },

    [AV_PIX_FMT_YUYV422]        = { 1, 1 },

    [AV_PIX_FMT_RGB24]          = { 1, 1 },

    [AV_PIX_FMT_BGR24]          = { 1, 1 },

    [AV_PIX_FMT_YUV422P]        = { 1, 1 },

    [AV_PIX_FMT_YUV444P]        = { 1, 1 },

    [AV_PIX_FMT_YUV410P]        = { 1, 1 },

    [AV_PIX_FMT_YUV411P]        = { 1, 1 },

    [AV_PIX_FMT_GRAY8]          = { 1, 1 },

    [AV_PIX_FMT_MONOWHITE]      = { 1, 1 },

    [AV_PIX_FMT_MONOBLACK]      = { 1, 1 },

    [AV_PIX_FMT_PAL8]           = { 1, 0 },

    [AV_PIX_FMT_YUVJ420P]       = { 1, 1 },

    [AV_PIX_FMT_YUVJ411P]       = { 1, 1 },

    [AV_PIX_FMT_YUVJ422P]       = { 1, 1 },

    [AV_PIX_FMT_YUVJ444P]       = { 1, 1 },

    [AV_PIX_FMT_YVYU422]        = { 1, 1 },

    [AV_PIX_FMT_UYVY422]        = { 1, 1 },

    [AV_PIX_FMT_UYYVYY411]      = { 1, 0 },

    [AV_PIX_FMT_BGR8]           = { 1, 1 },

    [AV_PIX_FMT_BGR4]           = { 0, 1 },

    [AV_PIX_FMT_BGR4_BYTE]      = { 1, 1 },

    [AV_PIX_FMT_RGB8]           = { 1, 1 },

    [AV_PIX_FMT_RGB4]           = { 0, 1 },

    [AV_PIX_FMT_RGB4_BYTE]      = { 1, 1 },

    [AV_PIX_FMT_NV12]           = { 1, 1 },

    [AV_PIX_FMT_NV21]           = { 1, 1 },

    [AV_PIX_FMT_ARGB]           = { 1, 1 },

    [AV_PIX_FMT_RGBA]           = { 1, 1 },

    [AV_PIX_FMT_ABGR]           = { 1, 1 },

    [AV_PIX_FMT_BGRA]           = { 1, 1 },

    [AV_PIX_FMT_0RGB]           = { 1, 1 },

    [AV_PIX_FMT_RGB0]           = { 1, 1 },

    [AV_PIX_FMT_0BGR]           = { 1, 1 },

    [AV_PIX_FMT_BGR0]           = { 1, 1 },

    [AV_PIX_FMT_GRAY9BE]        = { 1, 1 },

    [AV_PIX_FMT_GRAY9LE]        = { 1, 1 },

    [AV_PIX_FMT_GRAY10BE]       = { 1, 1 },

    [AV_PIX_FMT_GRAY10LE]       = { 1, 1 },

    [AV_PIX_FMT_GRAY12BE]       = { 1, 1 },

    [AV_PIX_FMT_GRAY12LE]       = { 1, 1 },

    [AV_PIX_FMT_GRAY14BE]       = { 1, 1 },

    [AV_PIX_FMT_GRAY14LE]       = { 1, 1 },

    [AV_PIX_FMT_GRAY16BE]       = { 1, 1 },

    [AV_PIX_FMT_GRAY16LE]       = { 1, 1 },

    [AV_PIX_FMT_YUV440P]        = { 1, 1 },

    [AV_PIX_FMT_YUVJ440P]       = { 1, 1 },

    [AV_PIX_FMT_YUV440P10LE]    = { 1, 1 },

    [AV_PIX_FMT_YUV440P10BE]    = { 1, 1 },

    [AV_PIX_FMT_YUV440P12LE]    = { 1, 1 },

    [AV_PIX_FMT_YUV440P12BE]    = { 1, 1 },

    [AV_PIX_FMT_YUVA420P]       = { 1, 1 },

    [AV_PIX_FMT_YUVA422P]       = { 1, 1 },

    [AV_PIX_FMT_YUVA444P]       = { 1, 1 },

    [AV_PIX_FMT_YUVA420P9BE]    = { 1, 1 },

    [AV_PIX_FMT_YUVA420P9LE]    = { 1, 1 },

    [AV_PIX_FMT_YUVA422P9BE]    = { 1, 1 },

    [AV_PIX_FMT_YUVA422P9LE]    = { 1, 1 },

    [AV_PIX_FMT_YUVA444P9BE]    = { 1, 1 },

    [AV_PIX_FMT_YUVA444P9LE]    = { 1, 1 },

    [AV_PIX_FMT_YUVA420P10BE]   = { 1, 1 },

    [AV_PIX_FMT_YUVA420P10LE]   = { 1, 1 },

    [AV_PIX_FMT_YUVA422P10BE]   = { 1, 1 },

    [AV_PIX_FMT_YUVA422P10LE]   = { 1, 1 },

    [AV_PIX_FMT_YUVA444P10BE]   = { 1, 1 },

    [AV_PIX_FMT_YUVA444P10LE]   = { 1, 1 },

    [AV_PIX_FMT_YUVA420P16BE]   = { 1, 1 },

    [AV_PIX_FMT_YUVA420P16LE]   = { 1, 1 },

    [AV_PIX_FMT_YUVA422P16BE]   = { 1, 1 },

    [AV_PIX_FMT_YUVA422P16LE]   = { 1, 1 },

    [AV_PIX_FMT_YUVA444P16BE]   = { 1, 1 },

    [AV_PIX_FMT_YUVA444P16LE]   = { 1, 1 },

    [AV_PIX_FMT_RGB48BE]        = { 1, 1 },

    [AV_PIX_FMT_RGB48LE]        = { 1, 1 },

    [AV_PIX_FMT_RGBA64BE]       = { 1, 1, 1 },

    [AV_PIX_FMT_RGBA64LE]       = { 1, 1, 1 },

    [AV_PIX_FMT_RGB565BE]       = { 1, 1 },

    [AV_PIX_FMT_RGB565LE]       = { 1, 1 },

    [AV_PIX_FMT_RGB555BE]       = { 1, 1 },

    [AV_PIX_FMT_RGB555LE]       = { 1, 1 },

    [AV_PIX_FMT_BGR565BE]       = { 1, 1 },

    [AV_PIX_FMT_BGR565LE]       = { 1, 1 },

    [AV_PIX_FMT_BGR555BE]       = { 1, 1 },

    [AV_PIX_FMT_BGR555LE]       = { 1, 1 },

    [AV_PIX_FMT_YUV420P16LE]    = { 1, 1 },

    [AV_PIX_FMT_YUV420P16BE]    = { 1, 1 },

    [AV_PIX_FMT_YUV422P16LE]    = { 1, 1 },

    [AV_PIX_FMT_YUV422P16BE]    = { 1, 1 },

    [AV_PIX_FMT_YUV444P16LE]    = { 1, 1 },

    [AV_PIX_FMT_YUV444P16BE]    = { 1, 1 },

    [AV_PIX_FMT_RGB444LE]       = { 1, 1 },

    [AV_PIX_FMT_RGB444BE]       = { 1, 1 },

    [AV_PIX_FMT_BGR444LE]       = { 1, 1 },

    [AV_PIX_FMT_BGR444BE]       = { 1, 1 },

    [AV_PIX_FMT_YA8]            = { 1, 1 },

    [AV_PIX_FMT_YA16BE]         = { 1, 1 },

    [AV_PIX_FMT_YA16LE]         = { 1, 1 },

    [AV_PIX_FMT_BGR48BE]        = { 1, 1 },

    [AV_PIX_FMT_BGR48LE]        = { 1, 1 },

    [AV_PIX_FMT_BGRA64BE]       = { 1, 1, 1 },

    [AV_PIX_FMT_BGRA64LE]       = { 1, 1, 1 },

    [AV_PIX_FMT_YUV420P9BE]     = { 1, 1 },

    [AV_PIX_FMT_YUV420P9LE]     = { 1, 1 },

    [AV_PIX_FMT_YUV420P10BE]    = { 1, 1 },

    [AV_PIX_FMT_YUV420P10LE]    = { 1, 1 },

    [AV_PIX_FMT_YUV420P12BE]    = { 1, 1 },

    [AV_PIX_FMT_YUV420P12LE]    = { 1, 1 },

    [AV_PIX_FMT_YUV420P14BE]    = { 1, 1 },

    [AV_PIX_FMT_YUV420P14LE]    = { 1, 1 },

    [AV_PIX_FMT_YUV422P9BE]     = { 1, 1 },

    [AV_PIX_FMT_YUV422P9LE]     = { 1, 1 },

    [AV_PIX_FMT_YUV422P10BE]    = { 1, 1 },

    [AV_PIX_FMT_YUV422P10LE]    = { 1, 1 },

    [AV_PIX_FMT_YUV422P12BE]    = { 1, 1 },

    [AV_PIX_FMT_YUV422P12LE]    = { 1, 1 },

    [AV_PIX_FMT_YUV422P14BE]    = { 1, 1 },

    [AV_PIX_FMT_YUV422P14LE]    = { 1, 1 },

    [AV_PIX_FMT_YUV444P9BE]     = { 1, 1 },

    [AV_PIX_FMT_YUV444P9LE]     = { 1, 1 },

    [AV_PIX_FMT_YUV444P10BE]    = { 1, 1 },

    [AV_PIX_FMT_YUV444P10LE]    = { 1, 1 },

    [AV_PIX_FMT_YUV444P12BE]    = { 1, 1 },

    [AV_PIX_FMT_YUV444P12LE]    = { 1, 1 },

    [AV_PIX_FMT_YUV444P14BE]    = { 1, 1 },

    [AV_PIX_FMT_YUV444P14LE]    = { 1, 1 },

    [AV_PIX_FMT_YUV444P10MSBBE] = { 1, 1 },

    [AV_PIX_FMT_YUV444P10MSBLE] = { 1, 1 },

    [AV_PIX_FMT_YUV444P12MSBBE] = { 1, 1 },

    [AV_PIX_FMT_YUV444P12MSBLE] = { 1, 1 },

    [AV_PIX_FMT_GBRP]           = { 1, 1 },

    [AV_PIX_FMT_GBRP9LE]        = { 1, 1 },

    [AV_PIX_FMT_GBRP9BE]        = { 1, 1 },

    [AV_PIX_FMT_GBRP10LE]       = { 1, 1 },

    [AV_PIX_FMT_GBRP10BE]       = { 1, 1 },

    [AV_PIX_FMT_GBRAP10LE]      = { 1, 1 },

    [AV_PIX_FMT_GBRAP10BE]      = { 1, 1 },

    [AV_PIX_FMT_GBRP10MSBLE]    = { 1, 1 },

    [AV_PIX_FMT_GBRP10MSBBE]    = { 1, 1 },

    [AV_PIX_FMT_GBRP12LE]       = { 1, 1 },

    [AV_PIX_FMT_GBRP12BE]       = { 1, 1 },

    [AV_PIX_FMT_GBRP12MSBLE]    = { 1, 1 },

    [AV_PIX_FMT_GBRP12MSBBE]    = { 1, 1 },

    [AV_PIX_FMT_GBRAP12LE]      = { 1, 1 },

    [AV_PIX_FMT_GBRAP12BE]      = { 1, 1 },

    [AV_PIX_FMT_GBRP14LE]       = { 1, 1 },

    [AV_PIX_FMT_GBRP14BE]       = { 1, 1 },

    [AV_PIX_FMT_GBRAP14LE]      = { 1, 1 },

    [AV_PIX_FMT_GBRAP14BE]      = { 1, 1 },

    [AV_PIX_FMT_GBRP16LE]       = { 1, 1 },

    [AV_PIX_FMT_GBRP16BE]       = { 1, 1 },

    [AV_PIX_FMT_GBRPF32LE]      = { 1, 1 },

    [AV_PIX_FMT_GBRPF32BE]      = { 1, 1 },

    [AV_PIX_FMT_GBRAPF32LE]     = { 1, 1 },

    [AV_PIX_FMT_GBRAPF32BE]     = { 1, 1 },

    [AV_PIX_FMT_GBRPF16LE]      = { 1, 0 },

    [AV_PIX_FMT_GBRPF16BE]      = { 1, 0 },

    [AV_PIX_FMT_GBRAPF16LE]     = { 1, 0 },

    [AV_PIX_FMT_GBRAPF16BE]     = { 1, 0 },

    [AV_PIX_FMT_GBRAP]          = { 1, 1 },

    [AV_PIX_FMT_GBRAP16LE]      = { 1, 1 },

    [AV_PIX_FMT_GBRAP16BE]      = { 1, 1 },

    [AV_PIX_FMT_BAYER_BGGR8]    = { 1, 0 },

    [AV_PIX_FMT_BAYER_RGGB8]    = { 1, 0 },

    [AV_PIX_FMT_BAYER_GBRG8]    = { 1, 0 },

    [AV_PIX_FMT_BAYER_GRBG8]    = { 1, 0 },

    [AV_PIX_FMT_BAYER_BGGR16LE] = { 1, 0 },

    [AV_PIX_FMT_BAYER_BGGR16BE] = { 1, 0 },

    [AV_PIX_FMT_BAYER_RGGB16LE] = { 1, 0 },

    [AV_PIX_FMT_BAYER_RGGB16BE] = { 1, 0 },

    [AV_PIX_FMT_BAYER_GBRG16LE] = { 1, 0 },

    [AV_PIX_FMT_BAYER_GBRG16BE] = { 1, 0 },

    [AV_PIX_FMT_BAYER_GRBG16LE] = { 1, 0 },

    [AV_PIX_FMT_BAYER_GRBG16BE] = { 1, 0 },

    [AV_PIX_FMT_XYZ12BE]        = { 1, 1, 1 },

    [AV_PIX_FMT_XYZ12LE]        = { 1, 1, 1 },

    [AV_PIX_FMT_AYUV64LE]       = { 1, 1},

    [AV_PIX_FMT_AYUV64BE]       = { 1, 1 },

    [AV_PIX_FMT_P010LE]         = { 1, 1 },

    [AV_PIX_FMT_P010BE]         = { 1, 1 },

    [AV_PIX_FMT_P012LE]         = { 1, 1 },

    [AV_PIX_FMT_P012BE]         = { 1, 1 },

    [AV_PIX_FMT_P016LE]         = { 1, 1 },

    [AV_PIX_FMT_P016BE]         = { 1, 1 },

    [AV_PIX_FMT_GRAYF32LE]      = { 1, 1 },

    [AV_PIX_FMT_GRAYF32BE]      = { 1, 1 },

    [AV_PIX_FMT_GRAYF16LE]      = { 1, 0 },

    [AV_PIX_FMT_GRAYF16BE]      = { 1, 0 },

    [AV_PIX_FMT_YAF32LE]        = { 1, 0 },

    [AV_PIX_FMT_YAF32BE]        = { 1, 0 },

    [AV_PIX_FMT_YAF16LE]        = { 1, 0 },

    [AV_PIX_FMT_YAF16BE]        = { 1, 0 },

    [AV_PIX_FMT_YUVA422P12BE]   = { 1, 1 },

    [AV_PIX_FMT_YUVA422P12LE]   = { 1, 1 },

    [AV_PIX_FMT_YUVA444P12BE]   = { 1, 1 },

    [AV_PIX_FMT_YUVA444P12LE]   = { 1, 1 },

    [AV_PIX_FMT_NV24]           = { 1, 1 },

    [AV_PIX_FMT_NV42]           = { 1, 1 },

    [AV_PIX_FMT_Y210LE]         = { 1, 1 },

    [AV_PIX_FMT_Y212LE]         = { 1, 1 },

    [AV_PIX_FMT_Y216LE]         = { 1, 1 },

    [AV_PIX_FMT_X2RGB10LE]      = { 1, 1 },

    [AV_PIX_FMT_X2BGR10LE]      = { 1, 1 },

    [AV_PIX_FMT_NV20BE]         = { 1, 1 },

    [AV_PIX_FMT_NV20LE]         = { 1, 1 },

    [AV_PIX_FMT_P210BE]         = { 1, 1 },

    [AV_PIX_FMT_P210LE]         = { 1, 1 },

    [AV_PIX_FMT_P212BE]         = { 1, 1 },

    [AV_PIX_FMT_P212LE]         = { 1, 1 },

    [AV_PIX_FMT_P410BE]         = { 1, 1 },

    [AV_PIX_FMT_P410LE]         = { 1, 1 },

    [AV_PIX_FMT_P412BE]         = { 1, 1 },

    [AV_PIX_FMT_P412LE]         = { 1, 1 },

    [AV_PIX_FMT_P216BE]         = { 1, 1 },

    [AV_PIX_FMT_P216LE]         = { 1, 1 },

    [AV_PIX_FMT_P416BE]         = { 1, 1 },

    [AV_PIX_FMT_P416LE]         = { 1, 1 },

    [AV_PIX_FMT_NV16]           = { 1, 1 },

    [AV_PIX_FMT_VUYA]           = { 1, 1 },

    [AV_PIX_FMT_VUYX]           = { 1, 1 },

    [AV_PIX_FMT_RGBAF16BE]      = { 1, 0 },

    [AV_PIX_FMT_RGBAF16LE]      = { 1, 0 },

    [AV_PIX_FMT_RGBF16BE]       = { 1, 0 },

    [AV_PIX_FMT_RGBF16LE]       = { 1, 0 },

    [AV_PIX_FMT_RGBF32BE]       = { 1, 0 },

    [AV_PIX_FMT_RGBF32LE]       = { 1, 0 },

    [AV_PIX_FMT_XV30LE]         = { 1, 1 },

    [AV_PIX_FMT_XV36LE]         = { 1, 1 },

    [AV_PIX_FMT_XV36BE]         = { 1, 1 },

    [AV_PIX_FMT_XV48LE]         = { 1, 1 },

    [AV_PIX_FMT_XV48BE]         = { 1, 1 },

    [AV_PIX_FMT_AYUV]           = { 1, 1 },

    [AV_PIX_FMT_UYVA]           = { 1, 1 },

    [AV_PIX_FMT_VYU444]         = { 1, 1 },

    [AV_PIX_FMT_V30XLE]         = { 1, 1 },

};

int sws_isSupportedInput(enum AVPixelFormat pix_fmt)

{

    return (unsigned)pix_fmt < FF_ARRAY_ELEMS(legacy_format_entries) ?

    legacy_format_entries[pix_fmt].is_supported_in : 0;

}

int sws_isSupportedOutput(enum AVPixelFormat pix_fmt)

{

    return (unsigned)pix_fmt < FF_ARRAY_ELEMS(legacy_format_entries) ?

    legacy_format_entries[pix_fmt].is_supported_out : 0;

}

int sws_isSupportedEndiannessConversion(enum AVPixelFormat pix_fmt)

{

    return (unsigned)pix_fmt < FF_ARRAY_ELEMS(legacy_format_entries) ?

    legacy_format_entries[pix_fmt].is_supported_endianness : 0;

}

static void sanitize_fmt(SwsFormat *fmt, const AVPixFmtDescriptor *desc)

{

    if (desc->flags & (AV_PIX_FMT_FLAG_RGB | AV_PIX_FMT_FLAG_PAL | AV_PIX_FMT_FLAG_BAYER)) {

        /* RGB-like family */

        fmt->csp   = AVCOL_SPC_RGB;

        fmt->range = AVCOL_RANGE_JPEG;

    } else if (desc->flags & AV_PIX_FMT_FLAG_XYZ) {

        fmt->csp   = AVCOL_SPC_UNSPECIFIED;

        fmt->color = (SwsColor) {

            .prim = AVCOL_PRI_BT709, /* swscale currently hard-codes this XYZ matrix */

            .trc  = AVCOL_TRC_SMPTE428,

        };

    } else if (desc->nb_components < 3) {

        /* Grayscale formats */

        fmt->color.prim = AVCOL_PRI_UNSPECIFIED;

        fmt->csp        = AVCOL_SPC_UNSPECIFIED;

        if (desc->flags & AV_PIX_FMT_FLAG_FLOAT)

            fmt->range = AVCOL_RANGE_UNSPECIFIED;

        else

            fmt->range = AVCOL_RANGE_JPEG; // FIXME: this restriction should be lifted

    }

    switch (av_pix_fmt_desc_get_id(desc)) {

    case AV_PIX_FMT_YUVJ420P:

    case AV_PIX_FMT_YUVJ411P:

    case AV_PIX_FMT_YUVJ422P:

    case AV_PIX_FMT_YUVJ444P:

    case AV_PIX_FMT_YUVJ440P:

        fmt->range = AVCOL_RANGE_JPEG;

        break;

    }

    if (!desc->log2_chroma_w && !desc->log2_chroma_h)

        fmt->loc = AVCHROMA_LOC_UNSPECIFIED;

}

/**

 * This function also sanitizes and strips the input data, removing irrelevant

 * fields for certain formats.

 */

SwsFormat ff_fmt_from_frame(const AVFrame *frame, int field)

{

    const AVColorPrimariesDesc *primaries;

    AVFrameSideData *sd;

    enum AVPixelFormat format = frame->format;

    enum AVPixelFormat hw_format = AV_PIX_FMT_NONE;

#if CONFIG_UNSTABLE

    if (frame->hw_frames_ctx) {

        AVHWFramesContext *hwfc = (AVHWFramesContext *)frame->hw_frames_ctx->data;

        hw_format = frame->format;

        format = hwfc->sw_format;

    }

#endif

    const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(format);

    SwsFormat fmt = {

        .width     = frame->width,

        .height    = frame->height,

        .format    = format,

        .hw_format = hw_format,

        .range     = frame->color_range,

        .csp       = frame->colorspace,

        .loc       = frame->chroma_location,

        .desc      = desc,

        .color = {

            .prim = frame->color_primaries,

            .trc  = frame->color_trc,

        },

    };

    av_assert1(fmt.width > 0);

    av_assert1(fmt.height > 0);

    av_assert1(fmt.format != AV_PIX_FMT_NONE);

    av_assert0(desc);

    sanitize_fmt(&fmt, desc);

    if (frame->flags & AV_FRAME_FLAG_INTERLACED) {

        fmt.height = (fmt.height + (field == FIELD_TOP)) >> 1;

        fmt.interlaced = 1;

        fmt.field = field;

    }

    /* Set luminance and gamut information */

    fmt.color.min_luma = av_make_q(0, 1);

    switch (fmt.color.trc) {

    case AVCOL_TRC_SMPTE2084:

        fmt.color.max_luma = av_make_q(10000, 1); break;

    case AVCOL_TRC_ARIB_STD_B67:

        fmt.color.max_luma = av_make_q( 1000, 1); break; /* HLG reference display */

    default:

        fmt.color.max_luma = av_make_q(  203, 1); break; /* SDR reference brightness */

    }

    primaries = av_csp_primaries_desc_from_id(fmt.color.prim);

    if (primaries)

        fmt.color.gamut = primaries->prim;

    if ((sd = av_frame_get_side_data(frame, AV_FRAME_DATA_MASTERING_DISPLAY_METADATA))) {

        const AVMasteringDisplayMetadata *mdm = (const AVMasteringDisplayMetadata *) sd->data;

        if (mdm->has_luminance) {

            fmt.color.min_luma = mdm->min_luminance;

            fmt.color.max_luma = mdm->max_luminance;

        }

        if (mdm->has_primaries) {

            /* Ignore mastering display white point as it has no bearance on

             * the underlying content */

            fmt.color.gamut.r.x = mdm->display_primaries[0][0];

            fmt.color.gamut.r.y = mdm->display_primaries[0][1];

            fmt.color.gamut.g.x = mdm->display_primaries[1][0];

            fmt.color.gamut.g.y = mdm->display_primaries[1][1];

            fmt.color.gamut.b.x = mdm->display_primaries[2][0];

            fmt.color.gamut.b.y = mdm->display_primaries[2][1];

        }

    }

    if ((sd = av_frame_get_side_data(frame, AV_FRAME_DATA_DYNAMIC_HDR_PLUS))) {

        const AVDynamicHDRPlus *dhp = (const AVDynamicHDRPlus *) sd->data;

        const AVHDRPlusColorTransformParams *pars = &dhp->params[0];

        const AVRational nits = av_make_q(10000, 1);

        AVRational maxrgb = pars->maxscl[0];

        if (!dhp->num_windows || dhp->application_version > 1)

            goto skip_hdr10;

        /* Maximum of MaxSCL components */

        if (av_cmp_q(pars->maxscl[1], maxrgb) > 0)

            maxrgb = pars->maxscl[1];

        if (av_cmp_q(pars->maxscl[2], maxrgb) > 0)

            maxrgb = pars->maxscl[2];

        if (maxrgb.num > 0) {

            /* Estimate true luminance from MaxSCL */

            const AVLumaCoefficients *luma = av_csp_luma_coeffs_from_avcsp(fmt.csp);

            if (!luma)

                goto skip_hdr10;

            fmt.color.frame_peak = av_add_q(av_mul_q(luma->cr, pars->maxscl[0]),

                                   av_add_q(av_mul_q(luma->cg, pars->maxscl[1]),

                                            av_mul_q(luma->cb, pars->maxscl[2])));

            /* Scale the scene average brightness by the ratio between the

             * maximum luminance and the MaxRGB values */

            fmt.color.frame_avg = av_mul_q(pars->average_maxrgb,

                                           av_div_q(fmt.color.frame_peak, maxrgb));

        } else {

            /**

             * Calculate largest value from histogram to use as fallback for

             * clips with missing MaxSCL information. Note that this may end

             * up picking the "reserved" value at the 5% percentile, which in

             * practice appears to track the brightest pixel in the scene.

             */

            for (int i = 0; i < pars->num_distribution_maxrgb_percentiles; i++) {

                const AVRational pct = pars->distribution_maxrgb[i].percentile;

                if (av_cmp_q(pct, maxrgb) > 0)

                    maxrgb = pct;

                fmt.color.frame_peak = maxrgb;

                fmt.color.frame_avg  = pars->average_maxrgb;

            }

        }

        /* Rescale to nits */

        fmt.color.frame_peak = av_mul_q(nits, fmt.color.frame_peak);

        fmt.color.frame_avg  = av_mul_q(nits, fmt.color.frame_avg);

    }

skip_hdr10:

    /* PQ is always scaled down to absolute zero, so ignore mastering metadata */

    if (fmt.color.trc == AVCOL_TRC_SMPTE2084)

        fmt.color.min_luma = av_make_q(0, 1);

    return fmt;

}

void ff_fmt_from_pixfmt(enum AVPixelFormat pixfmt, SwsFormat *fmt)

{

    ff_fmt_clear(fmt);

    fmt->format = pixfmt;

    fmt->desc = av_pix_fmt_desc_get(pixfmt);

    sanitize_fmt(fmt, fmt->desc);

}

static int infer_prim_ref(SwsColor *csp, const SwsColor *ref)

{

    if (csp->prim != AVCOL_PRI_UNSPECIFIED)

        return 0;

    /* Reuse the reference gamut only for "safe", similar primaries */

    switch (ref->prim) {

    case AVCOL_PRI_BT709:

    case AVCOL_PRI_BT470M:

    case AVCOL_PRI_BT470BG:

    case AVCOL_PRI_SMPTE170M:

    case AVCOL_PRI_SMPTE240M:

        csp->prim  = ref->prim;

        csp->gamut = ref->gamut;

        break;

    default:

        csp->prim  = AVCOL_PRI_BT709;

        csp->gamut = av_csp_primaries_desc_from_id(csp->prim)->prim;

        break;

    }

    return 1;

}

static int infer_trc_ref(SwsColor *csp, const SwsColor *ref)

{

    if (csp->trc != AVCOL_TRC_UNSPECIFIED)

        return 0;

    /* Pick a suitable SDR transfer function, to try and minimize conversions */

    switch (ref->trc) {

    case AVCOL_TRC_UNSPECIFIED:

    /* HDR curves, never default to these */

    case AVCOL_TRC_SMPTE2084:

    case AVCOL_TRC_ARIB_STD_B67:

        csp->trc = AVCOL_TRC_BT709;

        csp->min_luma = av_make_q(0, 1);

        csp->max_luma = av_make_q(203, 1);

        break;

    default:

        csp->trc = ref->trc;

        csp->min_luma = ref->min_luma;

        csp->max_luma = ref->max_luma;

        break;

    }

    return 1;

}

bool ff_infer_colors(SwsColor *src, SwsColor *dst)

{

    int incomplete = 0;

    incomplete |= infer_prim_ref(dst, src);

    incomplete |= infer_prim_ref(src, dst);

    av_assert0(src->prim != AVCOL_PRI_UNSPECIFIED);

    av_assert0(dst->prim != AVCOL_PRI_UNSPECIFIED);

    incomplete |= infer_trc_ref(dst, src);

    incomplete |= infer_trc_ref(src, dst);

    av_assert0(src->trc != AVCOL_TRC_UNSPECIFIED);

    av_assert0(dst->trc != AVCOL_TRC_UNSPECIFIED);

    return incomplete;

}

void ff_sws_chroma_pos(const SwsFormat *fmt, bool *incomplete,

                       int *out_x_pos, int *out_y_pos)

{

    enum AVChromaLocation chroma_loc = fmt->loc;

    const int sub_x = fmt->desc->log2_chroma_w;

    const int sub_y = fmt->desc->log2_chroma_h;

    int x_pos, y_pos;

    /* Explicitly default to center siting for compatibility with swscale */

    if (chroma_loc == AVCHROMA_LOC_UNSPECIFIED) {

        chroma_loc = AVCHROMA_LOC_CENTER;

        *incomplete |= sub_x || sub_y;

    }

    /* av_chroma_location_enum_to_pos() always gives us values in the range from

     * 0 to 256, but we need to adjust this to the true value range of the

     * subsampling grid, which may be larger for h/v_sub > 1 */

    av_chroma_location_enum_to_pos(&x_pos, &y_pos, chroma_loc);

    x_pos *= (1 << sub_x) - 1;

    y_pos *= (1 << sub_y) - 1;

    /* Fix vertical chroma position for interlaced frames */

    if (sub_y && fmt->interlaced) {

        /* When vertically subsampling, chroma samples are effectively only

         * placed next to even rows. To access them from the odd field, we need

         * to account for this shift by offsetting the distance of one luma row.

         *

         * For 4x vertical subsampling (v_sub == 2), they are only placed

         * next to every *other* even row, so we need to shift by three luma

         * rows to get to the chroma sample. */

        if (fmt->field == FIELD_BOTTOM)

            y_pos += (256 << sub_y) - 256;

        /* Luma row distance is doubled for fields, so halve offsets */

        y_pos >>= 1;

    }

    *out_x_pos = x_pos;

    *out_y_pos = y_pos;

}

/* Variant of sws_test_format() for the ops-based code */

static int test_format_ops(enum AVPixelFormat format, int output);

static int test_format_legacy(enum AVPixelFormat format, int output)

{

    return output ? sws_isSupportedOutput(format) : sws_isSupportedInput(format);

}

int ff_sws_test_pixfmt_backend(const SwsBackend backends,

                               enum AVPixelFormat format, int output)

{

    /* The only non-ops backend is the legacy backend */

    const SwsBackend backends_ops = SWS_BACKEND_ALL ^ SWS_BACKEND_LEGACY;

    return ((backends & SWS_BACKEND_LEGACY) && test_format_legacy(format, output)) ||

           ((backends & backends_ops)       && test_format_ops(format, output));

}

int sws_test_format(enum AVPixelFormat format, int output)

{

    return ff_sws_test_pixfmt_backend(SWS_BACKEND_STABLE, format, output);

}

int sws_test_hw_format(enum AVPixelFormat format)

{

    switch (format) {

    case AV_PIX_FMT_NONE: return 1;

#if CONFIG_VULKAN

    case AV_PIX_FMT_VULKAN: return 1;

#endif

    default: return 0;

    }

}

int sws_test_colorspace(enum AVColorSpace csp, int output)

{

    switch (csp) {

    case AVCOL_SPC_UNSPECIFIED:

    case AVCOL_SPC_RGB:

    case AVCOL_SPC_BT709:

    case AVCOL_SPC_BT470BG:

    case AVCOL_SPC_SMPTE170M:

    case AVCOL_SPC_FCC:

    case AVCOL_SPC_SMPTE240M:

    case AVCOL_SPC_BT2020_NCL:

        return 1;

    default:

        return 0;

    }

}

int sws_test_primaries(enum AVColorPrimaries prim, int output)

{

    return ((prim > AVCOL_PRI_RESERVED0 && prim < AVCOL_PRI_NB) ||

            (prim >= AVCOL_PRI_EXT_BASE && prim < AVCOL_PRI_EXT_NB)) &&

           prim != AVCOL_PRI_RESERVED;

}

int sws_test_transfer(enum AVColorTransferCharacteristic trc, int output)

{

    av_csp_eotf_function eotf = output ? av_csp_itu_eotf_inv(trc)

                                       : av_csp_itu_eotf(trc);

    return trc == AVCOL_TRC_UNSPECIFIED || eotf != NULL;

}

static int test_range(enum AVColorRange range)

{

    return (unsigned)range < AVCOL_RANGE_NB;

}

static int test_loc(enum AVChromaLocation loc)

{

    return (unsigned)loc < AVCHROMA_LOC_NB;

}

int ff_test_fmt(const SwsBackend backends, const SwsFormat *fmt, int output)

{

    return fmt->width > 0 && fmt->height > 0            &&

           ff_sws_test_pixfmt_backend(backends, fmt->format, output) &&

           sws_test_colorspace(fmt->csp,        output) &&

           sws_test_primaries (fmt->color.prim, output) &&

           sws_test_transfer  (fmt->color.trc,  output) &&

           sws_test_hw_format (fmt->hw_format)          &&

           test_range         (fmt->range)              &&

           test_loc           (fmt->loc);

}

int sws_test_frame(const AVFrame *frame, int output)

{

    for (int field = 0; field < 2; field++) {

        const SwsFormat fmt = ff_fmt_from_frame(frame, field);

        if (!ff_test_fmt(SWS_BACKEND_STABLE, &fmt, output))

            return 0;

        if (!fmt.interlaced)

            break;

    }

    return 1;

}

int sws_is_noop(const AVFrame *dst, const AVFrame *src)

{

    for (int field = 0; field < 2; field++) {

        SwsFormat dst_fmt = ff_fmt_from_frame(dst, field);

        SwsFormat src_fmt = ff_fmt_from_frame(src, field);

        if (!ff_fmt_equal(&dst_fmt, &src_fmt))

            return 0;

        if (!dst_fmt.interlaced)

            break;

    }

    return 1;

}

void ff_sws_frame_from_avframe(SwsFrame *dst, const AVFrame *src)

{

    dst->format  = src->format;

    dst->width   = src->width;

    dst->height  = src->height;

    dst->avframe = src;

    for (int i = 0; i < FF_ARRAY_ELEMS(dst->data); i++) {

        dst->data[i]     = src->data[i];

        dst->linesize[i] = src->linesize[i];

    }

}

#if CONFIG_UNSTABLE

/**

 * Returns the underlying descriptor for fake formats like PAL8 whose

 * descriptors alone do not fully describe the pixel data.

 */

static inline const AVPixFmtDescriptor *fmt_desc_decoded(enum AVPixelFormat fmt)

{

    if (fmt == AV_PIX_FMT_PAL8)

        return av_pix_fmt_desc_get(AV_PIX_FMT_RGB32);

    const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(fmt);

    av_assert0(!(desc->flags & AV_PIX_FMT_FLAG_PAL));

    return desc;

}

/* Returns the type suitable for a pixel after fully decoding/unpacking it */

static SwsPixelType fmt_pixel_type(enum AVPixelFormat fmt)

{

    const AVPixFmtDescriptor *desc = fmt_desc_decoded(fmt);

    const int bits = FFALIGN(desc->comp[0].depth, 8);

    if (desc->flags & AV_PIX_FMT_FLAG_FLOAT) {

        switch (bits) {

        case 32: return SWS_PIXEL_F32;

        /* TODO: no support for 16-bit float yet */

        }

    } else {

        switch (bits) {

        case  8: return SWS_PIXEL_U8;

        case 16: return SWS_PIXEL_U16;

        /* TODO: AVRational cannot represent UINT32_MAX */

        }

    }

    return SWS_PIXEL_NONE;

}

/* A regular format is defined as any format that contains only a single

 * component per elementary data type (i.e. no sub-byte pack/unpack needed),

 * and whose components map 1:1 onto elementary data units */

static int is_regular_fmt(enum AVPixelFormat fmt)

{

    const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(fmt);

    if (desc->flags & (AV_PIX_FMT_FLAG_PAL | AV_PIX_FMT_FLAG_BAYER))

        return 0; /* no 1:1 correspondence between components and data units */

    if (desc->flags & (AV_PIX_FMT_FLAG_BITSTREAM))

        return 0; /* bitstream formats are packed by definition */

    if ((desc->flags & AV_PIX_FMT_FLAG_PLANAR) || desc->nb_components == 1)

        return 1; /* planar formats are regular by definition */

    const int step = desc->comp[0].step;

    int total_bits = 0;

    for (int i = 0; i < desc->nb_components; i++) {

        if (desc->comp[i].shift || desc->comp[i].step != step)

            return 0; /* irregular/packed format */

        total_bits += desc->comp[i].depth;

    }

    /* Exclude formats with missing components like RGB0, 0RGB, etc. */

    return total_bits == step * 8;

}

typedef struct FmtInfo {

    SwsReadWriteOp rw;

    SwsSwizzleOp   swizzle;

    SwsPackOp      pack;

    int            shift;

} FmtInfo;

#define BITSTREAM_FMT(SWIZ, FRAC, MODE, ...) (FmtInfo) {        \

    .rw = { .elems = 1, .frac = FRAC, .mode = MODE },           \

    .swizzle = SWIZ,                                            \

    __VA_ARGS__                                                 \

}

#define SUBPACKED_FMT(SWIZ, ...) (FmtInfo) {                    \

    .rw = { .elems = 1, .mode = SWS_RW_PACKED },                \

    .swizzle = SWIZ,                                            \

    .pack.pattern = {__VA_ARGS__},                              \

}

#define PACKED_FMT(SWIZ, N, ...) (FmtInfo) {                    \

    .rw = { .elems = N, .mode = SWS_RW_PACKED },                \

    .swizzle = SWIZ,                                            \

    __VA_ARGS__                                                 \

}

#define RGBA SWS_SWIZZLE(0, 1, 2, 3)

#define BGRA SWS_SWIZZLE(2, 1, 0, 3)

#define ARGB SWS_SWIZZLE(3, 0, 1, 2)

#define ABGR SWS_SWIZZLE(3, 2, 1, 0)

#define AVYU SWS_SWIZZLE(3, 2, 0, 1)

#define VYUA SWS_SWIZZLE(2, 0, 1, 3)

#define UYVA SWS_SWIZZLE(1, 0, 2, 3)

#define VUYA BGRA

static FmtInfo fmt_info_irregular(enum AVPixelFormat fmt)

{

    switch (fmt) {

    /* Bitstream formats */

    case AV_PIX_FMT_MONOWHITE:

    case AV_PIX_FMT_MONOBLACK:

        return BITSTREAM_FMT(RGBA, 3, SWS_RW_PLANAR);

    case AV_PIX_FMT_RGB4: return BITSTREAM_FMT(RGBA, 1, SWS_RW_PACKED, .pack = {{ 1, 2, 1 }});

    case AV_PIX_FMT_BGR4: return BITSTREAM_FMT(BGRA, 1, SWS_RW_PACKED, .pack = {{ 1, 2, 1 }});

    /* Sub-packed 8-bit aligned formats */

    case AV_PIX_FMT_RGB4_BYTE:  return SUBPACKED_FMT(RGBA, 1, 2, 1);

    case AV_PIX_FMT_BGR4_BYTE:  return SUBPACKED_FMT(BGRA, 1, 2, 1);

    case AV_PIX_FMT_RGB8:       return SUBPACKED_FMT(RGBA, 3, 3, 2);

    case AV_PIX_FMT_BGR8:       return SUBPACKED_FMT(BGRA, 2, 3, 3);

    /* Sub-packed 16-bit aligned formats */

    case AV_PIX_FMT_RGB565LE:

    case AV_PIX_FMT_RGB565BE:

        return SUBPACKED_FMT(RGBA, 5, 6, 5);

    case AV_PIX_FMT_BGR565LE:

    case AV_PIX_FMT_BGR565BE:

        return SUBPACKED_FMT(BGRA, 5, 6, 5);

    case AV_PIX_FMT_RGB555LE:

    case AV_PIX_FMT_RGB555BE:

        return SUBPACKED_FMT(RGBA, 5, 5, 5);

    case AV_PIX_FMT_BGR555LE:

    case AV_PIX_FMT_BGR555BE:

        return SUBPACKED_FMT(BGRA, 5, 5, 5);

    case AV_PIX_FMT_RGB444LE:

    case AV_PIX_FMT_RGB444BE:

        return SUBPACKED_FMT(RGBA, 4, 4, 4);

    case AV_PIX_FMT_BGR444LE:

    case AV_PIX_FMT_BGR444BE:

        return SUBPACKED_FMT(BGRA, 4, 4, 4);

    /* Sub-packed 32-bit aligned formats */

    case AV_PIX_FMT_X2RGB10LE:

    case AV_PIX_FMT_X2RGB10BE:

        return SUBPACKED_FMT(ARGB, 2, 10, 10, 10);

    case AV_PIX_FMT_X2BGR10LE:

    case AV_PIX_FMT_X2BGR10BE:

        return SUBPACKED_FMT(ABGR, 2, 10, 10, 10);

    case AV_PIX_FMT_XV30LE:

    case AV_PIX_FMT_XV30BE:

        return SUBPACKED_FMT(AVYU, 2, 10, 10, 10);

    case AV_PIX_FMT_V30XLE:

    case AV_PIX_FMT_V30XBE:

        return SUBPACKED_FMT(VYUA, 10, 10, 10, 2);

    /* 3-component formats with extra padding */

    case AV_PIX_FMT_RGB0:   return PACKED_FMT(RGBA, 4);

    case AV_PIX_FMT_BGR0:   return PACKED_FMT(BGRA, 4);

    case AV_PIX_FMT_0RGB:   return PACKED_FMT(ARGB, 4);

    case AV_PIX_FMT_0BGR:   return PACKED_FMT(ABGR, 4);

    case AV_PIX_FMT_VUYX:   return PACKED_FMT(VUYA, 4);

    case AV_PIX_FMT_XV36LE:

    case AV_PIX_FMT_XV36BE:

        return PACKED_FMT(UYVA, 4, .shift = 4);

    case AV_PIX_FMT_XV48LE:

    case AV_PIX_FMT_XV48BE:

        return PACKED_FMT(UYVA, 4);

    /* Miscellaneous irregular formats */

    case AV_PIX_FMT_PAL8:

        return (FmtInfo) {

            .rw = { .elems = 4, .mode = SWS_RW_PALETTE },

            /* PAL8 is explicitly defined as endian-dependent */

        #if AV_HAVE_BIGENDIAN

            .swizzle = ARGB,

        #else

            .swizzle = BGRA,

        #endif

        };

    }

    return (FmtInfo) {0};

}

struct comp {

    int index;

    int plane;

    int offset;

};

/* Compare by (plane, offset) */

static int cmp_comp(const void *a, const void *b) {

    const struct comp *ca = a;

    const struct comp *cb = b;

    if (ca->plane != cb->plane)

        return ca->plane - cb->plane;

    return ca->offset - cb->offset;

}

static int fmt_analyze_regular(const AVPixFmtDescriptor *desc, SwsReadWriteOp *rw_op,

                               SwsSwizzleOp *swizzle, SwsShiftOp *shift)

{

    if (desc->nb_components == 2) {

        /* YA formats */

        *swizzle = SWS_SWIZZLE(0, 3, 1, 2);

    } else {

        /* Sort by increasing component order */

        struct comp sorted[4] = { {0}, {1}, {2}, {3} };

        for (int i = 0; i < desc->nb_components; i++) {

            sorted[i].plane  = desc->comp[i].plane;

            sorted[i].offset = desc->comp[i].offset;

        }

        qsort(sorted, desc->nb_components, sizeof(struct comp), cmp_comp);

        SwsSwizzleOp swiz = SWS_SWIZZLE(0, 1, 2, 3);

        for (int i = 0; i < desc->nb_components; i++)

            swiz.in[i] = sorted[i].index;

        *swizzle = swiz;

    }

    SwsReadWriteMode mode = SWS_RW_PLANAR;

    if (desc->nb_components > 1 && !(desc->flags & AV_PIX_FMT_FLAG_PLANAR))

        mode = SWS_RW_PACKED;

    *shift = (SwsShiftOp) { desc->comp[0].shift };

    *rw_op = (SwsReadWriteOp) {