im.h

Go to the documentation of this file.

// -*- coding: utf-8-unix -*-
/*
 * Copyright (c) 2021-2024 Daishi Mori (mori0091)
 *
 * This software is released under the MIT License.\n
 * See https://github.com/mori0091/libmsx/blob/main/LICENSE
 *
 * GitHub libmsx project\n
 * https://github.com/mori0091/libmsx
 */
#ifndef IMG_H_
#define IMG_H_
 
#include <stddef.h>
#include <stdint.h>
 
typedef uint8_t BM8x8[8];
 
typedef BM8x8 SP8x8;
 
typedef BM8x8 SP16x16[4];
 
void im_copy_BM8x8(const BM8x8 * src, BM8x8 * dst);
 
void im_copy_v_BM8x8(const BM8x8 * src);
 
void im_hflip_BM8x8(const BM8x8 * src, BM8x8 * dst);
 
void im_hflip_v_BM8x8(const BM8x8 * src);
 
void im_vflip_BM8x8(const BM8x8 * src, BM8x8 * dst);
 
void im_vflip_v_BM8x8(const BM8x8 * src);
 
void im_tr_BM8x8(const BM8x8 * src, BM8x8 * dst);
 
void im_tr_v_BM8x8(const BM8x8 * src);
 
void im_adtr_BM8x8(const BM8x8 * src, BM8x8 * dst);
 
void im_adtr_v_BM8x8(const BM8x8 * src);
 
void im_rot90_BM8x8(const BM8x8 * src, BM8x8 * dst);
 
void im_rot90_v_BM8x8(const BM8x8 * src);
 
void im_rot180_BM8x8(const BM8x8 * src, BM8x8 * dst);
 
void im_rot180_v_BM8x8(const BM8x8 * src);
 
void im_rot270_BM8x8(const BM8x8 * src, BM8x8 * dst);
 
void im_rot270_v_BM8x8(const BM8x8 * src);
 
void im_cmpl_BM8x8(const BM8x8 * src, BM8x8 * dst);
 
void im_cmpl_v_BM8x8(const BM8x8 * src);
 
void im_diff_BM8x8(const BM8x8 * src1, const BM8x8 * src2, BM8x8 * dst);
 
void im_diff_v_BM8x8(const BM8x8 * src1, const BM8x8 * src2);
 
void im_and_BM8x8(const BM8x8 * src1, const BM8x8 * src2, BM8x8 * dst);
 
void im_and_v_BM8x8(const BM8x8 * src1, const BM8x8 * src2);
 
void im_or_BM8x8(const BM8x8 * src1, const BM8x8 * src2, BM8x8 * dst);
 
void im_or_v_BM8x8(const BM8x8 * src1, const BM8x8 * src2);
 
void im_xor_BM8x8(const BM8x8 * src1, const BM8x8 * src2, BM8x8 * dst);
 
void im_xor_v_BM8x8(const BM8x8 * src1, const BM8x8 * src2);
 
void im_shift_u_BM8x8(uint8_t sft, const BM8x8 * src, BM8x8 * dst);
 
void im_shift_u_v_BM8x8(uint8_t sft, const BM8x8 * src);
 
void im_shift_d_BM8x8(uint8_t sft, const BM8x8 * src, BM8x8 * dst);
 
void im_shift_d_v_BM8x8(uint8_t sft, const BM8x8 * src);
 
void im_shift_l_BM8x8(uint8_t sft, const BM8x8 * src, BM8x8 * dst);
 
void im_shift_l_v_BM8x8(uint8_t sft, const BM8x8 * src);
 
void im_shift_r_BM8x8(uint8_t sft, const BM8x8 * src, BM8x8 * dst);
 
void im_shift_r_v_BM8x8(uint8_t sft, const BM8x8 * src);
 
void im_rotate_u_BM8x8(uint8_t sft, const BM8x8 * src, BM8x8 * dst);
 
