// SPDX-License-Identifier: GPL-2.0-only
/*
 * Font rotation
 *
 *    Copyright (C) 2005 Antonino Daplas <adaplas @pol.net>
 *
 * This file is subject to the terms and conditions of the GNU General Public
 * License.  See the file COPYING in the main directory of this archive for
 * more details.
 */

#include <linux/errno.h>
#include <linux/export.h>
#include <linux/math.h>
#include <linux/overflow.h>
#include <linux/slab.h>
#include <linux/string.h>

#include "font.h"

/* number of bits per line */
static unsigned int font_glyph_bit_pitch(unsigned int width)
{
	return round_up(width, 8);
}

static unsigned int __font_glyph_pos(unsigned int x, unsigned int y, unsigned int bit_pitch,
				     unsigned int *bit)
{
	unsigned int off = y * bit_pitch + x;
	unsigned int bit_shift = off % 8;

	*bit = 0x80 >> bit_shift; /* MSB has position 0, LSB has position 7 */

	return off / 8;
}

static bool font_glyph_test_bit(const unsigned char *glyph, unsigned int x, unsigned int y,
				unsigned int bit_pitch)
{
	unsigned int bit;
	unsigned int i = __font_glyph_pos(x, y, bit_pitch, &bit);

	return glyph[i] & bit;
}

static void font_glyph_set_bit(unsigned char *glyph, unsigned int x, unsigned int y,
			       unsigned int bit_pitch)
{
	unsigned int bit;
	unsigned int i = __font_glyph_pos(x, y, bit_pitch, &bit);

	glyph[i] |= bit;
}

static void __font_glyph_rotate_90(const unsigned char *glyph,
				   unsigned int width, unsigned int height,
				   unsigned char *out)
{
	unsigned int x, y;
	unsigned int shift = (8 - (height % 8)) & 7;
	unsigned int bit_pitch = font_glyph_bit_pitch(width);
	unsigned int out_bit_pitch = font_glyph_bit_pitch(height);

	for (y = 0; y < height; y++) {
		for (x = 0; x < width; x++) {
			if (font_glyph_test_bit(glyph, x, y, bit_pitch)) {
				font_glyph_set_bit(out, out_bit_pitch - 1 - y - shift, x,
						   out_bit_pitch);
			}
		}
	}
}

/**
 * font_glyph_rotate_90 - Rotate a glyph pattern by 90° in clockwise direction
 * @glyph: The glyph to rotate
 * @width: The glyph width in bits per scanline
 * @height: The number of scanlines in the glyph
 * @out: The rotated glyph bitmap
 *
 * The parameters @width and @height refer to the input glyph given in @glyph.
 * The caller has to provide the output buffer @out of sufficient size to hold
 * the rotated glyph. Rotating by 90° flips the width and height for the output
 * glyph. Depending on the glyph pitch, the size of the output glyph can be
 * different than the size of the input. Callers have to take this into account
 * when allocating the output memory.
 */
void font_glyph_rotate_90(const unsigned char *glyph, unsigned int width, unsigned int height,
			  unsigned char *out)
{
	memset(out, 0, font_glyph_size(height, width)); /* flip width/height */

	__font_glyph_rotate_90(glyph, width, height, out);
}
EXPORT_SYMBOL_GPL(font_glyph_rotate_90);

static void __font_glyph_rotate_180(const unsigned char *glyph,
				    unsigned int width, unsigned int height,
				    unsigned char *out)
{
	unsigned int x, y;
	unsigned int shift = (8 - (width % 8)) & 7;
	unsigned int bit_pitch = font_glyph_bit_pitch(width);

	for (y = 0; y < height; y++) {
		for (x = 0; x < width; x++) {
			if (font_glyph_test_bit(glyph, x, y, bit_pitch)) {
				font_glyph_set_bit(out, bit_pitch - 1 - x - shift, height - 1 - y,
						   bit_pitch);
			}
		}
	}
}

/**
 * font_glyph_rotate_180 - Rotate a glyph pattern by 180°
 * @glyph: The glyph to rotate
 * @width: The glyph width in bits per scanline
 * @height: The number of scanlines in the glyph
 * @out: The rotated glyph bitmap
 *
 * The parameters @width and @height refer to the input glyph given in @glyph.
 * The caller has to provide the output buffer @out of sufficient size to hold
 * the rotated glyph.
 */
void font_glyph_rotate_180(const unsigned char *glyph, unsigned int width, unsigned int height,
			   unsigned char *out)
{
	memset(out, 0, font_glyph_size(width, height));

	__font_glyph_rotate_180(glyph, width, height, out);
}
EXPORT_SYMBOL_GPL(font_glyph_rotate_180);

