bicyclesonthemoon.info Git - ott/enhance/blob - diff.c

   1 /*
   2 diff.c
   3 see the difference!
   4 15.11.2022
   5
   6 Copyright (C) 2022  Balthasar Szczepański
   7
   8 This program is free software: you can redistribute it and/or modify
   9 it under the terms of the GNU Affero General Public License as
  10 published by the Free Software Foundation, either version 3 of the
  11 License, or (at your option) any later version.
  12
  13 This program is distributed in the hope that it will be useful,
  14 but WITHOUT ANY WARRANTY; without even the implied warranty of
  15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16 GNU Affero General Public License for more details.
  17
  18 You should have received a copy of the GNU Affero General Public License
  19 along with this program.  If not, see <http://www.gnu.org/licenses/>.
  20
  21
  22 Requires Dev Image Library (libdevil) (http://openil.sourceforge.net/)
  23 on Pentium III libdevil must be recompiled with
  24 --disable-ssl2 --disable-ssl3
  25 (https://bugs.debian.org/cgi-bin/bugreport.cgi?bug=572954)
  26
  27 */
  28
  29 #define RA 0x00
  30 #define GA 0x57
  31 #define BA 0xAF
  32
  33 #define RB 0xBB
  34 #define GB 0x66
  35 #define BB 0x22
  36
  37 #include <stdio.h>
  38 #include <errno.h>
  39
  40 #include "bluenh.h"
  41 #include "core.h"
  42
  43 struct diff_data
  44 {
  45         ILuint r_a;
  46         ILuint r_a;
  47         ILuint r_a;
  48         ILuint g_b;
  49         ILuint g_b;
  50         ILuint g_b;
  51         ILuint max;
  52 };
  53
  54 char DIFF_MISSING_ARGS[] = "Missing parameters.\ndiff inPixA inPixB outPix [RA GA BA [RB GB BB]]\n";
  55
  56 int subtool_diff (int argc, char **argv, int argi, char **err)
  57 {
  58         ILubyte v;
  59         struct diff_data data;
  60         struct IL_full_info info[3];
  61         uint_fast16_t id[3] = {0, 1, 2};
  62         ILint xyf0[3] = {0, 0, 0};
  63         FLAG_TYPE flags[3] = {
  64                 CAN_BE_MULTIPLE | CAN_BE_OVER_8BIT | CANNOT_BE_GRAY | NOT_WRITABLE,
  65                 CAN_BE_MULTIPLE | CAN_BE_OVER_8BIT | CANNOT_BE_GRAY | NOT_WRITABLE,
  66                 CAN_BE_MULTIPLE | CAN_BE_OVER_8BIT | CANNOT_BE_GRAY | NOT_READABLE
  67         };
  68         uint_fast8_t palette_only;
  69         uint_fast8_t i;
  70         ILubyte new_pal[0x100 * 4];
  71         ILubyte *pal[3];
  72         ILuint handle;
  73         int r;
  74
  75
  76         if (argc < argi + 3)
  77         {
  78                 *err = DIFF_MISSING_ARGS;
  79                 return EINVAL;
  80         }
  81
  82         r = reserve_pictures(3);
  83         if (r)
  84         {
  85                 *err = CREATE_FAILED;
  86                 return r;
  87         }
  88
  89         r = load_picture(0, argv[argi], &(info[0]), &(flags[0]));
  90         if (r)
  91         {
  92                 *err = LOAD_FAILED;
  93                 return r;
  94         }
  95
  96         r = load_picture(1, argv[argi], &(info[1]), &(flags[1]));
  97         if (r)
  98         {
  99                 *err = LOAD_FAILED;
 100                 return r;
 101         }
 102
 103         if ((info[0].image_height != info[1].image_height) || (info[0].image_width != info[1].image_width) || (info[0].num_images != info[1].num_images))
 104         {
 105                 *err = SIZE_MISMATCH;
 106                 return r;
 107         }
 108
 109         if ((info[0].image_bpc != info[1].image_bpc) || (!(flags[0] & IS_OVER_8BIT)) || (!(flags[0] & IS_OVER_8BIT)))
 110         {
 111                 flags[0] &= ~CAN_BE_OVER_8BIT;
 112                 flags[1] &= ~CAN_BE_OVER_8BIT;
 113                 flags[2] &= ~CAN_BE_OVER_8BIT;
 114         }
 115
 116         if ((flags[0] & HAS_ALPHA) || (flags[1] & HAS_ALPHA))
 117         {
 118                 flags[0] |= MUST_HAVE_ALPHA;
 119                 flags[1] |= MUST_HAVE_ALPHA;
 120                 flags[2] |= MUST_HAVE_ALPHA;
 121         }
 122         else
 123                 flags[2] |= CANNOT_HAVE_ALPHA;
 124
 125         if ((flags[0] & IS_INDEXED) && (flags[1] & IS_INDEXED) && ((info[0].palette_num_cols * info[1].palette_num_cols) <= 0x100))
 126         {
 127                 palette_only = 1;
 128                 flags[0] |= OK_PALETTE_ONLY;
 129                 flags[1] |= OK_PALETTE_ONLY;
 130                 flags[2] |= OK_PALETTE_ONLY;
 131                 flags[0] &= ~CAN_BE_OVER_8BIT;
 132                 flags[1] &= ~CAN_BE_OVER_8BIT;
 133                 flags[2] &= ~CAN_BE_OVER_8BIT;
 134                 flags[2] |= MUST_BE_INDEXED;
 135         }
 136         else
 137         {
 138                 palette_only = 0;
 139                 flags[0] |= CANNOT_BE_INDEXED;
 140                 flags[1] |= CANNOT_BE_INDEXED;
 141                 flags[2] |= CANNOT_BE_INDEXED;
 142         }
 143
 144         r = convert_picture(0, &(info[0]), &(flags[0]);
 145         {
 146                 *err = CONVERT_FAILED;
 147                 return EIO;
 148         }
 149
 150         r = convert_picture(1, &(info[1]), &(flags[1]);
 151         {
 152                 *err = CONVERT_FAILED;
 153                 return EIO;
 154         }
 155
 156         if (argc >= argi + 6)
 157         {
 158                 sscanf(argv[argi+3],"%hhu",&v);
 159                 data.r_a = upscale_value(v, info[0].image_bpc);
 160                 sscanf(argv[argi+4],"%hhu",&v);
 161                 data.g_a = upscale_value(v, info[0].image_bpc);
 162                 sscanf(argv[argi+5],"%hhu",&v);
 163                 data.b_a = upscale_value(v, info[0].image_bpc);
 164         }
 165         else
 166         {
 167                 data.r_a = upscale_value(RA, info[0].image_bpc);
 168                 data.g_a = upscale_value(GA, info[0].image_bpc);
 169                 data.b_a = upscale_value(BA, info[0].image_bpc);
 170         }
 171         if (argc >= argi + 9)
 172         {
 173                 sscanf(argv[argi+6],"%hhu",&v);
 174                 data.r_b = upscale_value(v, info[0].image_bpc);
 175                 sscanf(argv[argi+7],"%hhu",&v);
 176                 data.g_b = upscale_value(v, info[0].image_bpc);
 177                 sscanf(argv[argi+8],"%hhu",&v);
 178                 data.b_b = upscale_value(v, info[0].image_bpc);
 179         }
 180         else
 181         {
 182                 data.r_b = upscale_value(RB, info[0].image_bpc);
 183                 data.g_b = upscale_value(GB, info[0].image_bpc);
 184                 data.b_b = upscale_value(BB, info[0].image_bpc);
 185         }
 186
 187         r = build_picture_from_info(2, &(info[0], &(info[2]), &(flags[2]));
 188         if (r!=0)
 189         {
 190                 *err = CREATE_FAILED;
 191                 return EIO;
 192         }
 193
 194         if (palette_only)
 195         {
 196
 197                 ilRegisterPal
 198
 199
 200         }
 201         else
 202         {
 203                 for (i=0; i<3; ++i)
 204                 {
 205                         handle = get_handle(i);
 206                         ilBindImage(handle);
 207                         if (i==2)
 208                         {
 209                                 ilRegisterPal(
 210                                         new_pal,
 211                                         ((flags[0] & HAS_ALPHA)?4:3) * info[0].palette_num_cols * info[1].palette_num_cols,
 212
 213
 214
 215         }