mpv/video/out/opengl/formats.c

#include "common/common.h"
#include "formats.h"

enum {
    // --- GL type aliases (for readability)
    T_U8        = GL_UNSIGNED_BYTE,
    T_U16       = GL_UNSIGNED_SHORT,
    T_FL        = GL_FLOAT,
};

// List of allowed formats, and their usability for bilinear filtering and FBOs.
// This is limited to combinations that are useful for our renderer.
static const struct gl_format gl_formats[] = {
    // These are used for desktop GL 3+, and GLES 3+ with GL_EXT_texture_norm16.
    {GL_R8,                  GL_RED,             T_U8,  F_CF | F_GL3 | F_GL2F | F_ES3},
    {GL_RG8,                 GL_RG,              T_U8,  F_CF | F_GL3 | F_GL2F | F_ES3},
    {GL_RGB8,                GL_RGB,             T_U8,  F_CF | F_GL3 | F_GL2F | F_ES3},
    {GL_RGBA8,               GL_RGBA,            T_U8,  F_CF | F_GL3 | F_GL2F | F_ES3},
    {GL_R16,                 GL_RED,             T_U16, F_CF | F_GL3 | F_GL2F | F_EXT16},
    {GL_RG16,                GL_RG,              T_U16, F_CF | F_GL3 | F_GL2F | F_EXT16},
    {GL_RGB16,               GL_RGB,             T_U16, F_CF | F_GL3 | F_GL2F},
    {GL_RGBA16,              GL_RGBA,            T_U16, F_CF | F_GL3 | F_GL2F | F_EXT16},

    // Specifically not color-renderable.
    {GL_RGB16,               GL_RGB,             T_U16, F_TF | F_EXT16},

    // GL2 legacy. Ignores possibly present FBO extensions (no CF flag set).
    {GL_LUMINANCE8,          GL_LUMINANCE,       T_U8,  F_TF | F_GL2},
    {GL_LUMINANCE8_ALPHA8,   GL_LUMINANCE_ALPHA, T_U8,  F_TF | F_GL2},
    {GL_RGB8,                GL_RGB,             T_U8,  F_TF | F_GL2},
    {GL_RGBA8,               GL_RGBA,            T_U8,  F_TF | F_GL2},
    {GL_LUMINANCE16,         GL_LUMINANCE,       T_U16, F_TF | F_GL2},
    {GL_LUMINANCE16_ALPHA16, GL_LUMINANCE_ALPHA, T_U16, F_TF | F_GL2},
    {GL_RGB16,               GL_RGB,             T_U16, F_TF | F_GL2},
    {GL_RGBA16,              GL_RGBA,            T_U16, F_TF | F_GL2},

    // ES2 legacy
    {GL_LUMINANCE,           GL_LUMINANCE,       T_U8,  F_TF | F_ES2},
    {GL_LUMINANCE_ALPHA,     GL_LUMINANCE_ALPHA, T_U8,  F_TF | F_ES2},
    {GL_RGB,                 GL_RGB,             T_U8,  F_TF | F_ES2},
    {GL_RGBA,                GL_RGBA,            T_U8,  F_TF | F_ES2},

    // Non-normalized integer formats.
    // Follows ES 3.0 as to which are color-renderable.
    {GL_R8UI,                GL_RED_INTEGER,     T_U8,  F_CR | F_GL3 | F_ES3},
    {GL_RG8UI,               GL_RG_INTEGER,      T_U8,  F_CR | F_GL3 | F_ES3},
    {GL_RGB8UI,              GL_RGB_INTEGER,     T_U8,         F_GL3 | F_ES3},
    {GL_RGBA8UI,             GL_RGBA_INTEGER,    T_U8,  F_CR | F_GL3 | F_ES3},
    {GL_R16UI,               GL_RED_INTEGER,     T_U16, F_CR | F_GL3 | F_ES3},
    {GL_RG16UI,              GL_RG_INTEGER,      T_U16, F_CR | F_GL3 | F_ES3},
    {GL_RGB16UI,             GL_RGB_INTEGER,     T_U16,        F_GL3 | F_ES3},
    {GL_RGBA16UI,            GL_RGBA_INTEGER,    T_U16, F_CR | F_GL3 | F_ES3},

    // On GL3+ or GL2.1 with GL_ARB_texture_float, floats work fully.
    {GL_R16F,                GL_RED,             T_FL,  F_F16 | F_CF | F_GL3 | F_GL2F},
    {GL_RG16F,               GL_RG,              T_FL,  F_F16 | F_CF | F_GL3 | F_GL2F},
    {GL_RGB16F,              GL_RGB,             T_FL,  F_F16 | F_CF | F_GL3 | F_GL2F},
    {GL_RGBA16F,             GL_RGBA,            T_FL,  F_F16 | F_CF | F_GL3 | F_GL2F},
    {GL_R32F,                GL_RED,             T_FL,          F_CF | F_GL3 | F_GL2F},
    {GL_RG32F,               GL_RG,              T_FL,          F_CF | F_GL3 | F_GL2F},
    {GL_RGB32F,              GL_RGB,             T_FL,          F_CF | F_GL3 | F_GL2F},
    {GL_RGBA32F,             GL_RGBA,            T_FL,          F_CF | F_GL3 | F_GL2F},

    // Note: we simply don't support float anything on ES2, despite extensions.
    // We also don't bother with non-filterable float formats, and we ignore
    // 32 bit float formats that are not blendable when rendering to them.

    // On ES3.2+, both 16 bit floats work fully (except 3-component formats).
    // F_EXTF16 implies extensions that also enable 16 bit floats fully.
    {GL_R16F,                GL_RED,             T_FL,  F_F16 | F_CF | F_ES32 | F_EXTF16},
    {GL_RG16F,               GL_RG,              T_FL,  F_F16 | F_CF | F_ES32 | F_EXTF16},
    {GL_RGB16F,              GL_RGB,             T_FL,  F_F16 | F_TF | F_ES32 | F_EXTF16},
    {GL_RGBA16F,             GL_RGBA,            T_FL,  F_F16 | F_CF | F_ES32 | F_EXTF16},

    // On ES3.0+, 16 bit floats are texture-filterable.
    // Don't bother with 32 bit floats; they exist but are neither CR nor TF.
    {GL_R16F,                GL_RED,             T_FL,  F_F16 | F_TF | F_ES3},
    {GL_RG16F,               GL_RG,              T_FL,  F_F16 | F_TF | F_ES3},
    {GL_RGB16F,              GL_RGB,             T_FL,  F_F16 | F_TF | F_ES3},
    {GL_RGBA16F,             GL_RGBA,            T_FL,  F_F16 | F_TF | F_ES3},

    // These might be useful as FBO formats.
    {GL_RGB10_A2,            GL_RGBA,
     GL_UNSIGNED_INT_2_10_10_10_REV,                    F_CF | F_GL3 | F_ES3},
    {GL_RGBA12,              GL_RGBA,            T_U16, F_CF | F_GL2 | F_GL3},
    {GL_RGB10,               GL_RGB,             T_U16, F_CF | F_GL2 | F_GL3},

    // Special formats.
    {GL_RGB8,                GL_RGB,
     GL_UNSIGNED_SHORT_5_6_5,                           F_TF | F_GL2 | F_GL3},
    {GL_RGB,                 GL_RGB_422_APPLE,
     GL_UNSIGNED_SHORT_8_8_APPLE,                       F_TF | F_APPL},
    {GL_RGB,                 GL_RGB_422_APPLE,
     GL_UNSIGNED_SHORT_8_8_REV_APPLE,                   F_TF | F_APPL},

    {0}
};

