static void dxt5_decompress_block(const BYTE *src, BYTE *dst, UINT width, UINT height, UINT depth,
        UINT x_pos, UINT y_pos, UINT z_pos, UINT dst_slice_pitch, UINT64 cur_block)
{
    UINT64 alpha_block, alpha_index, color_block, color_index;
    const UINT64 *source;
    DWORD *dest;
    DWORD alpha_lookup;
    DWORD bgra;
    DWORD temp;
    DWORD i, x, y;
    WORD color[2];
    BYTE alpha_val, color_val;
    BYTE alpha[8];
    BYTE r[4];
    BYTE g[4];
    BYTE b[4];

    source = (const UINT64  *)(src + cur_block * 16);
    alpha_block = source[0];
    color_block = source[1];

    alpha[0] = alpha_block & 0xff;
    alpha[1] = (alpha_block >> 8) & 0xff;

    /* Generate alpha lookup values */
    if (alpha[0] > alpha[1])
    {
        for (i = 0; i < 6; i++)
            alpha[2 + i] = (((6 - i) * alpha[0]) + ((1 + i) * alpha[1])) / 7;
    }
    else if (alpha[0] <= alpha[1])
    {
        for (i = 0; i < 4; i++)
            alpha[2 + i] = (((4 - i) * alpha[0]) + ((1 + i) * alpha[1])) / 5;
        alpha[6] = 0;
        alpha[7] = 255;
    }

    /* Generate color lookup values */
    color[0] = color_block & 0xffff;
    color[1] = (color_block >> 16) & 0xffff;

    for (i = 0; i < 2; i++)
    {
        temp = (color[i] >> 11) * 255 + 16;
        r[i] = (temp / 32 + temp) / 32;
        temp = ((color[i] >> 5) & 0x3f) * 255 + 32;
        g[i] = (temp / 64 + temp) / 64;
        temp = (color[i] & 0x1f) * 255 + 16;
        b[i] = (temp / 32 + temp) / 32;
    }

    for (i = 0; i < 2; i++)
    {
        r[2 + i] = (2 * r[0 + i] + r[1 - i]) / 3;
        g[2 + i] = (2 * g[0 + i] + g[1 - i]) / 3;
        b[2 + i] = (2 * b[0 + i] + b[1 - i]) / 3;
    }

    color_index = (color_block >> 32) & 0xffffffff;
    alpha_index = (alpha_block >> 16);

    dest = (DWORD *)(dst + z_pos * dst_slice_pitch);

    for (y = 0; y < 4; y++) {
        if (y_pos + y >= height)
                break;
        for (x = 0; x < 4; x++) {
            if (x_pos + x >= width)
                break;

            color_val = 0;
            alpha_val = 0;
            bgra = 0;

            color_val = (color_index >> (y * 8));
            color_val = (color_val >> (x * 2)) & 0x3;
            alpha_lookup = (alpha_index >> (y * 12)) & 0xfff;
            alpha_val = (alpha_lookup >> (x * 3)) & 0x7;
            bgra = ((alpha[alpha_val] << 24) | (r[color_val] << 16) | (g[color_val] << 8) | b[color_val]);
            dest[(y_pos + y) * width + (x_pos + x)] = bgra;
        }
    }
}

static void convert_dxt5_b8g8r8a8_unorm(const BYTE *src, BYTE *dst, UINT src_row_pitch, UINT src_slice_pitch,
        UINT dst_row_pitch, UINT dst_slice_pitch, UINT width, UINT height, UINT depth)
{
    UINT64 current_block;
    DWORD x, y, z;

    current_block = 0;

    for (z = 0; z < depth; z++)
    {
        for (y = 0; y < height; y += 4)
        {
            for (x = 0; x < width; x += 4)
            {
                dxt5_decompress_block(src, dst, width, height, depth, x, y, z, dst_slice_pitch, current_block);
                current_block++;
            }
        }
    }
}