fblin1.c

mini gui 1.6.8 lib and source

    if (s_head == d_head) {
        if (d_head) {
            if (d_head + w > 8) {
                *dst = (*src & right_side_mask [d_head]) | (*dst & left_side_mask [d_head]);
                src ++; dst ++;
                w -= 8 - d_head;
            }
            else {
                gal_uint8 mask = left_ban_mask [w] << d_head;
                *dst = (*src & mask) | (*dst & ~mask);
                return;
            }
        }

        while (w > 7) {
            *dst++ = *src++;
            w -= 8;
        }

        if (w) {
            *dst = (*src & left_side_mask [w]) | (*dst & (right_side_mask [w]));
        }
    }
    else if (d_head > s_head) {

        int shift = d_head - s_head;
        gal_uint8 sl_half = *src << shift;
        gal_uint8 sr_half;
        gal_uint8 sb_new;

        if (d_head + w > 8) {
            *dst = (sl_half & right_side_mask [d_head]) | (*dst & left_side_mask [d_head]);
            dst++;
            w -= 8 - d_head;
        }
        else {
            gal_uint8 mask = left_ban_mask [w] << d_head;
            *dst = (sl_half & mask) | (*dst & ~mask);
            return;
        }

        sr_half = *src & right_ban_mask [shift];
        while (w > 7) {
            src++;
            sl_half = *src << shift;
            sb_new = sl_half | (sr_half >> (8 - shift));
            sr_half = *src & right_ban_mask [shift];

            *dst = sb_new;
            dst++; 
            w -= 8;
        }

        if (w) {
            sr_half = *src & right_ban_mask [shift];
            if (w > shift) {
                src++;
                sl_half = *src << shift;
                sb_new = sl_half | (sr_half >> (8 - shift));
            }
            else
                sb_new = (sr_half >> (8 - shift));

            *dst = (sb_new & left_side_mask [w]) | (*dst & right_side_mask[w]);
        }
    }
    else /* s_head > d_head */
    {
        int shift = s_head - d_head;

        gal_uint8 sl_half = *src >> shift;
        gal_uint8 sr_half;
        gal_uint8 sb_new;

        if (s_head + w > 8) {
            sr_half = *(src + 1) & (left_ban_mask [shift]);
            sb_new = sl_half | (sr_half << (8 - shift));
        }
        else
            sb_new = sl_half;

        if (d_head) {
            if (d_head + w > 8) {
                *dst = (sb_new & right_side_mask [d_head]) | (*dst & left_side_mask [d_head]);
                dst++; src++;
                w -= 8 - d_head;
            }
            else {
                gal_uint8 mask = left_ban_mask [w] << d_head;
                *dst = (sb_new & mask) | (*dst & ~mask);
                return;
            }
        }

        while (w > 7) {
            sl_half = *src >> shift;
            sr_half = *(++src) & (left_ban_mask [shift]);
            sb_new = sl_half | (sr_half << (8 - shift));

            *dst = sb_new;
            dst++; 
            w -= 8;
        }

        if (w) {
            sl_half = *src >> shift;
            if (w > 8 - shift) {
                sr_half = *(++src) & (left_ban_mask [shift]);
                sb_new = sl_half | (sr_half << (8 - shift));
            }
            else
                sb_new = sl_half;

            *dst = (sb_new & left_side_mask [w]) | (*dst & right_side_mask[w]);
        }
    }
}

#if 0