void im_rotate_u_v_BM8x8(uint8_t sft, const BM8x8 * src);
 
void im_rotate_d_BM8x8(uint8_t sft, const BM8x8 * src, BM8x8 * dst);
 
void im_rotate_d_v_BM8x8(uint8_t sft, const BM8x8 * src);
 
void im_rotate_l_BM8x8(uint8_t sft, const BM8x8 * src, BM8x8 * dst);
 
void im_rotate_l_v_BM8x8(uint8_t sft, const BM8x8 * src);
 
void im_rotate_r_BM8x8(uint8_t sft, const BM8x8 * src, BM8x8 * dst);
 
void im_rotate_r_v_BM8x8(uint8_t sft, const BM8x8 * src);
 
void im_shift_l_vec_BM8x8(uint8_t sft, size_t n, const BM8x8 * src, BM8x8 * dst);
 
void im_shift_r_vec_BM8x8(uint8_t sft, size_t n, const BM8x8 * src, BM8x8 * dst);
 
void im_rotate_l_vec_BM8x8(uint8_t sft, size_t n, const BM8x8 * src, BM8x8 * dst);
 
void im_rotate_r_vec_BM8x8(uint8_t sft, size_t n, const BM8x8 * src, BM8x8 * dst);
 
enum ImOp {
  // Unary operators : image -> image
  IM_IDENTITY      = 0,
  IM_COPY          = IM_IDENTITY,
  IM_COMPLEMENT    = 1,
  IM_TRANSPOSE     = (1 << 5),
  IM_FLIP_VERT     = (1 << 6),
  IM_FLIP_HORZ     = (1 << 7),
  IM_ROTATE_90     = (IM_TRANSPOSE | IM_FLIP_HORZ),
  IM_ROTATE_180    = (IM_FLIP_VERT | IM_FLIP_HORZ),
  IM_ROTATE_270    = (IM_TRANSPOSE | IM_FLIP_VERT),
  IM_ANTITRANSPOSE = (IM_TRANSPOSE | IM_FLIP_VERT | IM_FLIP_HORZ),
};
 
// /**
//  * Enumeration of boolean operators for images.
//  */
// enum ImOp_boolean {
//   // Unary operators : image -> image
//   IM_NOT             = IM_COMPLEMENT,
//   // Binary operators : (image, image) -> image
//   IM_AND             = 2,
//   IM_OR              = 4,
//   IM_XOR             = 6,
//   IM_NAND            = IM_NOT | IM_AND,
//   IM_NOR             = IM_NOT | IM_OR,
//   IM_NXOR            = IM_NOT | IM_XOR,
//   IM_INTERSECTION    = IM_AND,
//   IM_UNION           = IM_OR,
//   IM_SETDIFF         = 8,
//   // (reserved 9 to 15)
// };
 
// /**
//  * Enumeration of shift operators for images.
//  */
// enum ImOp_shift {
//   // Shift operators : (scalar, image) -> image
//   IM_SHIFT_UP        = 16,
//   IM_SHIFT_DOWN      = 17,
//   IM_SHIFT_LEFT      = 18,
//   IM_SHIFT_RIGHT     = 19,
//   IM_ROTATE_UP       = 20,
//   IM_ROTATE_DOWN     = 21,
//   IM_ROTATE_LEFT     = 22,
//   IM_ROTATE_RIGHT    = 23,
//   // (reserved 24 to 31)
// };
 
void im_tilemap_BM8x8(const BM8x8 tileset[256], size_t n, const uint8_t tilemap[][2], BM8x8 * dst);
 
void im_tilemap_v_BM8x8(const BM8x8 tileset[256], size_t n, const uint8_t tilemap[][2]);
 
void im_copy_SP16x16(const SP16x16 * src, SP16x16 * dst);
 
void im_copy_v_SP16x16(const SP16x16 * src);
 
void im_hflip_SP16x16(const SP16x16 * src, SP16x16 * dst);
 