static void __font_glyph_rotate_270(const unsigned char *glyph,
				    unsigned int width, unsigned int height,
				    unsigned char *out)
{
	unsigned int x, y;
	unsigned int shift = (8 - (width % 8)) & 7;
	unsigned int bit_pitch = font_glyph_bit_pitch(width);
	unsigned int out_bit_pitch = font_glyph_bit_pitch(height);

	for (y = 0; y < height; y++) {
		for (x = 0; x < width; x++) {
			if (font_glyph_test_bit(glyph, x, y, bit_pitch))
				font_glyph_set_bit(out, y, bit_pitch - 1 - x - shift,
						   out_bit_pitch);
		}
	}
}

/**
 * font_glyph_rotate_270 - Rotate a glyph pattern by 270° in clockwise direction
 * @glyph: The glyph to rotate
 * @width: The glyph width in bits per scanline
 * @height: The number of scanlines in the glyph
 * @out: The rotated glyph bitmap
 *
 * The parameters @width and @height refer to the input glyph given in @glyph.
 * The caller has to provide the output buffer @out of sufficient size to hold
 * the rotated glyph. Rotating by 270° flips the width and height for the output
 * glyph. Depending on the glyph pitch, the size of the output glyph can be
 * different than the size of the input. Callers have to take this into account
 * when allocating the output memory.
 */
void font_glyph_rotate_270(const unsigned char *glyph, unsigned int width, unsigned int height,
			   unsigned char *out)
{
	memset(out, 0, font_glyph_size(height, width)); /* flip width/height */

	__font_glyph_rotate_270(glyph, width, height, out);
}
EXPORT_SYMBOL_GPL(font_glyph_rotate_270);

/**
 * font_data_rotate - Rotate font data by multiples of 90°
 * @fd: The font data to rotate
 * @width: The glyph width in bits per scanline
 * @height: The number of scanlines in the glyph
 * @charcount: The number of glyphs in the font
 * @steps: Number of rotation steps of 90°
 * @buf: Preallocated output buffer; can be NULL
 * @bufsize: The size of @buf in bytes; can be NULL
 *
 * The parameters @width and @height refer to the visible number of pixels
 * and scanlines in a single glyph. The number of glyphs is given in @charcount.
 * Rotation happens in steps of 90°. The @steps parameter can have any value,
 * but only 0 to 3 produce distinct results. With 4 or higher, a full rotation
 * has been performed. You can pass any value for @steps and the helper will
 * perform the appropriate rotation. Note that the returned buffer is not
 * compatible with font_data_t. It only contains glyph data in the same format
 * as returned by font_data_buf(). Callers are responsible to free the returned
 * buffer with kfree(). Font rotation typically happens when displays get
 * re-oriented. To avoid unnecessary re-allocation of the memory buffer, the
 * caller can pass in an earlier result buffer in @buf for reuse. The old and
 * new buffer sizes are given and retrieved by the caller in @bufsize. The
 * allocation semantics are compatible with krealloc().
 *
 * Returns:
 * A buffer with rotated glyphs on success, or an error pointer otherwise
 */
unsigned char *font_data_rotate(font_data_t *fd, unsigned int width, unsigned int height,
				unsigned int charcount, unsigned int steps,
				unsigned char *buf, size_t *bufsize)
{
	const unsigned char *src = font_data_buf(fd);
	unsigned int s_cellsize = font_glyph_size(width, height);
	unsigned int d_cellsize, i;
	unsigned char *dst;
	size_t size;

	steps %= 4;

	switch (steps) {
	case 0:
	case 2:
		d_cellsize = s_cellsize;
		break;
	case 1:
	case 3:
		d_cellsize = font_glyph_size(height, width); /* flip width/height */
		break;
	}

	if (check_mul_overflow(charcount, d_cellsize, &size))
		return ERR_PTR(-EINVAL);

	if (!buf || !bufsize || size > *bufsize) {
		dst = kmalloc_array(charcount, d_cellsize, GFP_KERNEL);
		if (!dst)
			return ERR_PTR(-ENOMEM);

		kfree(buf);
		buf = dst;
		if (bufsize)
			*bufsize = size;
	} else {
		dst = buf;
	}

	switch (steps) {
	case 0:
		memcpy(dst, src, size);
		break;
	case 1:
		memset(dst, 0, size);
		for (i = 0; i < charcount; ++i) {
			__font_glyph_rotate_90(src, width, height, dst);
			src += s_cellsize;
			dst += d_cellsize;
		}
		break;
	case 2:
		memset(dst, 0, size);
		for (i = 0; i < charcount; ++i) {
			__font_glyph_rotate_180(src, width, height, dst);
			src += s_cellsize;
			dst += d_cellsize;
		}
		break;
	case 3:
		memset(dst, 0, size);
		for (i = 0; i < charcount; ++i) {
			__font_glyph_rotate_270(src, width, height, dst);
			src += s_cellsize;
			dst += d_cellsize;
		}
		break;
	}

	return buf;
}
EXPORT_SYMBOL_GPL(font_data_rotate);