render/gradient.c

   1 /* -*- indent-tabs-mode: nil; tab-width: 4; c-basic-offset: 4; -*-
   2
   3    gradient.c for the Openbox window manager
   4    Copyright (c) 2006        Mikael Magnusson
   5    Copyright (c) 2003-2008   Dana Jansens
   6    Copyright (c) 2003        Derek Foreman
   7
   8    This program is free software; you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation; either version 2 of the License, or
  11    (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 General Public License for more details.
  17
  18    See the COPYING file for a copy of the GNU General Public License.
  19 */
  20
  21 #include "render.h"
  22 #include "gradient.h"
  23 #include "color.h"
  24 #include <glib.h>
  25 #include <string.h>
  26
  27 static void highlight(RrSurface *s, RrPixel32 *x, RrPixel32 *y,
  28                       gboolean raised);
  29 static void gradient_parentrelative(RrAppearance *a, gint w, gint h);
  30 static void gradient_solid(RrAppearance *l, gint w, gint h);
  31 static void gradient_splitvertical(RrAppearance *a, gint w, gint h);
  32 static void gradient_vertical(RrSurface *sf, gint w, gint h);
  33 static void gradient_horizontal(RrSurface *sf, gint w, gint h);
  34 static void gradient_mirrorhorizontal(RrSurface *sf, gint w, gint h);
  35 static void gradient_diagonal(RrSurface *sf, gint w, gint h);
  36 static void gradient_crossdiagonal(RrSurface *sf, gint w, gint h);
  37 static void gradient_pyramid(RrSurface *sf, gint inw, gint inh);
  38
  39 void RrRender(RrAppearance *a, gint w, gint h)
  40 {
  41     RrPixel32 *data = a->surface.pixel_data;
  42     RrPixel32 current;
  43     guint r,g,b;
  44     gint off, x;
  45
  46     switch (a->surface.grad) {
  47     case RR_SURFACE_PARENTREL:
  48         gradient_parentrelative(a, w, h);
  49         break;
  50     case RR_SURFACE_SOLID:
  51         gradient_solid(a, w, h);
  52         break;
  53     case RR_SURFACE_SPLIT_VERTICAL:
  54         gradient_splitvertical(a, w, h);
  55         break;
  56     case RR_SURFACE_VERTICAL:
  57         gradient_vertical(&a->surface, w, h);
  58         break;
  59     case RR_SURFACE_HORIZONTAL:
  60         gradient_horizontal(&a->surface, w, h);
  61         break;
  62     case RR_SURFACE_MIRROR_HORIZONTAL:
  63         gradient_mirrorhorizontal(&a->surface, w, h);
  64         break;
  65     case RR_SURFACE_DIAGONAL:
  66         gradient_diagonal(&a->surface, w, h);
  67         break;
  68     case RR_SURFACE_CROSS_DIAGONAL:
  69         gradient_crossdiagonal(&a->surface, w, h);
  70         break;
  71     case RR_SURFACE_PYRAMID:
  72         gradient_pyramid(&a->surface, w, h);
  73         break;
  74     default:
  75         g_assert_not_reached(); /* unhandled gradient */
  76         return;
  77     }
  78
  79     if (a->surface.interlaced) {
  80         gint i;
  81         RrPixel32 *p;
  82
  83         r = a->surface.interlace_color->r;
  84         g = a->surface.interlace_color->g;
  85         b = a->surface.interlace_color->b;
  86         current = (r << RrDefaultRedOffset)
  87             + (g << RrDefaultGreenOffset)
  88             + (b << RrDefaultBlueOffset);
  89         p = data;
  90         for (i = 0; i < h; i += 2, p += w)
  91             for (x = 0; x < w; ++x, ++p)
  92                 *p = current;
  93     }
  94
  95     if (a->surface.relief == RR_RELIEF_FLAT && a->surface.border) {
  96         r = a->surface.border_color->r;
  97         g = a->surface.border_color->g;
  98         b = a->surface.border_color->b;
  99         current = (r << RrDefaultRedOffset)
 100             + (g << RrDefaultGreenOffset)
 101             + (b << RrDefaultBlueOffset);
 102         for (off = 0, x = 0; x < w; ++x, off++) {
 103             *(data + off) = current;
 104             *(data + off + ((h-1) * w)) = current;
 105         }
 106         for (off = 0, x = 0; x < h; ++x, off++) {
 107             *(data + (off * w)) = current;
 108             *(data + (off * w) + w - 1) = current;
 109         }
 110     }
 111
 112     if (a->surface.relief != RR_RELIEF_FLAT) {
 113         if (a->surface.bevel == RR_BEVEL_1) {
 114             for (off = 1, x = 1; x < w - 1; ++x, off++)
 115                 highlight(&a->surface, data + off,
 116                           data + off + (h-1) * w,
 117                           a->surface.relief==RR_RELIEF_RAISED);
 118             for (off = 0, x = 0; x < h; ++x, off++)
 119                 highlight(&a->surface, data + off * w,
 120                           data + off * w + w - 1,
 121                           a->surface.relief==RR_RELIEF_RAISED);
 122         }
 123
 124         if (a->surface.bevel == RR_BEVEL_2) {
 125             for (off = 2, x = 2; x < w - 2; ++x, off++)
 126                 highlight(&a->surface, data + off + w,
 127                           data + off + (h-2) * w,
 128                           a->surface.relief==RR_RELIEF_RAISED);
 129             for (off = 1, x = 1; x < h-1; ++x, off++)
 130                 highlight(&a->surface, data + off * w + 1,
 131                           data + off * w + w - 2,
 132                           a->surface.relief==RR_RELIEF_RAISED);
 133         }
 134     }
 135 }
 136
 137 static void highlight(RrSurface *s, RrPixel32 *x, RrPixel32 *y, gboolean raised)
 138 {
 139     gint r, g, b;
 140
 141     RrPixel32 *up, *down;
 142     if (raised) {
 143         up = x;
 144         down = y;
 145     } else {
 146         up = y;
 147         down = x;
 148     }
 149
 150     r = (*up >> RrDefaultRedOffset) & 0xFF;
 151     r += (r * s->bevel_light_adjust) >> 8;
 152     g = (*up >> RrDefaultGreenOffset) & 0xFF;
 153     g += (g * s->bevel_light_adjust) >> 8;
 154     b = (*up >> RrDefaultBlueOffset) & 0xFF;
 155     b += (b * s->bevel_light_adjust) >> 8;
 156     if (r > 0xFF) r = 0xFF;
 157     if (g > 0xFF) g = 0xFF;
 158     if (b > 0xFF) b = 0xFF;
 159     *up = (r << RrDefaultRedOffset) + (g << RrDefaultGreenOffset)
 160         + (b << RrDefaultBlueOffset);
 161
 162     r = (*down >> RrDefaultRedOffset) & 0xFF;
 163     r -= (r * s->bevel_dark_adjust) >> 8;
 164     g = (*down >> RrDefaultGreenOffset) & 0xFF;
 165     g -= (g * s->bevel_dark_adjust) >> 8;
 166     b = (*down >> RrDefaultBlueOffset) & 0xFF;
 167     b -= (b * s->bevel_dark_adjust) >> 8;
 168     *down = (r << RrDefaultRedOffset) + (g << RrDefaultGreenOffset)
 169         + (b << RrDefaultBlueOffset);
 170 }
 171
 172 static void create_bevel_colors(RrAppearance *l)
 173 {
 174     gint r, g, b;
 175
 176     /* light color */
 177     r = l->surface.primary->r;
 178     r += (r * l->surface.bevel_light_adjust) >> 8;
 179     g = l->surface.primary->g;
 180     g += (g * l->surface.bevel_light_adjust) >> 8;
 181     b = l->surface.primary->b;
 182     b += (b * l->surface.bevel_light_adjust) >> 8;
 183     if (r > 0xFF) r = 0xFF;
 184     if (g > 0xFF) g = 0xFF;
 185     if (b > 0xFF) b = 0xFF;
 186     g_assert(!l->surface.bevel_light);
 187     l->surface.bevel_light = RrColorNew(l->inst, r, g, b);
 188
 189     /* dark color */
 190     r = l->surface.primary->r;
 191     r -= (r * l->surface.bevel_dark_adjust) >> 8;
 192     g = l->surface.primary->g;
 193     g -= (g * l->surface.bevel_dark_adjust) >> 8;
 194     b = l->surface.primary->b;
 195     b -= (b * l->surface.bevel_dark_adjust) >> 8;
 196     g_assert(!l->surface.bevel_dark);
 197     l->surface.bevel_dark = RrColorNew(l->inst, r, g, b);
 198 }
 199
 200 /*! Repeat the first pixel over the entire block of memory
 201   @param start The block of memory. start[0] will be copied
 202          to the rest of the block.
 203   @param w The width of the block of memory (including the already-set first
 204            element
 205 */
 206 static inline void repeat_pixel(RrPixel32 *start, gint w)
 207 {
 208     gint x;
 209     RrPixel32 *dest;
 210
 211     dest = start + 1;
 212
 213     /* for really small things, just copy ourselves */
 214     if (w < 8) {
 215         for (x = w-1; x > 0; --x)
 216             *(dest++) = *start;
 217     }
 218
 219     /* for >= 8, then use O(log n) memcpy's... */
 220     else {
 221         gchar *cdest;
 222         gint lenbytes;
 223
 224         /* copy the first 3 * 32 bits (3 words) ourselves - then we have
 225            3 + the original 1 = 4 words to make copies of at a time
 226
 227            this is faster than doing memcpy for 1 or 2 words at a time
 228         */
 229         for (x = 3; x > 0; --x)
 230             *(dest++) = *start;
 231
 232         /* cdest is a pointer to the pixel data that is typed char* so that
 233            adding 1 to its position moves it only one byte
 234
 235            lenbytes is the amount of bytes that we will be copying each
 236            iteration.  this doubles each time through the loop.
 237
 238            x is the number of bytes left to copy into.  lenbytes will alwaysa
 239            be bounded by x
 240
 241            this loop will run O(log n) times (n is the number of bytes we
 242            need to copy into), since the size of the copy is doubled each
 243            iteration.  it seems that gcc does some nice optimizations to make
 244            this memcpy very fast on hardware with support for vector operations
 245            such as mmx or see.  here is an idea of the kind of speed up we are
 246            getting by doing this (splitvertical3 switches from doing
 247            "*(data++) = color" n times to doing this memcpy thing log n times:
 248
 249            %   cumulative   self              self     total
 250            time   seconds   seconds    calls  ms/call  ms/call  name
 251            49.44      0.88     0.88     1063     0.83     0.83  splitvertical1
 252            47.19      1.72     0.84     1063     0.79     0.79  splitvertical2
 253             2.81      1.77     0.05     1063     0.05     0.05  splitvertical3
 254         */
 255         cdest = (gchar*)dest;
 256         lenbytes = 4 * sizeof(RrPixel32);
 257         for (x = (w - 4) * sizeof(RrPixel32); x > 0;) {
 258             memcpy(cdest, start, lenbytes);
 259             x -= lenbytes;
 260             cdest += lenbytes;
 261             lenbytes <<= 1;
 262             if (lenbytes > x)
 263                 lenbytes = x;
 264         }
 265     }
 266 }
 267
 268 static void gradient_parentrelative(RrAppearance *a, gint w, gint h)
 269 {
 270     RrPixel32 *source, *dest;
 271     gint sw, sh, partial_w, partial_h, i;
 272
 273     g_assert (a->surface.parent);
 274     g_assert (a->surface.parent->w);
 275
 276     sw = a->surface.parent->w;
 277     sh = a->surface.parent->h;
 278
 279     /* This is a little hack. When a texture is parentrelative, and the same
 280        area as the parent, and has a bevel, it will draw its bevel on top
 281        of the parent's, amplifying it. So instead, rerender the child with
 282        the parent's settings, but the child's bevel and interlace */
 283     if (a->surface.relief != RR_RELIEF_FLAT &&
 284         (a->surface.parent->surface.relief != RR_RELIEF_FLAT ||
 285          a->surface.parent->surface.border) &&
 286         !a->surface.parentx && !a->surface.parenty &&
 287         sw == w && sh == h)
 288     {
 289         RrSurface old = a->surface;
 290         a->surface = a->surface.parent->surface;
 291
 292         /* turn these off for the parent */
 293         a->surface.relief = RR_RELIEF_FLAT;
 294         a->surface.border = FALSE;
 295
 296         a->surface.pixel_data = old.pixel_data;
 297
 298         RrRender(a, w, h);
 299         a->surface = old;
 300     } else {
 301         source = (a->surface.parent->surface.pixel_data +
 302                   a->surface.parentx + sw * a->surface.parenty);
 303         dest = a->surface.pixel_data;
 304
 305         if (a->surface.parentx + w > sw) {
 306             partial_w = sw - a->surface.parentx;
 307         } else partial_w = w;
 308
 309         if (a->surface.parenty + h > sh) {
 310             partial_h = sh - a->surface.parenty;
 311         } else partial_h = h;
 312
 313         for (i = 0; i < partial_h; i++, source += sw, dest += w) {
 314             memcpy(dest, source, partial_w * sizeof(RrPixel32));
 315         }
 316     }
 317 }
 318
 319 static void gradient_solid(RrAppearance *l, gint w, gint h)
 320 {
 321     gint i;
 322     RrPixel32 pix;
 323     RrPixel32 *data = l->surface.pixel_data;
 324     RrSurface *sp = &l->surface;
 325     gint left = 0, top = 0, right = w - 1, bottom = h - 1;
 326
 327     pix = (sp->primary->r << RrDefaultRedOffset)
 328         + (sp->primary->g << RrDefaultGreenOffset)
 329         + (sp->primary->b << RrDefaultBlueOffset);
 330
 331     for (i = 0; i < w * h; i++)
 332         *data++ = pix;
 333
 334     if (sp->interlaced)
 335         return;
 336
 337     XFillRectangle(RrDisplay(l->inst), l->pixmap, RrColorGC(sp->primary),
 338                    0, 0, w, h);
 339
 340     switch (sp->relief) {
 341     case RR_RELIEF_RAISED:
 342         if (!sp->bevel_dark)
 343             create_bevel_colors(l);
 344
 345         switch (sp->bevel) {
 346         case RR_BEVEL_1:
 347             XDrawLine(RrDisplay(l->inst), l->pixmap, RrColorGC(sp->bevel_dark),
 348                       left, bottom, right, bottom);
 349             XDrawLine(RrDisplay(l->inst), l->pixmap, RrColorGC(sp->bevel_dark),
 350                       right, bottom, right, top);
 351
 352             XDrawLine(RrDisplay(l->inst), l->pixmap,RrColorGC(sp->bevel_light),
 353                       left, top, right, top);
 354             XDrawLine(RrDisplay(l->inst), l->pixmap,RrColorGC(sp->bevel_light),
 355                       left, bottom, left, top);
 356             break;
 357         case RR_BEVEL_2:
 358             XDrawLine(RrDisplay(l->inst), l->pixmap, RrColorGC(sp->bevel_dark),
 359                       left + 2, bottom - 1, right - 2, bottom - 1);
 360             XDrawLine(RrDisplay(l->inst), l->pixmap, RrColorGC(sp->bevel_dark),
 361                       right - 1, bottom - 1, right - 1, top + 1);
 362
 363             XDrawLine(RrDisplay(l->inst), l->pixmap,RrColorGC(sp->bevel_light),
 364                       left + 2, top + 1, right - 2, top + 1);
 365             XDrawLine(RrDisplay(l->inst), l->pixmap,RrColorGC(sp->bevel_light),
 366                       left + 1, bottom - 1, left + 1, top + 1);
 367             break;
 368         default:
 369             g_assert_not_reached(); /* unhandled BevelType */
 370         }
 371         break;
 372     case RR_RELIEF_SUNKEN:
 373         if (!sp->bevel_dark)
 374             create_bevel_colors(l);
 375
 376         switch (sp->bevel) {
 377         case RR_BEVEL_1:
 378             XDrawLine(RrDisplay(l->inst), l->pixmap,RrColorGC(sp->bevel_light),
 379                       left, bottom, right, bottom);
 380             XDrawLine(RrDisplay(l->inst), l->pixmap,RrColorGC(sp->bevel_light),
 381                       right, bottom, right, top);
 382
 383             XDrawLine(RrDisplay(l->inst), l->pixmap, RrColorGC(sp->bevel_dark),
 384                       left, top, right, top);
 385             XDrawLine(RrDisplay(l->inst), l->pixmap, RrColorGC(sp->bevel_dark),
 386                       left, bottom, left, top);
 387             break;
 388         case RR_BEVEL_2:
 389             XDrawLine(RrDisplay(l->inst), l->pixmap,RrColorGC(sp->bevel_light),
 390                       left + 2, bottom - 1, right - 2, bottom - 1);
 391             XDrawLine(RrDisplay(l->inst), l->pixmap,RrColorGC(sp->bevel_light),
 392                       right - 1, bottom - 1, right - 1, top + 1);
 393
 394             XDrawLine(RrDisplay(l->inst), l->pixmap, RrColorGC(sp->bevel_dark),
 395                       left + 2, top + 1, right - 2, top + 1);
 396             XDrawLine(RrDisplay(l->inst), l->pixmap, RrColorGC(sp->bevel_dark),
 397                       left + 1, bottom - 1, left + 1, top + 1);
 398             break;
 399         default:
 400             g_assert_not_reached(); /* unhandled BevelType */
 401         }
 402         break;
 403     case RR_RELIEF_FLAT:
 404         if (sp->border) {
 405             XDrawRectangle(RrDisplay(l->inst), l->pixmap,
 406                            RrColorGC(sp->border_color),
 407                            left, top, right, bottom);
 408         }
 409         break;
 410     default:
 411         g_assert_not_reached(); /* unhandled ReliefType */
 412     }
 413 }
 414
 415 /* * * * * * * * * * * * * * GRADIENT MAGIC WOOT * * * * * * * * * * * * * * */
 416
 417 #define VARS(x)                                                     \
 418     guint color##x[3];                                       \
 419     gint len##x, cdelta##x[3], error##x[3] = { 0, 0, 0 }, inc##x[3]; \
 420     gboolean bigslope##x[3] /* color slope > 1 */
 421
 422 #define SETUP(x, from, to, w)         \
 423     len##x = w;                       \
 424                                       \
 425     color##x[0] = from->r;            \
 426     color##x[1] = from->g;            \
 427     color##x[2] = from->b;            \
 428                                       \
 429     cdelta##x[0] = to->r - from->r;   \
 430     cdelta##x[1] = to->g - from->g;   \
 431     cdelta##x[2] = to->b - from->b;   \
 432                                       \
 433     if (cdelta##x[0] < 0) {           \
 434         cdelta##x[0] = -cdelta##x[0]; \
 435         inc##x[0] = -1;               \
 436     } else                            \
 437         inc##x[0] = 1;                \
 438     if (cdelta##x[1] < 0) {           \
 439         cdelta##x[1] = -cdelta##x[1]; \
 440         inc##x[1] = -1;               \
 441     } else                            \
 442         inc##x[1] = 1;                \
 443     if (cdelta##x[2] < 0) {           \
 444         cdelta##x[2] = -cdelta##x[2]; \
 445         inc##x[2] = -1;               \
 446     } else                            \
 447         inc##x[2] = 1;                \
 448     bigslope##x[0] = cdelta##x[0] > w;\
 449     bigslope##x[1] = cdelta##x[1] > w;\
 450     bigslope##x[2] = cdelta##x[2] > w
 451
 452 #define COLOR_RR(x, c)                       \
 453     c->r = color##x[0];                      \
 454     c->g = color##x[1];                      \
 455     c->b = color##x[2]
 456
 457 #define COLOR(x)                             \
 458     ((color##x[0] << RrDefaultRedOffset) +   \
 459      (color##x[1] << RrDefaultGreenOffset) + \
 460      (color##x[2] << RrDefaultBlueOffset))
 461
 462 #define INCREMENT(x, i) \
 463     (inc##x[i])
 464
 465 #define NEXT(x)                                           \
 466 {                                                         \
 467     gint i;                                                \
 468     for (i = 2; i >= 0; --i) {                            \
 469         if (!cdelta##x[i]) continue;                      \
 470                                                           \
 471         if (!bigslope##x[i]) {                            \
 472             /* Y (color) is dependant on X */             \
 473             error##x[i] += cdelta##x[i];                  \
 474             if ((error##x[i] << 1) >= len##x) {           \
 475                 color##x[i] += INCREMENT(x, i);           \
 476                 error##x[i] -= len##x;                    \
 477             }                                             \
 478         } else {                                          \
 479             /* X is dependant on Y (color) */             \
 480             while (1) {                                   \
 481                 color##x[i] += INCREMENT(x, i);           \
 482                 error##x[i] += len##x;                    \
 483                 if ((error##x[i] << 1) >= cdelta##x[i]) { \
 484                     error##x[i] -= cdelta##x[i];          \
 485                     break;                                \
 486                 }                                         \
 487             }                                             \
 488         }                                                 \
 489     }                                                     \
 490 }
 491
 492 static void gradient_splitvertical(RrAppearance *a, gint w, gint h)
 493 {
 494     gint y1, y2, y3;
 495     RrSurface *sf = &a->surface;
 496     RrPixel32 *data;
 497     gint y1sz, y2sz, y3sz;
 498
 499     VARS(y1);
 500     VARS(y2);
 501     VARS(y3);
 502
 503     /* if h <= 5, then a 0 or 1px middle gradient.
 504        if h > 5, then always a 1px middle gradient.
 505     */
 506     if (h <= 5) {
 507         y1sz = MAX(h/2, 0);
 508         y2sz = (h < 3 ? 0 : h % 2);
 509         y3sz = MAX(h/2, 1);
 510     }
 511     else {
 512         y1sz = h/2 - (1 - (h % 2));
 513         y2sz = 1;
 514         y3sz = h/2;
 515     }
 516
 517     SETUP(y1, sf->split_primary, sf->primary, y1sz);
 518     if (y2sz) {
 519         /* setup to get the colors _in between_ these other 2 */
 520         SETUP(y2, sf->primary, sf->secondary, y2sz + 2);
 521         NEXT(y2); /* skip the first one, its the same as the last of y1 */
 522     }
 523     SETUP(y3, sf->secondary, sf->split_secondary,  y3sz);
 524
 525     /* find the color for the first pixel of each row first */
 526     data = sf->pixel_data;
 527
 528     for (y1 = y1sz-1; y1 > 0; --y1) {
 529         *data = COLOR(y1);
 530         data += w;
 531         NEXT(y1);
 532     }
 533     *data = COLOR(y1);
 534     data += w;
 535     for (y2 = y2sz-1; y2 > 0; --y2) {
 536         *data = COLOR(y2);
 537         data += w;
 538         NEXT(y2);
 539     }
 540     *data = COLOR(y2);
 541     data += w;
 542     for (y3 = y3sz-1; y3 > 0; --y3) {
 543         *data = COLOR(y3);
 544         data += w;
 545         NEXT(y3);
 546     }
 547     *data = COLOR(y3);
 548
 549     /* copy the first pixels into the whole rows */
 550     data = sf->pixel_data;
 551     for (y1 = h; y1 > 0; --y1) {
 552         repeat_pixel(data, w);
 553         data += w;
 554     }
 555 }
 556
 557 static void gradient_horizontal(RrSurface *sf, gint w, gint h)
 558 {
 559     gint x, y, cpbytes;
 560     RrPixel32 *data = sf->pixel_data, *datav;
 561     gchar *datac;
 562
 563     VARS(x);
 564     SETUP(x, sf->primary, sf->secondary, w);
 565
 566     /* set the color values for the first row */
 567     datav = data;
 568     for (x = w - 1; x > 0; --x) {  /* 0 -> w - 1 */
 569         *datav = COLOR(x);
 570         ++datav;
 571         NEXT(x);
 572     }
 573     *datav = COLOR(x);
 574     ++datav;
 575
 576     /* copy the first row to the rest in O(logn) copies */
 577     datac = (gchar*)datav;
 578     cpbytes = 1 * w * sizeof(RrPixel32);
 579     for (y = (h - 1) * w * sizeof(RrPixel32); y > 0;) {
 580         memcpy(datac, data, cpbytes);
 581         y -= cpbytes;
 582         datac += cpbytes;
 583         cpbytes <<= 1;
 584         if (cpbytes > y)
 585             cpbytes = y;
 586     }
 587 }
 588
 589 static void gradient_mirrorhorizontal(RrSurface *sf, gint w, gint h)
 590 {
 591     gint x, y, half1, half2, cpbytes;
 592     RrPixel32 *data = sf->pixel_data, *datav;
 593     gchar *datac;
 594
 595     VARS(x);
 596
 597     half1 = (w + 1) / 2;
 598     half2 = w / 2;
 599
 600     /* set the color values for the first row */
 601
 602     SETUP(x, sf->primary, sf->secondary, half1);
 603     datav = data;
 604     for (x = half1 - 1; x > 0; --x) {  /* 0 -> half1 - 1 */
 605         *datav = COLOR(x);
 606         ++datav;
 607         NEXT(x);
 608     }
 609     *datav = COLOR(x);
 610     ++datav;
 611
 612     if (half2 > 0) {
 613         SETUP(x, sf->secondary, sf->primary, half2);
 614         for (x = half2 - 1; x > 0; --x) {  /* 0 -> half2 - 1 */
 615             *datav = COLOR(x);
 616             ++datav;
 617             NEXT(x);
 618         }
 619         *datav = COLOR(x);
 620         ++datav;
 621     }
 622
 623     /* copy the first row to the rest in O(logn) copies */
 624     datac = (gchar*)datav;
 625     cpbytes = 1 * w * sizeof(RrPixel32);
 626     for (y = (h - 1) * w * sizeof(RrPixel32); y > 0;) {
 627         memcpy(datac, data, cpbytes);
 628         y -= cpbytes;
 629         datac += cpbytes;
 630         cpbytes <<= 1;
 631         if (cpbytes > y)
 632             cpbytes = y;
 633     }
 634 }
 635
 636 static void gradient_vertical(RrSurface *sf, gint w, gint h)
 637 {
 638     gint y;
 639     RrPixel32 *data;
 640
 641     VARS(y);
 642     SETUP(y, sf->primary, sf->secondary, h);
 643
 644     /* find the color for the first pixel of each row first */
 645     data = sf->pixel_data;
 646
 647     for (y = h - 1; y > 0; --y) {  /* 0 -> h-1 */
 648         *data = COLOR(y);
 649         data += w;
 650         NEXT(y);
 651     }
 652     *data = COLOR(y);
 653
 654     /* copy the first pixels into the whole rows */
 655     data = sf->pixel_data;
 656     for (y = h; y > 0; --y) {
 657         repeat_pixel(data, w);
 658         data += w;
 659     }
 660 }
 661
 662
 663 static void gradient_diagonal(RrSurface *sf, gint w, gint h)
 664 {
 665     gint x, y;
 666     RrPixel32 *data = sf->pixel_data;
 667     RrColor left, right;
 668     RrColor extracorner;
 669
 670     VARS(lefty);
 671     VARS(righty);
 672     VARS(x);
 673
 674     extracorner.r = (sf->primary->r + sf->secondary->r) / 2;
 675     extracorner.g = (sf->primary->g + sf->secondary->g) / 2;
 676     extracorner.b = (sf->primary->b + sf->secondary->b) / 2;
 677
 678     SETUP(lefty, sf->primary, (&extracorner), h);
 679     SETUP(righty, (&extracorner), sf->secondary, h);
 680
 681     for (y = h - 1; y > 0; --y) {  /* 0 -> h-1 */
 682         COLOR_RR(lefty, (&left));
 683         COLOR_RR(righty, (&right));
 684
 685         SETUP(x, (&left), (&right), w);
 686
 687         for (x = w - 1; x > 0; --x) {  /* 0 -> w-1 */
 688             *(data++) = COLOR(x);
 689
 690             NEXT(x);
 691         }
 692         *(data++) = COLOR(x);
 693
 694         NEXT(lefty);
 695         NEXT(righty);
 696     }
 697     COLOR_RR(lefty, (&left));
 698     COLOR_RR(righty, (&right));
 699
 700     SETUP(x, (&left), (&right), w);
 701
 702     for (x = w - 1; x > 0; --x) {  /* 0 -> w-1 */
 703         *(data++) = COLOR(x);
 704
 705         NEXT(x);
 706     }
 707     *data = COLOR(x);
 708 }
 709
 710 static void gradient_crossdiagonal(RrSurface *sf, gint w, gint h)
 711 {
 712     gint x, y;
 713     RrPixel32 *data = sf->pixel_data;
 714     RrColor left, right;
 715     RrColor extracorner;
 716
 717     VARS(lefty);
 718     VARS(righty);
 719     VARS(x);
 720
 721     extracorner.r = (sf->primary->r + sf->secondary->r) / 2;
 722     extracorner.g = (sf->primary->g + sf->secondary->g) / 2;
 723     extracorner.b = (sf->primary->b + sf->secondary->b) / 2;
 724
 725     SETUP(lefty, (&extracorner), sf->secondary, h);
 726     SETUP(righty, sf->primary, (&extracorner), h);
 727
 728     for (y = h - 1; y > 0; --y) {  /* 0 -> h-1 */
 729         COLOR_RR(lefty, (&left));
 730         COLOR_RR(righty, (&right));
 731
 732         SETUP(x, (&left), (&right), w);
 733
 734         for (x = w - 1; x > 0; --x) {  /* 0 -> w-1 */
 735             *(data++) = COLOR(x);
 736
 737             NEXT(x);
 738         }
 739         *(data++) = COLOR(x);
 740
 741         NEXT(lefty);
 742         NEXT(righty);
 743     }
 744     COLOR_RR(lefty, (&left));
 745     COLOR_RR(righty, (&right));
 746
 747     SETUP(x, (&left), (&right), w);
 748
 749     for (x = w - 1; x > 0; --x) {  /* 0 -> w-1 */
 750         *(data++) = COLOR(x);
 751
 752         NEXT(x);
 753     }
 754     *data = COLOR(x);
 755 }
 756
 757 static void gradient_pyramid(RrSurface *sf, gint w, gint h)
 758 {
 759     RrPixel32 *ldata, *rdata;
 760     RrPixel32 *cp;
 761     RrColor left, right;
 762     RrColor extracorner;
 763     gint x, y, halfw, halfh, midx, midy;
 764
 765     VARS(lefty);
 766     VARS(righty);
 767     VARS(x);
 768
 769     extracorner.r = (sf->primary->r + sf->secondary->r) / 2;
 770     extracorner.g = (sf->primary->g + sf->secondary->g) / 2;
 771     extracorner.b = (sf->primary->b + sf->secondary->b) / 2;
 772
 773     halfw = w >> 1;
 774     halfh = h >> 1;
 775     midx = w - halfw - halfw; /* 0 or 1, depending if w is even or odd */
 776     midy = h - halfh - halfh;   /* 0 or 1, depending if h is even or odd */
 777
 778     SETUP(lefty, sf->primary, (&extracorner), halfh + midy);
 779     SETUP(righty, (&extracorner), sf->secondary, halfh + midy);
 780
 781     /* draw the top half
 782
 783        it is faster to draw both top quarters together than to draw one and
 784        then copy it over to the other side.
 785     */
 786
 787     ldata = sf->pixel_data;
 788     rdata = ldata + w - 1;
 789     for (y = halfh + midy; y > 0; --y) {  /* 0 -> (h+1)/2 */
 790         RrPixel32 c;
 791
 792         COLOR_RR(lefty, (&left));
 793         COLOR_RR(righty, (&right));
 794
 795         SETUP(x, (&left), (&right), halfw + midx);
 796
 797         for (x = halfw + midx - 1; x > 0; --x) {  /* 0 -> (w+1)/2 */
 798             c = COLOR(x);
 799             *(ldata++) = *(rdata--) = c;
 800
 801             NEXT(x);
 802         }
 803         c = COLOR(x);
 804         *ldata = *rdata = c;
 805         ldata += halfw + 1;
 806         rdata += halfw - 1 + midx + w;
 807
 808         NEXT(lefty);
 809         NEXT(righty);
 810     }
 811
 812     /* copy the top half into the bottom half, mirroring it, so we can only
 813        copy one row at a time
 814
 815        it is faster, to move the writing pointer forward, and the reading
 816        pointer backward
 817
 818        this is the current code, moving the write pointer forward and read
 819        pointer backward
 820        41.78      4.26     1.78      504     3.53     3.53  gradient_pyramid2
 821        this is the opposite, moving the read pointer forward and the write
 822        pointer backward
 823        42.27      4.40     1.86      504     3.69     3.69  gradient_pyramid2
 824
 825     */
 826     ldata = sf->pixel_data + (halfh - 1) * w;
 827     cp = ldata + (midy + 1) * w;
 828     for (y = halfh; y > 0; --y) {
 829         memcpy(cp, ldata, w * sizeof(RrPixel32));
 830         ldata -= w;
 831         cp += w;
 832     }
 833 }