// Pairs of mpv formats and OpenGL types that match directly. Code using this
// is supposed to look through the gl_formats table, and there is supposed to
// be exactly 1 matching entry (which tells you format/internal format).
static const int special_formats[][2] = {
    {IMGFMT_RGB565,     GL_UNSIGNED_SHORT_5_6_5},
    {IMGFMT_UYVY,       GL_UNSIGNED_SHORT_8_8_APPLE},
    {IMGFMT_YUYV,       GL_UNSIGNED_SHORT_8_8_REV_APPLE},
    {0}
};

// Return an or-ed combination of all F_ flags that apply.
int gl_format_feature_flags(GL *gl)
{
    return (gl->version == 210 ? F_GL2 : 0)
         | (gl->version >= 300 ? F_GL3 : 0)
         | (gl->es == 200 ? F_ES2 : 0)
         | (gl->es >= 300 ? F_ES3 : 0)
         | (gl->es >= 320 ? F_ES32 : 0)
         | (gl->mpgl_caps & MPGL_CAP_EXT16 ? F_EXT16 : 0)
         | ((gl->es >= 300 &&
            (gl->mpgl_caps & MPGL_CAP_EXT_CR_HFLOAT)) ? F_EXTF16 : 0)
         | ((gl->version == 210 &&
            (gl->mpgl_caps & MPGL_CAP_ARB_FLOAT) &&
            (gl->mpgl_caps & MPGL_CAP_TEX_RG) &&
            (gl->mpgl_caps & MPGL_CAP_FB)) ? F_GL2F : 0)
         | (gl->mpgl_caps & MPGL_CAP_APPLE_RGB_422 ? F_APPL : 0);
}

