chiark / gitweb /
Speed is OK now and it runs inside VNC on liberator
[ypp-sc-tools.db-test.git] / pctb / structure.h
index 10de443ed6e55169520bea1d7e4e57fd3610bb05..ec399a2aaa7cb974dfee2b636971ad2abb348415 100644 (file)
@@ -1,3 +1,31 @@
+/*
+ * Image canonicalisation function for use by callers feeding
+ *  images into structure.c's routines.
+ */
+/*
+ *  This is part of ypp-sc-tools, a set of third-party tools for assisting
+ *  players of Yohoho Puzzle Pirates.
+ * 
+ *  Copyright (C) 2009 Ian Jackson <ijackson@chiark.greenend.org.uk>
+ * 
+ *  This program is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ * 
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ * 
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ * 
+ *  Yohoho and Puzzle Pirates are probably trademarks of Three Rings and
+ *  are used without permission.  This program is not endorsed or
+ *  sponsored by Three Rings.
+ */
+
 #ifndef STRUCTURE_H
 #define STRUCTURE_H
 
@@ -14,43 +42,54 @@ extern const CanonColourInfo canoncolourinfos[];
 
 CanonImage *alloc_canon_image(int w, int h);
 
-#ifdef DEBUG_RECTANGLES
-# define CANIMG_DEBUG_RECTANGLE_1LINE(im,w,h)  \
-      fprintf(debug, "%4d ",y);                        \
-      int r= fwrite(im->d + y*w, 1,w, debug);  \
-      eassert(r==w);                           \
-      fputc('\n',debug);
-#else
-# define CANIMG_DEBUG_RECTANGLE_1LINE(im,y,h) /* nothing */
-#endif
-
-#define CANONICALISE_IMAGE(im,w,h, COMPUTE_RGB) do{            \
-    /* compute_rgb should be a number of statements, or                \
-     * a block, which assigns to                               \
-     *   unsigned long rgb;                                    \
-     * given the values of                                     \
-     *   int x,y;                                              \
-     * all of which are anamorphic.  Result is stored in im.   \
-     * The COMPUTE_RGB is executed exactly once for            \
-     * each pixel in reading order.                            \
-     */                                                                \
-    (im)= alloc_canon_image((w), (h));                         \
-                                                               \
-    int x,y;                                                   \
-    for (y=0; y<(h); y++) {                                    \
-      for (x=0; x<(w); x++) {                                  \
-        const CanonColourInfo *cci;                            \
-        unsigned long rgb;                                     \
-       COMPUTE_RGB;                                            \
-       for (cci=canoncolourinfos; cci->c; cci++)               \
-         if (cci->rgb == rgb) {                                \
-           (im)->d[y*(w) + x]= cci->c;                         \
-           break;                                              \
-         }                                                     \
-      }                                                                \
-      CANIMG_DEBUG_RECTANGLE_1LINE((im),(w),(h))               \
-    }                                                          \
-    debug_flush();                                             \
+#define CANONICALISE_IMAGE(im,w,h, COMPUTE_RGB) do{                    \
+    /* compute_rgb should be a number of statements, or                        \
+     * a block, which assigns to                                       \
+     *   unsigned long rgb;                                            \
+     * given the values of                                             \
+     *   int x,y;                                                      \
+     * all of which are anamorphic.  Result is stored in im.           \
+     * The COMPUTE_RGB is executed exactly once for                    \
+     * each pixel in reading order.                                    \
+     */                                                                        \
+    (im)= alloc_canon_image((w), (h));                                 \
+                                                                       \
+    int x,y;                                                           \
+    unsigned long last_rgb= ~0UL;                                      \
+    int last_c= -1;                                                    \
+    for (y=0; y<(h); y++) {                                            \
+      for (x=0; x<(w); x++) {                                          \
+        const CanonColourInfo *cci;                                    \
+        unsigned long rgb;                                             \
+       COMPUTE_RGB;                                                    \
+       if (rgb == last_rgb) {                                          \
+         (im)->d[y*(w) + x]= last_c;                                   \
+       } else {                                                        \
+         for (cci=canoncolourinfos; cci->c; cci++) {                   \
+           if (cci->rgb == rgb) {                                      \
+             last_rgb= rgb;                                            \
+             (im)->d[y*(w) + x]= last_c= cci->c;                       \
+             break;                                                    \
+           }                                                           \
+         }                                                             \
+       }                                                               \
+      }                                                                        \
+      if (DEBUGP(rect)) {                                              \
+       fprintf(debug, "%4d ",y);                                       \
+       fwrite(im->d + y*w, 1,w, debug);                                \
+       fputc('\n',debug);                                              \
+      }                                                                        \
+    }                                                                  \
+    debug_flush();                                                     \
+  }while(0)
+
+
+#define CANONIMG_ALSO_STORERGB(ri)             \
+  do{                                          \
+    unsigned char *rip= RI_PIXEL((ri),x,y);    \
+    rip[0]= rgb >> 16;                         \
+    rip[1]= rgb >> 8;                          \
+    rip[2]= rgb;                               \
   }while(0)