/* copy line from right to left, used when dst and src overlap */
static void fblin1_copyline_rl (gal_uint8 *src, int x1, gal_uint8 *dst, int x2, int w)
{
    int s_tail = (x1 + w - 1) & 7;
    int d_tail = (x2 + w - 1) & 7;

    if (s_tail == d_tail) {
        if (d_tail) {
            if (w > d_tail) {
                *dst = (*src & left_side_mask [d_tail]) | (*dst & right_side_mask [d_tail]);
                src --; dst --;
                w -= d_tail;
            }
            else {
                gal_uint8 mask = right_ban_mask [w] >> (8 - d_tail);
                *dst = (*src & mask) | (*dst & ~mask);
                return;
            }
        }

        while (w > 7) {
            *dst-- = *src--;
            w -= 8;
        }

        if (w)
            *dst = (*src & right_side_mask [w]) | (*dst & left_side_mask [w]);
    }
    else if (s_tail > d_tail) {

        int shift = s_tail - d_tail;
        gal_uint8 sr_half = *src >> shift;
        gal_uint8 sl_half;
        gal_uint8 sb_new;
        
        if (w > d_tail) {
            *dst = (sr_half & left_side_mask [d_tail]) | (*dst & right_side_mask [d_tail]);
            dst--;
            w -= d_tail;
        }
        else {
            gal_uint8 mask = right_ban_mask [w] >> (8 - d_tail);
            *dst = (sr_half & mask) | (*dst & ~mask);
            return;
        }

        sl_half = *src & left_ban_mask [shift];
        while (w > 7) {
            src--;
            sr_half = *src >> shift;
            sb_new = sr_half | (sl_half << (8 - shift));
            sl_half = *src & left_ban_mask [shift];

            *dst = sb_new; dst--;
            w -= 8;
        }

        if (w) {
            src--;
            sr_half = *src >> shift;
            sb_new = sr_half | (sl_half << (8 - shift));

            *dst = (sb_new & right_side_mask [w]) | (*dst & left_side_mask[w]);
        }
    }
    else /* d_tail > s_tail */
    {
        int shift = d_tail - s_tail;

        gal_uint8 sr_half = *src << shift;
        gal_uint8 sl_half;
        gal_uint8 sb_new;

        if (w > s_tail) {
            sl_half = *(src - 1) & (right_ban_mask [shift]);
            sb_new = sr_half | (sl_half >> (8 - shift));
        }
        else
            sb_new = sr_half;

        if (w > d_tail) {
            *dst = (sb_new & left_side_mask [d_tail]) | (*dst & right_side_mask [d_tail]);
            dst--; src--;
            w -= d_tail;
        }
        else {
            gal_uint8 mask = right_ban_mask [w] >> (8 - d_tail);
            *dst = (sb_new & mask) | (*dst & ~mask);
            return;
        }

        while (w > 7) {
            sr_half = *src << shift;
            sl_half = *(--src) & (right_ban_mask [shift]);
            sb_new = sr_half | (sl_half >> (8 - shift));

            *dst = sb_new;
            dst--;
            w -= 8;
        }

        if (w) {
            sr_half = *src << shift;
            if (w > 8 - shift) {
                sl_half = *(--src) & (right_ban_mask [shift]);
                sb_new = sr_half | (sl_half >> (8 - shift));
            }
            else
                sb_new = sr_half;

            *dst = (sb_new & right_side_mask [w]) | (*dst & left_side_mask[w]);
        }
    }
}

#endif

static void fblin1_copybox (PSD psd, int x1, int y1, int w, int h, int x2, int y2)
{
    register gal_uint8 *src, *dst;
    register int linelen = psd->linelen;

    if (y1 == y2) {
        if (x1 < x2 && x1 + w > x2) {
#if 0
            src= psd->addr + y1 * linelen + ((x1 + w - 1)>> 3);
            dst= psd->addr + y2 * linelen + ((x2 + w - 1)>> 3);

            while (h) {
                fblin1_copyline_rl (src, x1, dst, x2, w);
                src += linelen;
                dst += linelen;
                h--;
            }
#else
            //gal_uint8 *tmp = alloca (w >> 3);
            gal_uint8 *tmp = malloc (w >> 3);

            src= (gal_uint8 *)psd->addr + y1 * linelen + (x1 >> 3);
            dst= (gal_uint8 *)psd->addr + y2 * linelen + (x2 >> 3);

            while (h) {
                fblin1_copyline_lr (src, x1, tmp, 0, w);
                fblin1_copyline_lr (tmp, 0, dst, x2, w);
                src += linelen;
                dst += linelen;
                h--;
            }
            free (tmp);
#endif
        }
        else {
            src= (gal_uint8 *)psd->addr + y1 * linelen + (x1 >> 3);
            dst= (gal_uint8 *)psd->addr + y2 * linelen + (x2 >> 3);

            while (h) {
                fblin1_copyline_lr (src, x1, dst, x2, w);
                src += linelen;
                dst += linelen;
                h--;
            }
        }
    }
    else if (y1 < y2 && y1 + h >= y2) {
        y1 += (h-1);
        y2 += (h-1);

        src= (gal_uint8 *)psd->addr + y1 * linelen + (x1 >> 3);
        dst= (gal_uint8 *)psd->addr + y2 * linelen + (x2 >> 3);

        while (h) {
            fblin1_copyline_lr (src, x1, dst, x2, w);
            src -= linelen;
            dst -= linelen;
            h--;
        }
    }
    else {
        src= (gal_uint8 *)psd->addr + y1 * linelen + (x1 >> 3);
        dst= (gal_uint8 *)psd->addr + y2 * linelen + (x2 >> 3);

        while (h) {
            fblin1_copyline_lr (src, x1, dst, x2, w);
            src += linelen;
            dst += linelen;
            h--;
        }
    }
}

/* blit, no clipping */
static void fblin1_blit (PSD dstpsd, int dstx, int dsty, int w, int h,
    PSD srcpsd, int srcx, int srcy)
{
    gal_uint8* dst;
    gal_uint8* src;

    dst = get_pixel_address (dstpsd, dstx, dsty);
    src = get_pixel_address (srcpsd, srcx, srcy);

    while (h) {
        fblin1_copyline_lr (src, srcx, dst, dstx, w);
        src += srcpsd->linelen;
        dst += dstpsd->linelen;
        h--;
    }
}

SUBDRIVER fblinear1 = {
    fblin1_init,
    fblin1_drawpixel,
    fblin1_readpixel,
    fblin1_drawhline,
    fblin1_drawvline,
    fblin1_blit,
    fblin1_putbox,
    fblin1_getbox,
    fblin1_putboxmask,
    fblin1_copybox
};

#endif /* _FBLIN1R_SUPPORT */