FFmpeg coverage

GCC Code Coverage Report

Directory:	../../../ffmpeg/		Exec	Total	Coverage
File:	src/libavcodec/texturedsp.c	Lines:	243	243	100.0 %
Date:	2020-08-14 10:39:37	Branches:	72	72	100.0 %


/*
 * Texture block decompression
 * Copyright (C) 2009 Benjamin Dobell, Glass Echidna
 * Copyright (C) 2012 Matthäus G. "Anteru" Chajdas (http://anteru.net)
 * Copyright (C) 2015 Vittorio Giovara <vittorio.giovara@gmail.com>
 *
 * Permission is hereby granted, free of charge, to any person obtaining a
 * copy of this software and associated documentation files (the "Software"),
 * to deal in the Software without restriction, including without limitation
 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
 * and/or sell copies of the Software, and to permit persons to whom the
 * Software is furnished to do so, subject to the following conditions:
 * The above copyright notice and this permission notice shall be included
 * in all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
 * IN THE SOFTWARE.
 */

#include <stddef.h>
#include <stdint.h>

#include "libavutil/attributes.h"
#include "libavutil/common.h"
#include "libavutil/intreadwrite.h"
#include "libavutil/libm.h"

#include "texturedsp.h"

#define RGBA(r, g, b, a) (((uint8_t)(r) <<  0) | \
                          ((uint8_t)(g) <<  8) | \
                          ((uint8_t)(b) << 16) | \
                          ((unsigned)(uint8_t)(a) << 24))

static av_always_inline void extract_color(uint32_t colors[4],
                                           uint16_t color0,
                                           uint16_t color1,
                                           int dxtn, int alpha)
{
    int tmp;
    uint8_t r0, g0, b0, r1, g1, b1;
    uint8_t a = dxtn ? 0 : 255;

    tmp = (color0 >> 11) * 255 + 16;
    r0  = (uint8_t) ((tmp / 32 + tmp) / 32);
    tmp = ((color0 & 0x07E0) >> 5) * 255 + 32;
    g0  = (uint8_t) ((tmp / 64 + tmp) / 64);
    tmp = (color0 & 0x001F) * 255 + 16;
    b0  = (uint8_t) ((tmp / 32 + tmp) / 32);

    tmp = (color1 >> 11) * 255 + 16;
    r1  = (uint8_t) ((tmp / 32 + tmp) / 32);
    tmp = ((color1 & 0x07E0) >> 5) * 255 + 32;
    g1  = (uint8_t) ((tmp / 64 + tmp) / 64);
    tmp = (color1 & 0x001F) * 255 + 16;
    b1  = (uint8_t) ((tmp / 32 + tmp) / 32);

    if (dxtn || color0 > color1) {
        colors[0] = RGBA(r0, g0, b0, a);
        colors[1] = RGBA(r1, g1, b1, a);
        colors[2] = RGBA((2 * r0 + r1) / 3,
                         (2 * g0 + g1) / 3,
                         (2 * b0 + b1) / 3,
                         a);
        colors[3] = RGBA((2 * r1 + r0) / 3,
                         (2 * g1 + g0) / 3,
                         (2 * b1 + b0) / 3,
                         a);
    } else {
        colors[0] = RGBA(r0, g0, b0, a);
        colors[1] = RGBA(r1, g1, b1, a);
        colors[2] = RGBA((r0 + r1) / 2,
                         (g0 + g1) / 2,
                         (b0 + b1) / 2,
                         a);
        colors[3] = RGBA(0, 0, 0, alpha);
    }
}

static inline void dxt1_block_internal(uint8_t *dst, ptrdiff_t stride,
                                       const uint8_t *block, uint8_t alpha)
{
    int x, y;
    uint32_t colors[4];
    uint16_t color0 = AV_RL16(block + 0);
    uint16_t color1 = AV_RL16(block + 2);
    uint32_t code   = AV_RL32(block + 4);

    extract_color(colors, color0, color1, 0, alpha);

    for (y = 0; y < 4; y++) {
        for (x = 0; x < 4; x++) {
            uint32_t pixel = colors[code & 3];
            code >>= 2;
            AV_WL32(dst + x * 4, pixel);
        }
        dst += stride;
    }
}

/**
 * Decompress one block of a DXT1 texture and store the resulting
 * RGBA pixels in 'dst'. Alpha component is fully opaque.
 *
 * @param dst    output buffer.
 * @param stride scanline in bytes.
 * @param block  block to decompress.
 * @return how much texture data has been consumed.
 */
static int dxt1_block(uint8_t *dst, ptrdiff_t stride, const uint8_t *block)
{
    dxt1_block_internal(dst, stride, block, 255);

    return 8;
}

/**
 * Decompress one block of a DXT1 with 1-bit alpha texture and store
 * the resulting RGBA pixels in 'dst'. Alpha is either fully opaque or
 * fully transparent.
 *
 * @param dst    output buffer.
 * @param stride scanline in bytes.
 * @param block  block to decompress.
 * @return how much texture data has been consumed.
 */
static int dxt1a_block(uint8_t *dst, ptrdiff_t stride, const uint8_t *block)
{
    dxt1_block_internal(dst, stride, block, 0);

    return 8;
}

static inline void dxt3_block_internal(uint8_t *dst, ptrdiff_t stride,
                                       const uint8_t *block)
{
    int x, y;
    uint32_t colors[4];
    uint16_t color0 = AV_RL16(block +  8);
    uint16_t color1 = AV_RL16(block + 10);
    uint32_t code   = AV_RL32(block + 12);

    extract_color(colors, color0, color1, 1, 0);

    for (y = 0; y < 4; y++) {
        const uint16_t alpha_code = AV_RL16(block + 2 * y);
        uint8_t alpha_values[4];

        alpha_values[0] = ((alpha_code >>  0) & 0x0F) * 17;
        alpha_values[1] = ((alpha_code >>  4) & 0x0F) * 17;
        alpha_values[2] = ((alpha_code >>  8) & 0x0F) * 17;
        alpha_values[3] = ((alpha_code >> 12) & 0x0F) * 17;

        for (x = 0; x < 4; x++) {
            uint8_t alpha = alpha_values[x];
            uint32_t pixel = colors[code & 3] | ((unsigned)alpha << 24);
            code >>= 2;

            AV_WL32(dst + x * 4, pixel);
        }
        dst += stride;
    }
}

