libs/filters/GP_HilbertPeano.gen.c.t

   1 %% extends "base.c.t"
   2
   3 {% block descr %}Hilbert Peano dithering RGB888 -> any pixel{% endblock %}
   4
   5 %% block body
   6
   7 #include "core/GP_Core.h"
   8 #include "core/GP_GetPutPixel.h"
   9 #include "GP_HilbertCurve.h"
  10 #include "GP_Filter.h"
  11
  12 /*
  13  * Returns closest greater square of two, used to determine the curve size.
  14  */
  15 static unsigned int count_bits(unsigned int n)
  16 {
  17         unsigned int i = 0, s = n;
  18
  19         do {
  20                 n>>=1;
  21                 i++;
  22         } while (n);
  23
  24         i--;
  25
  26         return (i + (s != (1U<<i)));
  27 }
  28
  29 %% for pt in pixeltypes
  30 %% if not pt.is_unknown() and not pt.is_alpha() and not pt.is_palette()
  31 /*
  32  * Hilbert Peano RGB888 to {{ pt.name }}
  33  */
  34 int GP_FilterHilbertPeano_RGB888_to_{{ pt.name }}_Raw(const GP_Context *src,
  35                                                  GP_Context *dst,
  36                                                  GP_ProgressCallback *callback)
  37 {
  38         struct GP_CurveState state;
  39         unsigned int n;
  40
  41         n = GP_MAX(count_bits(src->w), count_bits(src->h));
  42
  43         GP_DEBUG(1, "Hilbert Peano dithering %ux%u -> n = %u", src->w, src->h, n);
  44
  45         GP_HilbertCurveInit(&state, n);
  46
  47         /* processed pixels counter */
  48         unsigned int cnt = 0;
  49
  50         /* error counters */
  51 %% for c in pt.chanslist
  52         int err_{{ c[0] }} = 0;
  53 %% endfor
  54
  55         while (GP_HilbertCurveContinues(&state)) {
  56                 if (state.x < src->w && state.y < src->h) {
  57                         GP_Pixel pix = GP_GetPixel_Raw_24BPP(src, state.x, state.y);
  58
  59 %% for c in pt.chanslist
  60 %% if pt.is_gray()
  61                         int pix_{{ c[0] }} = GP_Pixel_GET_R_RGB888(pix) +
  62                                              GP_Pixel_GET_G_RGB888(pix) +
  63                                              GP_Pixel_GET_B_RGB888(pix);
  64 %% else
  65                         int pix_{{ c[0] }} = GP_Pixel_GET_{{ c[0] }}_RGB888(pix);
  66 %% endif
  67
  68                         pix_{{ c[0] }} += err_{{ c[0] }};
  69
  70 %% if pt.is_gray()
  71                         int res_{{ c[0] }} = ({{ 2 ** c[2] - 1}} * pix_{{ c[0] }} + 382) / {{ 3 * 255 }};
  72                         err_{{ c[0] }} = pix_{{ c[0] }} - {{ 3 * 255 }} * res_{{ c[0] }} / {{ 2 ** c[2] - 1 }};
  73 %% else
  74                         int res_{{ c[0] }} = ({{ 2 ** c[2] - 1}} * pix_{{ c[0] }} + 127) / 255;
  75                         err_{{ c[0] }} = pix_{{ c[0] }} - 255 * res_{{ c[0] }} / {{ 2 ** c[2] - 1 }};
  76 %% endif
  77 %% endfor
  78
  79 %% if pt.is_gray()
  80                         GP_PutPixel_Raw_{{ pt.pixelsize.suffix }}(dst, state.x, state.y, res_V);
  81 %% else
  82                         GP_Pixel res = GP_Pixel_CREATE_{{ pt.name }}(res_{{ pt.chanslist[0][0] }}{% for c in pt.chanslist[1:] %}, res_{{ c[0] }}{% endfor %});
  83
  84                         GP_PutPixel_Raw_{{ pt.pixelsize.suffix }}(dst, state.x, state.y, res);
  85 %% endif
  86                         cnt++;
  87
  88                         if (GP_ProgressCallbackReport(callback, cnt/src->h, src->w, src->h))
  89                                 return 1;
  90
  91                         /* We are done, exit */
  92                         if (cnt == src->w * src->h - 1) {
  93                                 GP_ProgressCallbackDone(callback);
  94                                 return 0;
  95                         }
  96                 } else {
  97 %% for c in pt.chanslist
  98                         err_{{ c[0] }} = 0;
  99 %% endfor
 100                 }
 101
 102                 GP_HilbertCurveNext(&state);
 103         }
 104
 105         GP_ProgressCallbackDone(callback);
 106         return 0;
 107 }
 108
 109 %% endif
 110 %% endfor
 111
 112 int GP_FilterHilbertPeano_RGB888_Raw(const GP_Context *src,
 113                                      GP_Context *dst,
 114                                      GP_ProgressCallback *callback)
 115 {
 116         switch (dst->pixel_type) {
 117 %% for pt in pixeltypes
 118 %% if not pt.is_unknown() and not pt.is_alpha() and not pt.is_palette()
 119         case GP_PIXEL_{{ pt.name }}:
 120                 return GP_FilterHilbertPeano_RGB888_to_{{ pt.name }}_Raw(src, dst, callback);
 121 %% endif
 122 %% endfor
 123         default:
 124                 return 1;
 125         }
 126 }
 127
 128 %% endblock body