// Return the entry for the given internal format. Return NULL if unsupported.
const struct gl_format *gl_find_internal_format(GL *gl, GLint internal_format)
{
    int features = gl_format_feature_flags(gl);
    for (int n = 0; gl_formats[n].type; n++) {
        const struct gl_format *f = &gl_formats[n];
        if (f->internal_format == internal_format && (f->flags & features))
            return f;
    }
    return NULL;
}

const struct gl_format *gl_find_special_format(GL *gl, int mpfmt)
{
    int features = gl_format_feature_flags(gl);
    for (int n = 0; special_formats[n][0]; n++) {
        if (special_formats[n][0] == mpfmt) {
            GLenum type = special_formats[n][1];
            for (int i = 0; gl_formats[i].type; i++) {
                const struct gl_format *f = &gl_formats[i];
                if (f->type == type && (f->flags & features))
                    return f;
            }
            break;
        }
    }
    return NULL;
}

// type: one of MPGL_TYPE_*
// flags: bitset of F_*, all flags must be present
const struct gl_format *gl_find_format(GL *gl, int type, int flags,
                                       int bytes_per_component, int n_components)
{
    if (!bytes_per_component || !n_components || !type)
        return NULL;
    int features = gl_format_feature_flags(gl);
    for (int n = 0; gl_formats[n].type; n++) {
        const struct gl_format *f = &gl_formats[n];
        if ((f->flags & features) &&
            ((f->flags & flags) == flags) &&
            gl_format_type(f) == type &&
            gl_component_size(f->type) == bytes_per_component &&
            gl_format_components(f->format) == n_components)
            return f;
    }
    return NULL;
}

// Return a texture-filterable unsigned normalized fixed point format.
const struct gl_format *gl_find_unorm_format(GL *gl, int bytes_per_component,
                                             int n_components)
{
    return gl_find_format(gl, MPGL_TYPE_UNORM, F_TF, bytes_per_component,
                          n_components);
}

// Return an unsigned integer format.
const struct gl_format *gl_find_uint_format(GL *gl, int bytes_per_component,
                                            int n_components)
{
    return gl_find_format(gl, MPGL_TYPE_UINT, 0, bytes_per_component,
                          n_components);
}

// Return a 16 bit float format. Note that this will return a GL_FLOAT format
// with 32 bit per component; just the internal representation is smaller.
// Some GL versions will allow upload with GL_HALF_FLOAT as well.
const struct gl_format *gl_find_float16_format(GL *gl, int n_components)
{
    return gl_find_format(gl, MPGL_TYPE_FLOAT, F_F16, 4, n_components);
}

int gl_format_type(const struct gl_format *format)
{
    if (!format)
        return 0;
    if (format->type == GL_FLOAT)
        return MPGL_TYPE_FLOAT;
    if (gl_integer_format_to_base(format->format))
        return MPGL_TYPE_UINT;
    return MPGL_TYPE_UNORM;
}

// Return base internal format of an integer format, or 0 if it's not integer.
// "format" is like in struct gl_format.
GLenum gl_integer_format_to_base(GLenum format)
{
    switch (format) {
    case GL_RED_INTEGER:        return GL_RED;
    case GL_RG_INTEGER:         return GL_RG;
    case GL_RGB_INTEGER:        return GL_RGB;
    case GL_RGBA_INTEGER:       return GL_RGBA;
    }
    return 0;
}

// Return whether it's a non-normalized integer format.
// "format" is like in struct gl_format.
bool gl_is_integer_format(GLenum format)
{
    return !!gl_integer_format_to_base(format);
}

// Return the number of bytes per component this format implies.
// Returns 0 for formats with non-byte alignments and formats which
// merge multiple components (like GL_UNSIGNED_SHORT_5_6_5).
// "type" is like in struct gl_format.
int gl_component_size(GLenum type)
{
    switch (type) {
    case GL_UNSIGNED_BYTE:                      return 1;
    case GL_UNSIGNED_SHORT:                     return 2;
    case GL_FLOAT:                              return 4;
    }
    return 0;
}