/** Convert a premultiplied alpha pixel to a straight alpha pixel. */
static av_always_inline void premult2straight(uint8_t *src)
{
    int r = src[0];
    int g = src[1];
    int b = src[2];
    int a = src[3]; /* unchanged */

    src[0] = (uint8_t) r * a / 255;
    src[1] = (uint8_t) g * a / 255;
    src[2] = (uint8_t) b * a / 255;
}

/**
 * Decompress one block of a DXT2 texture and store the resulting
 * RGBA pixels in 'dst'.
 *
 * @param dst    output buffer.
 * @param stride scanline in bytes.
 * @param block  block to decompress.
 * @return how much texture data has been consumed.
 */
static int dxt2_block(uint8_t *dst, ptrdiff_t stride, const uint8_t *block)
{
    int x, y;

    dxt3_block_internal(dst, stride, block);

    /* This format is DXT3, but returns premultiplied alpha. It needs to be
     * converted because it's what lavc outputs (and swscale expects). */
    for (y = 0; y < 4; y++)
        for (x = 0; x < 4; x++)
            premult2straight(dst + x * 4 + y * stride);

    return 16;
}

/**
 * Decompress one block of a DXT3 texture and store the resulting
 * RGBA pixels in 'dst'.
 *
 * @param dst    output buffer.
 * @param stride scanline in bytes.
 * @param block  block to decompress.
 * @return how much texture data has been consumed.
 */
static int dxt3_block(uint8_t *dst, ptrdiff_t stride, const uint8_t *block)
{
    dxt3_block_internal(dst, stride, block);

    return 16;
}

/**
 * Decompress a BC 16x3 index block stored as
 *   h g f e
 *   d c b a
 *   p o n m
 *   l k j i
 *
 * Bits packed as
 *  | h | g | f | e | d | c | b | a | // Entry
 *  |765 432 107 654 321 076 543 210| // Bit
 *  |0000000000111111111112222222222| // Byte
 *
 * into 16 8-bit indices.
 */
static void decompress_indices(uint8_t *dst, const uint8_t *src)
{
    int block, i;

    for (block = 0; block < 2; block++) {
        int tmp = AV_RL24(src);

        /* Unpack 8x3 bit from last 3 byte block */
        for (i = 0; i < 8; i++)
            dst[i] = (tmp >> (i * 3)) & 0x7;

        src += 3;
        dst += 8;
    }
}

static inline void dxt5_block_internal(uint8_t *dst, ptrdiff_t stride,
                                       const uint8_t *block)
{
    int x, y;
    uint32_t colors[4];
    uint8_t alpha_indices[16];
    uint16_t color0 = AV_RL16(block + 8);
    uint16_t color1 = AV_RL16(block + 10);
    uint32_t code   = AV_RL32(block + 12);
    uint8_t alpha0  = *(block);
    uint8_t alpha1  = *(block + 1);

    decompress_indices(alpha_indices, block + 2);

    extract_color(colors, color0, color1, 1, 0);

    for (y = 0; y < 4; y++) {
        for (x = 0; x < 4; x++) {
            int alpha_code = alpha_indices[x + y * 4];
            uint32_t pixel;
            uint8_t alpha;

            if (alpha_code == 0) {
                alpha = alpha0;
            } else if (alpha_code == 1) {
                alpha = alpha1;
            } else {
                if (alpha0 > alpha1) {
                    alpha = (uint8_t) (((8 - alpha_code) * alpha0 +
                                        (alpha_code - 1) * alpha1) / 7);
                } else {
                    if (alpha_code == 6) {
                        alpha = 0;
                    } else if (alpha_code == 7) {
                        alpha = 255;
                    } else {
                        alpha = (uint8_t) (((6 - alpha_code) * alpha0 +
                                            (alpha_code - 1) * alpha1) / 5);
                    }
                }
            }
            pixel = colors[code & 3] | ((unsigned)alpha << 24);
            code >>= 2;
            AV_WL32(dst + x * 4, pixel);
        }
        dst += stride;
    }
}

/**
 * Decompress one block of a DXT4 texture and store the resulting
 * RGBA pixels in 'dst'.
 *
 * @param dst    output buffer.
 * @param stride scanline in bytes.
 * @param block  block to decompress.
 * @return how much texture data has been consumed.
 */
static int dxt4_block(uint8_t *dst, ptrdiff_t stride, const uint8_t *block)
{
    int x, y;

    dxt5_block_internal(dst, stride, block);

    /* This format is DXT5, but returns premultiplied alpha. It needs to be
     * converted because it's what lavc outputs (and swscale expects). */
    for (y = 0; y < 4; y++)
        for (x = 0; x < 4; x++)
            premult2straight(dst + x * 4 + y * stride);

    return 16;
}

/**
 * Decompress one block of a DXT5 texture and store the resulting
 * RGBA pixels in 'dst'.
 *
 * @param dst    output buffer.
 * @param stride scanline in bytes.
 * @param block  block to decompress.
 * @return how much texture data has been consumed.
 */
static int dxt5_block(uint8_t *dst, ptrdiff_t stride, const uint8_t *block)
{
    dxt5_block_internal(dst, stride, block);

    return 16;
}

/**
 * Convert a YCoCg buffer to RGBA.
 *
 * @param src    input buffer.
 * @param scaled variant with scaled chroma components and opaque alpha.
 */
static av_always_inline void ycocg2rgba(uint8_t *src, int scaled)
{
    int r = src[0];
    int g = src[1];
    int b = src[2];
    int a = src[3];

    int s  = scaled ? (b >> 3) + 1 : 1;
    int y  = a;
    int co = (r - 128) / s;
    int cg = (g - 128) / s;

    src[0] = av_clip_uint8(y + co - cg);
    src[1] = av_clip_uint8(y + cg);
    src[2] = av_clip_uint8(y - co - cg);
    src[3] = scaled ? 255 : b;
}