void im_hflip_v_SP16x16(const SP16x16 * src);
 
void im_vflip_SP16x16(const SP16x16 * src, SP16x16 * dst);
 
void im_vflip_v_SP16x16(const SP16x16 * src);
 
void im_tr_SP16x16(const SP16x16 * src, SP16x16 * dst);
 
void im_tr_v_SP16x16(const SP16x16 * src);
 
void im_adtr_SP16x16(const SP16x16 * src, SP16x16 * dst);
 
void im_adtr_v_SP16x16(const SP16x16 * src);
 
void im_rot90_SP16x16(const SP16x16 * src, SP16x16 * dst);
 
void im_rot90_v_SP16x16(const SP16x16 * src);
 
void im_rot180_SP16x16(const SP16x16 * src, SP16x16 * dst);
 
void im_rot180_v_SP16x16(const SP16x16 * src);
 
void im_rot270_SP16x16(const SP16x16 * src, SP16x16 * dst);
 
void im_rot270_v_SP16x16(const SP16x16 * src);
 
void im_cmpl_SP16x16(const SP16x16 * src, SP16x16 * dst);
 
void im_cmpl_v_SP16x16(const SP16x16 * src);
 
void im_diff_SP16x16(const SP16x16 * src1, const SP16x16 * src2, SP16x16 * dst);
 
void im_diff_v_SP16x16(const SP16x16 * src1, const SP16x16 * src2);
 
void im_and_SP16x16(const SP16x16 * src1, const SP16x16 * src2, SP16x16 * dst);
 
void im_and_v_SP16x16(const SP16x16 * src1, const SP16x16 * src2);
 
void im_or_SP16x16(const SP16x16 * src1, const SP16x16 * src2, SP16x16 * dst);
 
void im_or_v_SP16x16(const SP16x16 * src1, const SP16x16 * src2);
 
void im_xor_SP16x16(const SP16x16 * src1, const SP16x16 * src2, SP16x16 * dst);
 
void im_xor_v_SP16x16(const SP16x16 * src1, const SP16x16 * src2);
 
void im_shift_u_SP16x16(uint8_t sft, const SP16x16 * src, SP16x16 * dst);
 
void im_shift_u_v_SP16x16(uint8_t sft, const SP16x16 * src);
 
void im_shift_d_SP16x16(uint8_t sft, const SP16x16 * src, SP16x16 * dst);
 
void im_shift_d_v_SP16x16(uint8_t sft, const SP16x16 * src);
 
void im_shift_l_SP16x16(uint8_t sft, const SP16x16 * src, SP16x16 * dst);
 
void im_shift_l_v_SP16x16(uint8_t sft, const SP16x16 * src);
 
void im_shift_r_SP16x16(uint8_t sft, const SP16x16 * src, SP16x16 * dst);
 
void im_shift_r_v_SP16x16(uint8_t sft, const SP16x16 * src);
 
void im_rotate_u_SP16x16(uint8_t sft, const SP16x16 * src, SP16x16 * dst);
 
void im_rotate_u_v_SP16x16(uint8_t sft, const SP16x16 * src);
 
void im_rotate_d_SP16x16(uint8_t sft, const SP16x16 * src, SP16x16 * dst);
 
void im_rotate_d_v_SP16x16(uint8_t sft, const SP16x16 * src);
 
void im_rotate_l_SP16x16(uint8_t sft, const SP16x16 * src, SP16x16 * dst);
 
void im_rotate_l_v_SP16x16(uint8_t sft, const SP16x16 * src);
 
void im_rotate_r_SP16x16(uint8_t sft, const SP16x16 * src, SP16x16 * dst);
 
void im_rotate_r_v_SP16x16(uint8_t sft, const SP16x16 * src);
 
void im_trim_SP16x16(uint8_t tblr[4], const SP16x16 * src, SP16x16 * dst);
 
#endif // IMG_H_