// Return the number of separate color components.
// "format" is like in struct gl_format.
int gl_format_components(GLenum format)
{
    switch (format) {
    case GL_RED:
    case GL_RED_INTEGER:
    case GL_LUMINANCE:
        return 1;
    case GL_RG:
    case GL_RG_INTEGER:
    case GL_LUMINANCE_ALPHA:
        return 2;
    case GL_RGB:
    case GL_RGB_INTEGER:
        return 3;
    case GL_RGBA:
    case GL_RGBA_INTEGER:
        return 4;
    }
    return 0;
}

// Return the number of bytes per pixel for the given format.
// Parameter names like in struct gl_format.
int gl_bytes_per_pixel(GLenum format, GLenum type)
{
    // Formats with merged components are special.
    switch (type) {
    case GL_UNSIGNED_INT_2_10_10_10_REV:        return 4;
    case GL_UNSIGNED_SHORT_5_6_5:               return 2;
    case GL_UNSIGNED_SHORT_8_8_APPLE:           return 2;
    case GL_UNSIGNED_SHORT_8_8_REV_APPLE:       return 2;
    }

    return gl_component_size(type) * gl_format_components(format);
}

// The format has cleanly separated components (on byte boundaries).
bool gl_format_is_regular(const struct gl_format *fmt)
{
    int bpp = gl_component_size(fmt->type) * gl_format_components(fmt->format);
    return bpp == gl_bytes_per_pixel(fmt->format, fmt->type);
}

// Like gl_find_unorm_format(), but takes bits (not bytes), and if no fixed
// point format is available, return an unsigned integer format.
static const struct gl_format *find_plane_format(GL *gl, int bytes, int n_channels)
{
    const struct gl_format *f = gl_find_unorm_format(gl, bytes, n_channels);
    if (f)
        return f;
    return gl_find_uint_format(gl, bytes, n_channels);
}

static int find_comp(uint8_t *components, int num_components, int component)
{
    for (int n = 0; n < num_components; n++) {
        if (components[n] == component)
            return n;
    }
    return -1;
}

// Put a mapping of imgfmt to OpenGL textures into *out. Basically it selects
// the correct texture formats needed to represent an imgfmt in OpenGL, with
// textures using the same memory organization as on the CPU.
// Each plane is represented by a texture, and each texture has a RGBA
// component order. out->color_swizzle is set to permute the components back.
// May return integer formats for >8 bit formats, if the driver has no
// normalized 16 bit formats.
// Returns false (and *out is set to all-0) if no format found.
bool gl_get_imgfmt_desc(GL *gl, int imgfmt, struct gl_imgfmt_desc *out)
{
    *out = (struct gl_imgfmt_desc){0};

    struct mp_imgfmt_desc desc = mp_imgfmt_get_desc(imgfmt);
    if (!desc.id)
        return false;

    if (desc.num_planes > 4 || (desc.flags & MP_IMGFLAG_HWACCEL))
        return false;

    const struct gl_format *planes[4] = {0};
    char swizzle_tmp[MP_NUM_COMPONENTS + 1] = {0};
    char *swizzle = "rgba";
    struct mp_regular_imgfmt regfmt = {0};

    if (mp_get_regular_imgfmt(&regfmt, imgfmt)) {
        uint8_t components[MP_NUM_COMPONENTS + 1] = {0};
        int num_components = 0;
        for (int n = 0; n < regfmt.num_planes; n++) {
            struct mp_regular_imgfmt_plane *plane = &regfmt.planes[n];
            planes[n] = find_plane_format(gl, regfmt.component_size,
                                          plane->num_components);
            for (int i = 0; i < plane->num_components; i++)
                components[num_components++] = plane->components[i];
        }
        swizzle = swizzle_tmp;
        for (int c = 0; c < 4; c++) {
            int loc = find_comp(components, num_components, c + 1);
            swizzle[c] = "rgba"[loc >= 0 && loc < 4 ? loc : 0];
        }
        swizzle[4] = '\0';
        goto supported;
    }

    // Special formats for which OpenGL happens to have direct support.
    planes[0] = gl_find_special_format(gl, imgfmt);
    if (planes[0]) {
        // Packed YUV Apple formats color permutation
        if (planes[0]->format == GL_RGB_422_APPLE)
            swizzle = "gbra";
        goto supported;
    }

    // Unsupported format
    return false;

supported:

    snprintf(out->swizzle, sizeof(out->swizzle), "%s", swizzle);
    out->num_planes = desc.num_planes;
    for (int n = 0; n < desc.num_planes; n++) {
        if (!planes[n])
            return false;
        out->xs[n] = desc.xs[n];
        out->ys[n] = desc.ys[n];
        out->planes[n] = planes[n];
    }
    return true;
}