/**
 * Decompress one block of a DXT5 texture with classic YCoCg and store
 * the resulting RGBA pixels in 'dst'. Alpha component is fully opaque.
 *
 * @param dst    output buffer.
 * @param stride scanline in bytes.
 * @param block  block to decompress.
 * @return how much texture data has been consumed.
 */
static int dxt5y_block(uint8_t *dst, ptrdiff_t stride, const uint8_t *block)
{
    int x, y;

    /* This format is basically DXT5, with luma stored in alpha.
     * Run a normal decompress and then reorder the components. */
    dxt5_block_internal(dst, stride, block);

    for (y = 0; y < 4; y++)
        for (x = 0; x < 4; x++)
            ycocg2rgba(dst + x * 4 + y * stride, 0);

    return 16;
}

/**
 * Decompress one block of a DXT5 texture with scaled YCoCg and store
 * the resulting RGBA pixels in 'dst'. Alpha component is fully opaque.
 *
 * @param dst    output buffer.
 * @param stride scanline in bytes.
 * @param block  block to decompress.
 * @return how much texture data has been consumed.
 */
static int dxt5ys_block(uint8_t *dst, ptrdiff_t stride, const uint8_t *block)
{
    int x, y;

    /* This format is basically DXT5, with luma stored in alpha.
     * Run a normal decompress and then reorder the components. */
    dxt5_block_internal(dst, stride, block);

    for (y = 0; y < 4; y++)
        for (x = 0; x < 4; x++)
            ycocg2rgba(dst + x * 4 + y * stride, 1);

    return 16;
}

static inline void rgtc_block_internal(uint8_t *dst, ptrdiff_t stride,
                                       const uint8_t *block,
                                       const int *color_tab, int mono, int offset, int pix_size)
{
    uint8_t indices[16];
    int x, y;

    decompress_indices(indices, block + 2);

    /* Only one or two channels are stored at most, since it only used to
     * compress specular (black and white) or normal (red and green) maps.
     * Although the standard says to zero out unused components, many
     * implementations fill all of them with the same value. */
    for (y = 0; y < 4; y++) {
        for (x = 0; x < 4; x++) {
            int i = indices[x + y * 4];
            /* Interval expansion from [-1 1] or [0 1] to [0 255]. */
            int c = color_tab[i];

            if (mono){
                dst [x * pix_size + y * stride + offset] = (uint8_t)c;
            }
            else{
                uint32_t pixel = RGBA(c, c, c, 255U);
                AV_WL32(dst + x * pix_size + y * stride, pixel);
            }
        }
    }
}

static inline void rgtc1_block_internal(uint8_t *dst, ptrdiff_t stride,
                                        const uint8_t *block, int sign, int mono, int offset, int pix_size)
{
    int color_table[8];
    int r0, r1;

    if (sign) {
        /* signed data is in [-128 127] so just offset it to unsigned
         * and it can be treated exactly the same */
        r0 = ((int8_t) block[0]) + 128;
        r1 = ((int8_t) block[1]) + 128;
    } else {
        r0 = block[0];
        r1 = block[1];
    }

    color_table[0] = r0;
    color_table[1] = r1;

    if (r0 > r1) {
        /* 6 interpolated color values */
        color_table[2] = (6 * r0 + 1 * r1) / 7; // bit code 010
        color_table[3] = (5 * r0 + 2 * r1) / 7; // bit code 011
        color_table[4] = (4 * r0 + 3 * r1) / 7; // bit code 100
        color_table[5] = (3 * r0 + 4 * r1) / 7; // bit code 101
        color_table[6] = (2 * r0 + 5 * r1) / 7; // bit code 110
        color_table[7] = (1 * r0 + 6 * r1) / 7; // bit code 111
    } else {
        /* 4 interpolated color values */
        color_table[2] = (4 * r0 + 1 * r1) / 5; // bit code 010
        color_table[3] = (3 * r0 + 2 * r1) / 5; // bit code 011
        color_table[4] = (2 * r0 + 3 * r1) / 5; // bit code 100
        color_table[5] = (1 * r0 + 4 * r1) / 5; // bit code 101
        color_table[6] = 0;    /* min range */  // bit code 110
        color_table[7] = 255;  /* max range */  // bit code 111
    }

    rgtc_block_internal(dst, stride, block, color_table, mono, offset, pix_size);
}

/**
 * Decompress one block of a RGRC1 texture with signed components
 * and store the resulting RGBA pixels in 'dst'.
 *
 * @param dst    output buffer.
 * @param stride scanline in bytes.
 * @param block  block to decompress.
 * @return how much texture data has been consumed.
 */
static int rgtc1s_block(uint8_t *dst, ptrdiff_t stride, const uint8_t *block)
{
    rgtc1_block_internal(dst, stride, block, 1, 0, 0, 4);

    return 8;
}

/**
 * Decompress one block of a RGRC1 texture with unsigned components
 * and store the resulting RGBA pixels in 'dst'.
 *
 * @param dst    output buffer.
 * @param stride scanline in bytes.
 * @param block  block to decompress.
 * @return how much texture data has been consumed.
 */
static int rgtc1u_block(uint8_t *dst, ptrdiff_t stride, const uint8_t *block)
{
    rgtc1_block_internal(dst, stride, block, 0, 0, 0, 4);

    return 8;
}

/**
 * Decompress one block of a RGTC1 texture with unsigned components
 * and overwrite the alpha component in 'dst' (RGBA data).
 *
 * @param dst    output buffer.
 * @param stride scanline in bytes.
 * @param block  block to decompress.
 * @return how much texture data has been consumed.
 */
static int rgtc1u_alpha_block(uint8_t *dst, ptrdiff_t stride, const uint8_t *block)
{
    rgtc1_block_internal(dst, stride, block, 0, 1, 3, 4);

    return 8;
}

/**
 * Decompress one block of a RGTC1 texture with unsigned components
 * to Gray 8.
 *
 * @param dst    output buffer.
 * @param stride scanline in bytes.
 * @param block  block to decompress.
 * @return how much texture data has been consumed.
 */
static int rgtc1u_gray_block(uint8_t *dst, ptrdiff_t stride, const uint8_t *block)
{
    rgtc1_block_internal(dst, stride, block, 0, 1, 0, 1);

    return 8;
}

static inline void rgtc2_block_internal(uint8_t *dst, ptrdiff_t stride,
                                        const uint8_t *block, int sign)
{
    /* 4x4 block containing 4 component pixels. */
    uint8_t c0[4 * 4 * 4];
    uint8_t c1[4 * 4 * 4];
    int x, y;

    /* Decompress the two channels separately and interleave them afterwards. */
    rgtc1_block_internal(c0, 16, block, sign, 0, 0, 4);
    rgtc1_block_internal(c1, 16, block + 8, sign, 0, 0, 4);

    /* B is rebuilt exactly like a normal map. */
    for (y = 0; y < 4; y++) {
        for (x = 0; x < 4; x++) {
            uint8_t *p = dst + x * 4 + y * stride;
            int r = c0[x * 4 + y * 16];
            int g = c1[x * 4 + y * 16];
            int b = 127;

            int d = (255 * 255 - r * r - g * g) / 2;
            if (d > 0)
                b = lrint(sqrtf(d));

            p[0] = r;
            p[1] = g;
            p[2] = b;
            p[3] = 255;
        }
    }
}

/**
 * Decompress one block of a RGRC2 texture with signed components
 * and store the resulting RGBA pixels in 'dst'. Alpha is fully opaque.
 *
 * @param dst    output buffer.
 * @param stride scanline in bytes.
 * @param block  block to decompress.
 * @return how much texture data has been consumed.
 */
static int rgtc2s_block(uint8_t *dst, ptrdiff_t stride, const uint8_t *block)
{
    rgtc2_block_internal(dst, stride, block, 1);

    return 16;
}

/**
 * Decompress one block of a RGRC2 texture with unsigned components
 * and store the resulting RGBA pixels in 'dst'. Alpha is fully opaque.
 *
 * @param dst    output buffer.
 * @param stride scanline in bytes.
 * @param block  block to decompress.
 * @return how much texture data has been consumed.
 */
static int rgtc2u_block(uint8_t *dst, ptrdiff_t stride, const uint8_t *block)
{
    rgtc2_block_internal(dst, stride, block, 0);

    return 16;
}

/**
 * Decompress one block of a 3Dc texture with unsigned components
 * and store the resulting RGBA pixels in 'dst'. Alpha is fully opaque.
 *
 * @param dst    output buffer.
 * @param stride scanline in bytes.
 * @param block  block to decompress.
 * @return how much texture data has been consumed.
 */
static int dxn3dc_block(uint8_t *dst, ptrdiff_t stride, const uint8_t *block)
{
    int x, y;
    rgtc2_block_internal(dst, stride, block, 0);

    /* This is the 3Dc variant of RGTC2, with swapped R and G. */
    for (y = 0; y < 4; y++) {
        for (x = 0; x < 4; x++) {
            uint8_t *p = dst + x * 4 + y * stride;
            FFSWAP(uint8_t, p[0], p[1]);
        }
    }

    return 16;
}

av_cold void ff_texturedsp_init(TextureDSPContext *c)
{
    c->dxt1_block         = dxt1_block;
    c->dxt1a_block        = dxt1a_block;
    c->dxt2_block         = dxt2_block;
    c->dxt3_block         = dxt3_block;
    c->dxt4_block         = dxt4_block;
    c->dxt5_block         = dxt5_block;
    c->dxt5y_block        = dxt5y_block;
    c->dxt5ys_block       = dxt5ys_block;
    c->rgtc1s_block       = rgtc1s_block;
    c->rgtc1u_block       = rgtc1u_block;
    c->rgtc1u_gray_block  = rgtc1u_gray_block;
    c->rgtc1u_alpha_block = rgtc1u_alpha_block;
    c->rgtc2s_block       = rgtc2s_block;
    c->rgtc2u_block       = rgtc2u_block;
    c->dxn3dc_block       = dxn3dc_block;
}


Generated by: GCOVR (Version 4.2)

Line	Branch	Exec	Source
1			/*
2			* Texture block decompression
3			* Copyright (C) 2009 Benjamin Dobell, Glass Echidna
4			* Copyright (C) 2012 Matthäus G. "Anteru" Chajdas (http://anteru.net)
5			* Copyright (C) 2015 Vittorio Giovara <vittorio.giovara@gmail.com>
6			*
7			* Permission is hereby granted, free of charge, to any person obtaining a
8			* copy of this software and associated documentation files (the "Software"),
9			* to deal in the Software without restriction, including without limitation
10			* the rights to use, copy, modify, merge, publish, distribute, sublicense,
11			* and/or sell copies of the Software, and to permit persons to whom the
12			* Software is furnished to do so, subject to the following conditions:
13			* The above copyright notice and this permission notice shall be included
14			* in all copies or substantial portions of the Software.
15			*
16			* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17			* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18			* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
19			* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20			* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21			* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
22			* IN THE SOFTWARE.
23			*/
24
25			#include <stddef.h>
26			#include <stdint.h>
27
28			#include "libavutil/attributes.h"
29			#include "libavutil/common.h"
30			#include "libavutil/intreadwrite.h"
31			#include "libavutil/libm.h"
32
33			#include "texturedsp.h"
34
35			#define RGBA(r, g, b, a) (((uint8_t)(r) << 0) \| \
36			((uint8_t)(g) << 8) \| \
37			((uint8_t)(b) << 16) \| \
38			((unsigned)(uint8_t)(a) << 24))
39
40		1131646	static av_always_inline void extract_color(uint32_t colors[4],
41			uint16_t color0,
42			uint16_t color1,
43			int dxtn, int alpha)
44			{
45			int tmp;
46			uint8_t r0, g0, b0, r1, g1, b1;
47	✓✓	1131646	uint8_t a = dxtn ? 0 : 255;
48
49		1131646	tmp = (color0 >> 11) * 255 + 16;
50		1131646	r0 = (uint8_t) ((tmp / 32 + tmp) / 32);
51		1131646	tmp = ((color0 & 0x07E0) >> 5) * 255 + 32;
52		1131646	g0 = (uint8_t) ((tmp / 64 + tmp) / 64);
53		1131646	tmp = (color0 & 0x001F) * 255 + 16;
54		1131646	b0 = (uint8_t) ((tmp / 32 + tmp) / 32);
55
56		1131646	tmp = (color1 >> 11) * 255 + 16;
57		1131646	r1 = (uint8_t) ((tmp / 32 + tmp) / 32);
58		1131646	tmp = ((color1 & 0x07E0) >> 5) * 255 + 32;
59		1131646	g1 = (uint8_t) ((tmp / 64 + tmp) / 64);
60		1131646	tmp = (color1 & 0x001F) * 255 + 16;
61		1131646	b1 = (uint8_t) ((tmp / 32 + tmp) / 32);
62
63	✓✓✓✓	1131646	if (dxtn \|\| color0 > color1) {
64		984784	colors[0] = RGBA(r0, g0, b0, a);
65		984784	colors[1] = RGBA(r1, g1, b1, a);
66		984784	colors[2] = RGBA((2 * r0 + r1) / 3,
67			(2 * g0 + g1) / 3,
68			(2 * b0 + b1) / 3,
69			a);
70		984784	colors[3] = RGBA((2 * r1 + r0) / 3,
71			(2 * g1 + g0) / 3,
72			(2 * b1 + b0) / 3,
73			a);
74			} else {
75		146862	colors[0] = RGBA(r0, g0, b0, a);
76		146862	colors[1] = RGBA(r1, g1, b1, a);
77		146862	colors[2] = RGBA((r0 + r1) / 2,
78			(g0 + g1) / 2,
79			(b0 + b1) / 2,
80			a);
81		146862	colors[3] = RGBA(0, 0, 0, alpha);
82			}
83		1131646	}
84
85		547584	static inline void dxt1_block_internal(uint8_t *dst, ptrdiff_t stride,
86			const uint8_t *block, uint8_t alpha)
87			{
88			int x, y;
89			uint32_t colors[4];
90		547584	uint16_t color0 = AV_RL16(block + 0);
91		547584	uint16_t color1 = AV_RL16(block + 2);
92		547584	uint32_t code = AV_RL32(block + 4);
93
94		547584	extract_color(colors, color0, color1, 0, alpha);
95
96	✓✓	2737920	for (y = 0; y < 4; y++) {
97	✓✓	10951680	for (x = 0; x < 4; x++) {
98		8761344	uint32_t pixel = colors[code & 3];
99		8761344	code >>= 2;
100		8761344	AV_WL32(dst + x * 4, pixel);
101			}
102		2190336	dst += stride;
103			}
104		547584	}
105
106			/**
107			* Decompress one block of a DXT1 texture and store the resulting
108			* RGBA pixels in 'dst'. Alpha component is fully opaque.
109			*
110			* @param dst output buffer.
111			* @param stride scanline in bytes.
112			* @param block block to decompress.
113			* @return how much texture data has been consumed.
114			*/
115		544512	static int dxt1_block(uint8_t dst, ptrdiff_t stride, const uint8_t block)
116			{
117		544512	dxt1_block_internal(dst, stride, block, 255);
118
119		544512	return 8;
120			}
121
122			/**
123			* Decompress one block of a DXT1 with 1-bit alpha texture and store
124			* the resulting RGBA pixels in 'dst'. Alpha is either fully opaque or
125			* fully transparent.
126			*
127			* @param dst output buffer.
128			* @param stride scanline in bytes.
129			* @param block block to decompress.
130			* @return how much texture data has been consumed.
131			*/
132		3072	static int dxt1a_block(uint8_t dst, ptrdiff_t stride, const uint8_t block)
133			{
134		3072	dxt1_block_internal(dst, stride, block, 0);
135
136		3072	return 8;
137			}
138
139		13758	static inline void dxt3_block_internal(uint8_t *dst, ptrdiff_t stride,
140			const uint8_t *block)
141			{
142			int x, y;
143			uint32_t colors[4];
144		13758	uint16_t color0 = AV_RL16(block + 8);
145		13758	uint16_t color1 = AV_RL16(block + 10);
146		13758	uint32_t code = AV_RL32(block + 12);
147
148		13758	extract_color(colors, color0, color1, 1, 0);
149
150	✓✓	68790	for (y = 0; y < 4; y++) {
151		55032	const uint16_t alpha_code = AV_RL16(block + 2 * y);
152			uint8_t alpha_values[4];
153
154		55032	alpha_values[0] = ((alpha_code >> 0) & 0x0F) * 17;
155		55032	alpha_values[1] = ((alpha_code >> 4) & 0x0F) * 17;
156		55032	alpha_values[2] = ((alpha_code >> 8) & 0x0F) * 17;
157		55032	alpha_values[3] = ((alpha_code >> 12) & 0x0F) * 17;
158
159	✓✓	275160	for (x = 0; x < 4; x++) {
160		220128	uint8_t alpha = alpha_values[x];
161		220128	uint32_t pixel = colors[code & 3] \| ((unsigned)alpha << 24);
162		220128	code >>= 2;
163
164		220128	AV_WL32(dst + x * 4, pixel);
165			}
166		55032	dst += stride;
167			}
168		13758	}
169
170			/** Convert a premultiplied alpha pixel to a straight alpha pixel. */
171		16384	static av_always_inline void premult2straight(uint8_t *src)
172			{
173		16384	int r = src[0];
174		16384	int g = src[1];
175		16384	int b = src[2];
176		16384	int a = src[3]; /* unchanged */
177
178		16384	src[0] = (uint8_t) r * a / 255;
179		16384	src[1] = (uint8_t) g * a / 255;
180		16384	src[2] = (uint8_t) b * a / 255;
181		16384	}
182
183			/**
184			* Decompress one block of a DXT2 texture and store the resulting
185			* RGBA pixels in 'dst'.
186			*
187			* @param dst output buffer.
188			* @param stride scanline in bytes.
189			* @param block block to decompress.
190			* @return how much texture data has been consumed.
191			*/
192		512	static int dxt2_block(uint8_t dst, ptrdiff_t stride, const uint8_t block)
193			{
194			int x, y;
195
196		512	dxt3_block_internal(dst, stride, block);
197
198			/* This format is DXT3, but returns premultiplied alpha. It needs to be
199			* converted because it's what lavc outputs (and swscale expects). */
200	✓✓	2560	for (y = 0; y < 4; y++)
201	✓✓	10240	for (x = 0; x < 4; x++)
202		8192	premult2straight(dst + x * 4 + y * stride);
203
204		512	return 16;
205			}
206
207			/**
208			* Decompress one block of a DXT3 texture and store the resulting
209			* RGBA pixels in 'dst'.
210			*
211			* @param dst output buffer.
212			* @param stride scanline in bytes.
213			* @param block block to decompress.
214			* @return how much texture data has been consumed.
215			*/
216		13246	static int dxt3_block(uint8_t dst, ptrdiff_t stride, const uint8_t block)
217			{
218		13246	dxt3_block_internal(dst, stride, block);
219
220		13246	return 16;
221			}
222
223			/**
224			* Decompress a BC 16x3 index block stored as
225			* h g f e
226			* d c b a
227			* p o n m
228			* l k j i
229			*
230			* Bits packed as
231			* \| h \| g \| f \| e \| d \| c \| b \| a \| // Entry
232			* \|765 432 107 654 321 076 543 210\| // Bit
233			* \|0000000000111111111112222222222\| // Byte
234			*
235			* into 16 8-bit indices.
236			*/
237		578816	static void decompress_indices(uint8_t dst, const uint8_t src)
238			{
239			int block, i;
240
241	✓✓	1736448	for (block = 0; block < 2; block++) {
242		1157632	int tmp = AV_RL24(src);
243
244			/* Unpack 8x3 bit from last 3 byte block */
245	✓✓	10418688	for (i = 0; i < 8; i++)
246		9261056	dst[i] = (tmp >> (i * 3)) & 0x7;
247
248		1157632	src += 3;
249		1157632	dst += 8;
250			}
251		578816	}
252
253		570304	static inline void dxt5_block_internal(uint8_t *dst, ptrdiff_t stride,
254			const uint8_t *block)
255			{
256			int x, y;
257			uint32_t colors[4];
258			uint8_t alpha_indices[16];
259		570304	uint16_t color0 = AV_RL16(block + 8);
260		570304	uint16_t color1 = AV_RL16(block + 10);
261		570304	uint32_t code = AV_RL32(block + 12);
262		570304	uint8_t alpha0 = *(block);
263		570304	uint8_t alpha1 = *(block + 1);
264
265		570304	decompress_indices(alpha_indices, block + 2);
266
267		570304	extract_color(colors, color0, color1, 1, 0);
268
269	✓✓	2851520	for (y = 0; y < 4; y++) {
270	✓✓	11406080	for (x = 0; x < 4; x++) {
271		9124864	int alpha_code = alpha_indices[x + y * 4];
272			uint32_t pixel;
273			uint8_t alpha;
274
275	✓✓	9124864	if (alpha_code == 0) {
276		4574453	alpha = alpha0;
277	✓✓	4550411	} else if (alpha_code == 1) {
278		4239259	alpha = alpha1;
279			} else {
280	✓✓	311152	if (alpha0 > alpha1) {
281		279934	alpha = (uint8_t) (((8 - alpha_code) * alpha0 +
282		279934	(alpha_code - 1) * alpha1) / 7);
283			} else {
284	✓✓	31218	if (alpha_code == 6) {
285		6494	alpha = 0;
286	✓✓	24724	} else if (alpha_code == 7) {
287		18150	alpha = 255;
288			} else {
289		6574	alpha = (uint8_t) (((6 - alpha_code) * alpha0 +
290		6574	(alpha_code - 1) * alpha1) / 5);
291			}
292			}
293			}
294		9124864	pixel = colors[code & 3] \| ((unsigned)alpha << 24);
295		9124864	code >>= 2;
296		9124864	AV_WL32(dst + x * 4, pixel);
297			}
298		2281216	dst += stride;
299			}
300		570304	}
301
302			/**
303			* Decompress one block of a DXT4 texture and store the resulting
304			* RGBA pixels in 'dst'.
305			*
306			* @param dst output buffer.
307			* @param stride scanline in bytes.
308			* @param block block to decompress.
309			* @return how much texture data has been consumed.
310			*/
311		512	static int dxt4_block(uint8_t dst, ptrdiff_t stride, const uint8_t block)
312			{
313			int x, y;
314
315		512	dxt5_block_internal(dst, stride, block);
316
317			/* This format is DXT5, but returns premultiplied alpha. It needs to be
318			* converted because it's what lavc outputs (and swscale expects). */
319	✓✓	2560	for (y = 0; y < 4; y++)
320	✓✓	10240	for (x = 0; x < 4; x++)
321		8192	premult2straight(dst + x * 4 + y * stride);
322
323		512	return 16;
324			}
325
326			/**
327			* Decompress one block of a DXT5 texture and store the resulting
328			* RGBA pixels in 'dst'.
329			*
330			* @param dst output buffer.
331			* @param stride scanline in bytes.
332			* @param block block to decompress.
333			* @return how much texture data has been consumed.
334			*/
335		547584	static int dxt5_block(uint8_t dst, ptrdiff_t stride, const uint8_t block)
336			{
337		547584	dxt5_block_internal(dst, stride, block);
338
339		547584	return 16;
340			}
341
342			/**
343			* Convert a YCoCg buffer to RGBA.
344			*
345			* @param src input buffer.
346			* @param scaled variant with scaled chroma components and opaque alpha.
347			*/
348		355328	static av_always_inline void ycocg2rgba(uint8_t *src, int scaled)
349			{
350		355328	int r = src[0];
351		355328	int g = src[1];
352		355328	int b = src[2];
353		355328	int a = src[3];
354
355	✓✓	355328	int s = scaled ? (b >> 3) + 1 : 1;
356		355328	int y = a;
357		355328	int co = (r - 128) / s;
358		355328	int cg = (g - 128) / s;
359
360		355328	src[0] = av_clip_uint8(y + co - cg);
361		355328	src[1] = av_clip_uint8(y + cg);
362		355328	src[2] = av_clip_uint8(y - co - cg);
363	✓✓	355328	src[3] = scaled ? 255 : b;
364		355328	}
365
366			/**
367			* Decompress one block of a DXT5 texture with classic YCoCg and store
368			* the resulting RGBA pixels in 'dst'. Alpha component is fully opaque.
369			*
370			* @param dst output buffer.
371			* @param stride scanline in bytes.
372			* @param block block to decompress.
373			* @return how much texture data has been consumed.
374			*/
375		512	static int dxt5y_block(uint8_t dst, ptrdiff_t stride, const uint8_t block)
376			{
377			int x, y;
378
379			/* This format is basically DXT5, with luma stored in alpha.
380			* Run a normal decompress and then reorder the components. */
381		512	dxt5_block_internal(dst, stride, block);
382
383	✓✓	2560	for (y = 0; y < 4; y++)
384	✓✓	10240	for (x = 0; x < 4; x++)
385		8192	ycocg2rgba(dst + x * 4 + y * stride, 0);
386
387		512	return 16;
388			}
389
390			/**
391			* Decompress one block of a DXT5 texture with scaled YCoCg and store
392			* the resulting RGBA pixels in 'dst'. Alpha component is fully opaque.
393			*
394			* @param dst output buffer.
395			* @param stride scanline in bytes.
396			* @param block block to decompress.
397			* @return how much texture data has been consumed.
398			*/
399		21696	static int dxt5ys_block(uint8_t dst, ptrdiff_t stride, const uint8_t block)
400			{
401			int x, y;
402
403			/* This format is basically DXT5, with luma stored in alpha.
404			* Run a normal decompress and then reorder the components. */
405		21696	dxt5_block_internal(dst, stride, block);
406
407	✓✓	108480	for (y = 0; y < 4; y++)
408	✓✓	433920	for (x = 0; x < 4; x++)
409		347136	ycocg2rgba(dst + x * 4 + y * stride, 1);
410
411		21696	return 16;
412			}
413
414		8512	static inline void rgtc_block_internal(uint8_t *dst, ptrdiff_t stride,
415			const uint8_t *block,
416			const int *color_tab, int mono, int offset, int pix_size)
417			{
418			uint8_t indices[16];
419			int x, y;
420
421		8512	decompress_indices(indices, block + 2);
422
423			/* Only one or two channels are stored at most, since it only used to
424			* compress specular (black and white) or normal (red and green) maps.
425			* Although the standard says to zero out unused components, many
426			* implementations fill all of them with the same value. */
427	✓✓	42560	for (y = 0; y < 4; y++) {
428	✓✓	170240	for (x = 0; x < 4; x++) {
429		136192	int i = indices[x + y * 4];
430			/* Interval expansion from [-1 1] or [0 1] to [0 255]. */
431		136192	int c = color_tab[i];
432
433	✓✓	136192	if (mono){
434		46080	dst [x * pix_size + y * stride + offset] = (uint8_t)c;
435			}
436			else{
437		90112	uint32_t pixel = RGBA(c, c, c, 255U);
438		90112	AV_WL32(dst + x * pix_size + y * stride, pixel);
439			}
440			}
441			}
442		8512	}
443
444		8512	static inline void rgtc1_block_internal(uint8_t *dst, ptrdiff_t stride,
445			const uint8_t *block, int sign, int mono, int offset, int pix_size)
446			{
447			int color_table[8];
448			int r0, r1;
449
450	✓✓	8512	if (sign) {
451			/* signed data is in [-128 127] so just offset it to unsigned
452			* and it can be treated exactly the same */
453		1536	r0 = ((int8_t) block[0]) + 128;
454		1536	r1 = ((int8_t) block[1]) + 128;
455			} else {
456		6976	r0 = block[0];
457		6976	r1 = block[1];
458			}
459
460		8512	color_table[0] = r0;
461		8512	color_table[1] = r1;
462
463	✓✓	8512	if (r0 > r1) {
464			/* 6 interpolated color values */
465		4848	color_table[2] = (6 * r0 + 1 * r1) / 7; // bit code 010
466		4848	color_table[3] = (5 * r0 + 2 * r1) / 7; // bit code 011
467		4848	color_table[4] = (4 * r0 + 3 * r1) / 7; // bit code 100
468		4848	color_table[5] = (3 * r0 + 4 * r1) / 7; // bit code 101
469		4848	color_table[6] = (2 * r0 + 5 * r1) / 7; // bit code 110
470		4848	color_table[7] = (1 * r0 + 6 * r1) / 7; // bit code 111
471			} else {
472			/* 4 interpolated color values */
473		3664	color_table[2] = (4 * r0 + 1 * r1) / 5; // bit code 010
474		3664	color_table[3] = (3 * r0 + 2 * r1) / 5; // bit code 011
475		3664	color_table[4] = (2 * r0 + 3 * r1) / 5; // bit code 100
476		3664	color_table[5] = (1 * r0 + 4 * r1) / 5; // bit code 101
477		3664	color_table[6] = 0; /* min range */ // bit code 110
478		3664	color_table[7] = 255; /* max range */ // bit code 111
479			}
480
481		8512	rgtc_block_internal(dst, stride, block, color_table, mono, offset, pix_size);
482		8512	}
483
484			/**
485			* Decompress one block of a RGRC1 texture with signed components
486			* and store the resulting RGBA pixels in 'dst'.
487			*
488			* @param dst output buffer.
489			* @param stride scanline in bytes.
490			* @param block block to decompress.
491			* @return how much texture data has been consumed.
492			*/
493		512	static int rgtc1s_block(uint8_t dst, ptrdiff_t stride, const uint8_t block)
494			{
495		512	rgtc1_block_internal(dst, stride, block, 1, 0, 0, 4);
496
497		512	return 8;
498			}
499
500			/**
501			* Decompress one block of a RGRC1 texture with unsigned components
502			* and store the resulting RGBA pixels in 'dst'.
503			*
504			* @param dst output buffer.
505			* @param stride scanline in bytes.
506			* @param block block to decompress.
507			* @return how much texture data has been consumed.
508			*/
509		1024	static int rgtc1u_block(uint8_t dst, ptrdiff_t stride, const uint8_t block)
510			{
511		1024	rgtc1_block_internal(dst, stride, block, 0, 0, 0, 4);
512
513		1024	return 8;
514			}
515
516			/**
517			* Decompress one block of a RGTC1 texture with unsigned components
518			* and overwrite the alpha component in 'dst' (RGBA data).
519			*
520			* @param dst output buffer.
521			* @param stride scanline in bytes.
522			* @param block block to decompress.
523			* @return how much texture data has been consumed.
524			*/
525		1728	static int rgtc1u_alpha_block(uint8_t dst, ptrdiff_t stride, const uint8_t block)
526			{
527		1728	rgtc1_block_internal(dst, stride, block, 0, 1, 3, 4);
528
529		1728	return 8;
530			}
531
532			/**
533			* Decompress one block of a RGTC1 texture with unsigned components
534			* to Gray 8.
535			*
536			* @param dst output buffer.
537			* @param stride scanline in bytes.
538			* @param block block to decompress.
539			* @return how much texture data has been consumed.
540			*/
541		1152	static int rgtc1u_gray_block(uint8_t dst, ptrdiff_t stride, const uint8_t block)
542			{
543		1152	rgtc1_block_internal(dst, stride, block, 0, 1, 0, 1);
544
545		1152	return 8;
546			}
547
548		2048	static inline void rgtc2_block_internal(uint8_t *dst, ptrdiff_t stride,
549			const uint8_t *block, int sign)
550			{
551			/* 4x4 block containing 4 component pixels. */
552			uint8_t c0[4 * 4 * 4];
553			uint8_t c1[4 * 4 * 4];
554			int x, y;
555
556			/* Decompress the two channels separately and interleave them afterwards. */
557		2048	rgtc1_block_internal(c0, 16, block, sign, 0, 0, 4);
558		2048	rgtc1_block_internal(c1, 16, block + 8, sign, 0, 0, 4);
559
560			/* B is rebuilt exactly like a normal map. */
561	✓✓	10240	for (y = 0; y < 4; y++) {
562	✓✓	40960	for (x = 0; x < 4; x++) {
563		32768	uint8_t p = dst + x 4 + y * stride;
564		32768	int r = c0[x * 4 + y * 16];
565		32768	int g = c1[x * 4 + y * 16];
566		32768	int b = 127;
567
568		32768	int d = (255 * 255 - r * r - g * g) / 2;
569	✓✓	32768	if (d > 0)
570		26534	b = lrint(sqrtf(d));
571
572		32768	p[0] = r;
573		32768	p[1] = g;
574		32768	p[2] = b;
575		32768	p[3] = 255;
576			}
577			}
578		2048	}
579
580			/**
581			* Decompress one block of a RGRC2 texture with signed components
582			* and store the resulting RGBA pixels in 'dst'. Alpha is fully opaque.
583			*
584			* @param dst output buffer.
585			* @param stride scanline in bytes.
586			* @param block block to decompress.
587			* @return how much texture data has been consumed.
588			*/
589		512	static int rgtc2s_block(uint8_t dst, ptrdiff_t stride, const uint8_t block)
590			{
591		512	rgtc2_block_internal(dst, stride, block, 1);
592
593		512	return 16;
594			}
595
596			/**
597			* Decompress one block of a RGRC2 texture with unsigned components
598			* and store the resulting RGBA pixels in 'dst'. Alpha is fully opaque.
599			*
600			* @param dst output buffer.
601			* @param stride scanline in bytes.
602			* @param block block to decompress.
603			* @return how much texture data has been consumed.
604			*/
605		512	static int rgtc2u_block(uint8_t dst, ptrdiff_t stride, const uint8_t block)
606			{
607		512	rgtc2_block_internal(dst, stride, block, 0);
608
609		512	return 16;
610			}
611
612			/**
613			* Decompress one block of a 3Dc texture with unsigned components
614			* and store the resulting RGBA pixels in 'dst'. Alpha is fully opaque.
615			*
616			* @param dst output buffer.
617			* @param stride scanline in bytes.
618			* @param block block to decompress.
619			* @return how much texture data has been consumed.
620			*/
621		1024	static int dxn3dc_block(uint8_t dst, ptrdiff_t stride, const uint8_t block)
622			{
623			int x, y;
624		1024	rgtc2_block_internal(dst, stride, block, 0);
625
626			/* This is the 3Dc variant of RGTC2, with swapped R and G. */
627	✓✓	5120	for (y = 0; y < 4; y++) {
628	✓✓	20480	for (x = 0; x < 4; x++) {
629		16384	uint8_t p = dst + x 4 + y * stride;
630		16384	FFSWAP(uint8_t, p[0], p[1]);
631			}
632			}
633
634		1024	return 16;
635			}
636
637		148	av_cold void ff_texturedsp_init(TextureDSPContext *c)
638			{
639		148	c->dxt1_block = dxt1_block;
640		148	c->dxt1a_block = dxt1a_block;
641		148	c->dxt2_block = dxt2_block;
642		148	c->dxt3_block = dxt3_block;
643		148	c->dxt4_block = dxt4_block;
644		148	c->dxt5_block = dxt5_block;
645		148	c->dxt5y_block = dxt5y_block;
646		148	c->dxt5ys_block = dxt5ys_block;
647		148	c->rgtc1s_block = rgtc1s_block;
648		148	c->rgtc1u_block = rgtc1u_block;
649		148	c->rgtc1u_gray_block = rgtc1u_gray_block;
650		148	c->rgtc1u_alpha_block = rgtc1u_alpha_block;
651		148	c->rgtc2s_block = rgtc2s_block;
652		148	c->rgtc2u_block = rgtc2u_block;
653		148	c->dxn3dc_block = dxn3dc_block;
654		148	}