bitmap.c File Reference

#include <config.h>
#include <stdlib.h>
#include "mdvi.h"
#include "color.h"

Include dependency graph for bitmap.c:

Go to the source code of this file.

Macros
#define	SHOW_OP_DATA   (DEBUGGING(BITMAP_OPS) && DEBUGGING(BITMAP_DATA))
#define	SEGMENT(m, n)   (bit_masks[m] << (n))

Functions
BITMAP *	bitmap_convert_lsb8 (Uchar *bits, int w, int h, int stride)
BITMAP *	bitmap_convert_msb8 (Uchar *data, int w, int h, int stride)
BITMAP *	bitmap_copy (BITMAP *bm)
BITMAP *	bitmap_alloc (int w, int h)
BITMAP *	bitmap_alloc_raw (int w, int h)
void	bitmap_destroy (BITMAP *bm)
void	bitmap_print (FILE *out, BITMAP *bm)
void	bitmap_set_col (BITMAP *bm, int row, int col, int count, int state)
void	bitmap_paint_bits (BmUnit *ptr, int n, int count)
void	bitmap_clear_bits (BmUnit *ptr, int n, int count)
void	bitmap_set_row (BITMAP *bm, int row, int col, int count, int state)
void	bitmap_flip_horizontally (BITMAP *bm)
void	bitmap_flip_vertically (BITMAP *bm)
void	bitmap_flip_diagonally (BITMAP *bm)
void	bitmap_rotate_clockwise (BITMAP *bm)
void	bitmap_rotate_counter_clockwise (BITMAP *bm)
void	bitmap_flip_rotate_clockwise (BITMAP *bm)
void	bitmap_flip_rotate_counter_clockwise (BITMAP *bm)
static int	do_sample (BmUnit *data, int stride, int step, int w, int h)
void	mdvi_shrink_box (DviContext *dvi, DviFont *font, DviFontChar *pk, DviGlyph *dest)
void	mdvi_shrink_glyph (DviContext *dvi, DviFont *font, DviFontChar *pk, DviGlyph *dest)
void	mdvi_shrink_glyph_grey (DviContext *dvi, DviFont *font, DviFontChar *pk, DviGlyph *dest)

Variables
static BmUnit	bit_masks []
static int	sample_count []
static Uchar	bit_swap []

Macro Definition Documentation

#define SEGMENT	(		m,
			n
	)		(bit_masks[m] << (n))

Definition at line 60 of file bitmap.c.

#define SHOW_OP_DATA   (DEBUGGING(BITMAP_OPS) && DEBUGGING(BITMAP_DATA))

Definition at line 48 of file bitmap.c.

Function Documentation

BITMAP* bitmap_alloc	(	int	w,
		int	h
	)

Definition at line 205 of file bitmap.c.

{
    BITMAP  *bm;
    
    bm = xalloc(BITMAP);
    bm->width = w;
    bm->height = h;
    bm->stride = BM_BYTES_PER_LINE(bm);
    if(h && bm->stride)
        bm->data = (BmUnit *)mdvi_calloc(h, bm->stride);
    else
        bm->data = NULL;
    
    return bm;
}

Here is the caller graph for this function:

BITMAP* bitmap_alloc_raw	(	int	w,
		int	h
	)

Definition at line 221 of file bitmap.c.

{
    BITMAP  *bm;
    
    bm = xalloc(BITMAP);
    bm->width = w;
    bm->height = h;
    bm->stride = BM_BYTES_PER_LINE(bm);
    if(h && bm->stride)
        bm->data = (BmUnit *)mdvi_malloc(h * bm->stride);
    else
        bm->data = NULL;
    
    return bm;
}

Here is the caller graph for this function:

void bitmap_clear_bits	(	BmUnit *	ptr,
		int	n,
		int	count
	)

Definition at line 344 of file bitmap.c.

{
    if(n + count > BITMAP_BITS) {
        *ptr &= ~SEGMENT(BITMAP_BITS - n, n);
        count -= BITMAP_BITS;
        ptr++;
    } else {
        *ptr &= ~SEGMENT(count, n);
        return;
    }

    for(; count >= BITMAP_BITS; count -= BITMAP_BITS)
        *ptr++ = 0;

    if(count > 0)
        *ptr &= ~SEGMENT(count, 0);
}

Here is the caller graph for this function:

BITMAP* bitmap_convert_lsb8	(	Uchar *	bits,
		int	w,
		int	h,
		int	stride
	)

Definition at line 128 of file bitmap.c.

{
    BITMAP  *bm;
    int i;
    Uchar   *unit;
    register Uchar *curr;
    int bytes;
    
    DEBUG((DBG_BITMAP_OPS, "convert LSB %dx%d@8 -> bitmap\n", w, h));   

    bm = bitmap_alloc_raw(w, h);

    /* this is the number of bytes in the original bitmap */
    bytes = ROUND(w, 8);
    unit  = (Uchar *)bm->data;
    curr = bits;
    /* we try to do this as fast as we can */   
    for(i = 0; i < h; i++) {
#ifdef WORD_LITTLE_ENDIAN
        memcpy(unit, curr, bytes);
        curr += stride;
#else
        int j;
        
        for(j = 0; j < bytes; curr++, j++)
            unit[j] = bit_swap[*curr];
        cur += stride - bytes;
#endif
        memzero(unit + bytes, bm->stride - bytes);
        unit  += bm->stride;
    }
    if(SHOW_OP_DATA)
        bitmap_print(stderr, bm);
    return bm;
}

BITMAP* bitmap_convert_msb8	(	Uchar *	data,
		int	w,
		int	h,
		int	stride
	)

Definition at line 164 of file bitmap.c.

{
    BITMAP  *bm;
    Uchar   *unit;
    Uchar   *curr;
    int i;
    int bytes;
    
    bm = bitmap_alloc(w, h);
    bytes = ROUND(w, 8);
    unit = (Uchar *)bm->data;
    curr = data;
    for(i = 0; i < h; i++) {
#ifdef WORD_LITTLE_ENDIAN
        int j;
        
        for(j = 0; j < bytes; curr++, j++)
            unit[j] = bit_swap[*curr];
        curr += stride - bytes;
#else
        memcpy(unit, curr, bytes);
        curr += stride;
#endif
        memzero(unit + bytes, bm->stride - bytes);
        unit += bm->stride;
    }
    if(SHOW_OP_DATA)
        bitmap_print(stderr, bm);
    return bm;
}

BITMAP* bitmap_copy

(

BITMAP *

bm)

Definition at line 196 of file bitmap.c.

{
    BITMAP  *nb = bitmap_alloc(bm->width, bm->height);

    DEBUG((DBG_BITMAP_OPS, "copy %dx%d\n", bm->width, bm->height)); 
    memcpy(nb->data, bm->data, bm->height * bm->stride);
    return nb;
}

void bitmap_destroy

(

BITMAP *

bm)

Definition at line 237 of file bitmap.c.

{
    if(bm->data)
        free(bm->data);
    free(bm);
}

Here is the caller graph for this function:

void bitmap_flip_diagonally

(

BITMAP *

bm)

Definition at line 467 of file bitmap.c.

{
    BITMAP  nb;
    BmUnit  *fptr, *tptr;
    BmUnit  fmask, tmask;
    int w, h;
    
    nb.width = bm->width;
    nb.height = bm->height;
    nb.stride = bm->stride;
    nb.data = mdvi_calloc(bm->height, bm->stride);
    
    fptr = bm->data;
    tptr = __bm_unit_ptr(&nb, nb.width-1, nb.height-1);
    for(h = 0; h < bm->height; h++) {
        BmUnit  *fline, *tline;
        
        fline = fptr; 
        tline = tptr;
        fmask = FIRSTMASK;
        tmask = FIRSTMASKAT(nb.width-1);
        for(w = 0; w < bm->width; w++) {
            if(*fline & fmask)
                *tline |= tmask;
            if(fmask == LASTMASK) {
                fmask = FIRSTMASK;
                fline++;
            } else
                NEXTMASK(fmask);
            if(tmask == FIRSTMASK) {
                tmask = LASTMASK;
                tline--;
            } else
                PREVMASK(tmask);
        }
        fptr = bm_offset(fptr, bm->stride);
        tptr = bm_offset(tptr, -nb.stride);
    }
    DEBUG((DBG_BITMAP_OPS, "flip_diagonally (%d,%d) -> (%d,%d)\n",
        bm->width, bm->height, nb.width, nb.height));
    mdvi_free(bm->data);
    bm->data = nb.data;
    if(SHOW_OP_DATA)
        bitmap_print(stderr, bm);
}

Here is the caller graph for this function:

void bitmap_flip_horizontally

(

BITMAP *

bm)

Definition at line 380 of file bitmap.c.

{
    BITMAP  nb;
    BmUnit  *fptr, *tptr;
    BmUnit  fmask, tmask;
    int w, h;

    nb.width = bm->width;
    nb.height = bm->height;
    nb.stride = bm->stride;
    nb.data = mdvi_calloc(bm->height, bm->stride);
        
    fptr = bm->data;
    tptr = __bm_unit_ptr(&nb, nb.width-1, 0);
    for(h = 0; h < bm->height; h++) {
        BmUnit  *fline, *tline;
        
        fline = fptr; 
        tline = tptr;
        fmask = FIRSTMASK;
        tmask = FIRSTMASKAT(nb.width-1);
        for(w = 0; w < bm->width; w++) {
            if(*fline & fmask)
                *tline |= tmask;
            if(fmask == LASTMASK) {
                fmask = FIRSTMASK;
                fline++;
            } else
                NEXTMASK(fmask);
            if(tmask == FIRSTMASK) {
                tmask = LASTMASK;
                tline--;
            } else
                PREVMASK(tmask);
        }
        fptr = bm_offset(fptr, bm->stride);
        tptr = bm_offset(tptr, bm->stride);
    }
    DEBUG((DBG_BITMAP_OPS, "flip_horizontally (%d,%d) -> (%d,%d)\n",
        bm->width, bm->height, nb.width, nb.height));
    mdvi_free(bm->data);
    bm->data = nb.data;
    if(SHOW_OP_DATA)
        bitmap_print(stderr, bm);
}

Here is the caller graph for this function:

void bitmap_flip_rotate_clockwise

(

BITMAP *

bm)

Definition at line 617 of file bitmap.c.

{
    BITMAP  nb;
    BmUnit  *fptr, *tptr;
    BmUnit  fmask, tmask;
    int w, h;
    
    nb.width = bm->height;
    nb.height = bm->width;
    nb.stride = BM_BYTES_PER_LINE(&nb);
    nb.data = mdvi_calloc(nb.height, nb.stride);
    
    fptr = bm->data;
    tptr = __bm_unit_ptr(&nb, nb.width-1, nb.height-1);

    tmask = FIRSTMASKAT(nb.width-1);    
    for(h = 0; h < bm->height; h++) {
        BmUnit  *fline, *tline;

        fmask = FIRSTMASK;
        fline = fptr;
        tline = tptr;
        for(w = 0; w < bm->width; w++) {
            if(*fline & fmask)
                *tline |= tmask;
            if(fmask == LASTMASK) {
                fmask = FIRSTMASK;
                fline++;
            } else
                NEXTMASK(fmask);
            /* go to previous line */
            tline = bm_offset(tline, -nb.stride);
        }
        fptr = bm_offset(fptr, bm->stride);
        if(tmask == FIRSTMASK) {
            tmask = LASTMASK;
            tptr--;
        } else
            PREVMASK(tmask);
    }
    DEBUG((DBG_BITMAP_OPS, "flip_rotate_clockwise (%d,%d) -> (%d,%d)\n",
        bm->width, bm->height, nb.width, nb.height));
    mdvi_free(bm->data);
    bm->data = nb.data;
    bm->width = nb.width;
    bm->height = nb.height; 
    bm->stride = nb.stride;
    if(SHOW_OP_DATA)
        bitmap_print(stderr, bm);
}

Here is the caller graph for this function:

void bitmap_flip_rotate_counter_clockwise

(

BITMAP *

bm)

Definition at line 668 of file bitmap.c.

{
    BITMAP  nb;
    BmUnit  *fptr, *tptr;
    BmUnit  fmask, tmask;
    int w, h;
    
    nb.width = bm->height;
    nb.height = bm->width;
    nb.stride = BM_BYTES_PER_LINE(&nb);
    nb.data = mdvi_calloc(nb.height, nb.stride);
    
    fptr = bm->data;
    tptr = nb.data;
    tmask = FIRSTMASK;
    
    for(h = 0; h < bm->height; h++) {
        BmUnit  *fline, *tline;

        fmask = FIRSTMASK;
        fline = fptr;
        tline = tptr;
        for(w = 0; w < bm->width; w++) {
            if(*fline & fmask)
                *tline |= tmask;
            if(fmask == LASTMASK) {
                fmask = FIRSTMASK;
                fline++;
            } else
                NEXTMASK(fmask);
            /* go to next line */
            tline = bm_offset(tline, nb.stride);
        }
        fptr = bm_offset(fptr, bm->stride);
        if(tmask == LASTMASK) {
            tmask = FIRSTMASK;
            tptr++;
        } else
            NEXTMASK(tmask);
    }

    DEBUG((DBG_BITMAP_OPS, "flip_rotate_counter_clockwise (%d,%d) -> (%d,%d)\n",
        bm->width, bm->height, nb.width, nb.height));
    mdvi_free(bm->data);
    bm->data = nb.data;
    bm->width = nb.width;
    bm->height = nb.height; 
    bm->stride = nb.stride;
    if(SHOW_OP_DATA)
        bitmap_print(stderr, bm);
}

Here is the caller graph for this function:

void bitmap_flip_vertically

(

BITMAP *

bm)

Definition at line 426 of file bitmap.c.

{
    BITMAP  nb;
    BmUnit  *fptr, *tptr;
    BmUnit  fmask;
    int w, h;

    nb.width = bm->width;
    nb.height = bm->height;
    nb.stride = bm->stride;
    nb.data = mdvi_calloc(bm->height, bm->stride);
    
    fptr = bm->data;
    tptr = __bm_unit_ptr(&nb, 0, nb.height-1);
    for(h = 0; h < bm->height; h++) {
        BmUnit  *fline, *tline;
        
        fline = fptr; 
        tline = tptr;
        fmask = FIRSTMASK;
        for(w = 0; w < bm->width; w++) {
            if(*fline & fmask)
                *tline |= fmask;
            if(fmask == LASTMASK) {
                fmask = FIRSTMASK;
                fline++;
                tline++;
            } else
                NEXTMASK(fmask);
        }
        fptr = bm_offset(fptr, bm->stride);
        tptr = (BmUnit *)((char *)tptr - bm->stride);
    }
    DEBUG((DBG_BITMAP_OPS, "flip_vertically (%d,%d) -> (%d,%d)\n",
        bm->width, bm->height, nb.width, nb.height));
    mdvi_free(bm->data);
    bm->data = nb.data;
    if(SHOW_OP_DATA)
        bitmap_print(stderr, bm);
}

Here is the caller graph for this function:

void bitmap_paint_bits	(	BmUnit *	ptr,
		int	n,
		int	count
	)

Definition at line 319 of file bitmap.c.

{
    /* paint the head */
    if(n + count > BITMAP_BITS) {
        *ptr |= SEGMENT(BITMAP_BITS - n, n);
        count -= BITMAP_BITS - n;
        ptr++;
    } else {
        *ptr |= SEGMENT(count, n);
        return;
    }

    /* paint the middle */
    for(; count >= BITMAP_BITS; count -= BITMAP_BITS)
        *ptr++ = bit_masks[BITMAP_BITS];

    /* paint the tail */
    if(count > 0) 
        *ptr |= SEGMENT(count, 0);
}

Here is the caller graph for this function:

void bitmap_print	(	FILE *	out,
		BITMAP *	bm
	)

Definition at line 244 of file bitmap.c.

{
    int i, j;
    BmUnit  *a, mask;
    static const char labels[] = {
        '1', '2', '3', '4', '5', '6', '7', '8', '9', '0'
    };
    int sub;

    a = bm->data;   
    fprintf(out, "    ");
    if(bm->width > 10) {
        putchar('0');
        sub = 0;
        for(j = 2; j <= bm->width; j++)
            if((j %10) == 0) {
                if((j % 100) == 0) {
                    fprintf(out, "*");
                    sub += 100;
                } else
                    fprintf(out, "%d", (j - sub)/10);
            } else
                putc(' ', out);
        fprintf(out, "\n    ");
    }
    for(j = 0; j < bm->width; j++)
        putc(labels[j % 10], out);
    putchar('\n');
    for(i = 0; i < bm->height; i++) {
        mask = FIRSTMASK;
        a = (BmUnit *)((char *)bm->data + i * bm->stride);
        fprintf(out, "%3d ", i+1);
        for(j = 0; j < bm->width; j++) {
            if(*a & mask)
                putc('#', out);
            else
                putc('.', out);
            if(mask == LASTMASK) {
                a++;
                mask = FIRSTMASK;
            } else
                NEXTMASK(mask);
        }
        putchar('\n');
    }
}

Here is the caller graph for this function:

void bitmap_rotate_clockwise

(

BITMAP *

bm)

Definition at line 513 of file bitmap.c.

{
    BITMAP  nb;
    BmUnit  *fptr, *tptr;
    BmUnit  fmask, tmask;
    int w, h;
    
    nb.width = bm->height;
    nb.height = bm->width;
    nb.stride = BM_BYTES_PER_LINE(&nb);
    nb.data = mdvi_calloc(nb.height, nb.stride);
    
    fptr = bm->data;
    tptr = __bm_unit_ptr(&nb, nb.width - 1, 0);
    
    tmask = FIRSTMASKAT(nb.width-1);
    for(h = 0; h < bm->height; h++) {
        BmUnit  *fline, *tline;
        
        fmask = FIRSTMASK;
        fline = fptr;
        tline = tptr;
        for(w = 0; w < bm->width; w++) {
            if(*fline & fmask)
                *tline |= tmask;
            if(fmask == LASTMASK) {
                fmask = FIRSTMASK;
                fline++;
            } else
                NEXTMASK(fmask);
            /* go to next row */
            tline = bm_offset(tline, nb.stride);
        }
        fptr = bm_offset(fptr, bm->stride);
        if(tmask == FIRSTMASK) {
            tmask = LASTMASK;
            tptr--;
        } else
            PREVMASK(tmask);
    }

    DEBUG((DBG_BITMAP_OPS, "rotate_clockwise (%d,%d) -> (%d,%d)\n",
        bm->width, bm->height, nb.width, nb.height));
    mdvi_free(bm->data);
    bm->data = nb.data;
    bm->width = nb.width;
    bm->height = nb.height; 
    bm->stride = nb.stride;
    if(SHOW_OP_DATA)
        bitmap_print(stderr, bm);
}

Here is the caller graph for this function:

void bitmap_rotate_counter_clockwise

(

BITMAP *

bm)

Definition at line 565 of file bitmap.c.

{
    BITMAP  nb;
    BmUnit  *fptr, *tptr;
    BmUnit  fmask, tmask;
    int w, h;
    
    nb.width = bm->height;
    nb.height = bm->width;
    nb.stride = BM_BYTES_PER_LINE(&nb);
    nb.data = mdvi_calloc(nb.height, nb.stride);
    
    fptr = bm->data;
    tptr = __bm_unit_ptr(&nb, 0, nb.height - 1);

    tmask = FIRSTMASK;
    for(h = 0; h < bm->height; h++) {
        BmUnit  *fline, *tline;
        
        fmask = FIRSTMASK;
        fline = fptr;
        tline = tptr;
        for(w = 0; w < bm->width; w++) {
            if(*fline & fmask)
                *tline |= tmask;
            if(fmask == LASTMASK) {
                fmask = FIRSTMASK;
                fline++;
            } else
                NEXTMASK(fmask);
            /* go to previous row */
            tline = bm_offset(tline, -nb.stride);
        }
        fptr = bm_offset(fptr, bm->stride);
        if(tmask == LASTMASK) {
            tmask = FIRSTMASK;
            tptr++;
        } else
            NEXTMASK(tmask);
    }

    DEBUG((DBG_BITMAP_OPS, "rotate_counter_clockwise (%d,%d) -> (%d,%d)\n",
        bm->width, bm->height, nb.width, nb.height));
    mdvi_free(bm->data);
    bm->data = nb.data;
    bm->width = nb.width;
    bm->height = nb.height; 
    bm->stride = nb.stride;
    if(SHOW_OP_DATA)
        bitmap_print(stderr, bm);
}

Here is the caller graph for this function:

void bitmap_set_col	(	BITMAP *	bm,
		int	row,
		int	col,
		int	count,
		int	state
	)

Definition at line 291 of file bitmap.c.

{
    BmUnit  *ptr;
    BmUnit  mask;
    
    ptr = __bm_unit_ptr(bm, col, row);
    mask = FIRSTMASKAT(col);
    
    while(count-- > 0) {
        if(state)
            *ptr |= mask;
        else
            *ptr &= ~mask;
        /* move to next row */
        ptr = bm_offset(ptr, bm->stride);
    }
}

void bitmap_set_row	(	BITMAP *	bm,
		int	row,
		int	col,
		int	count,
		int	state
	)

Definition at line 365 of file bitmap.c.

{
    BmUnit  *ptr;
    
    ptr = __bm_unit_ptr(bm, col, row);
    if(state)
        bitmap_paint_bits(ptr, col & (BITMAP_BITS-1), count);
    else
        bitmap_clear_bits(ptr, col & (BITMAP_BITS-1), count);
}

Here is the caller graph for this function:

static int do_sample ( BmUnit *  data, int  stride, int  step, int  w, int  h  )

static

Definition at line 757 of file bitmap.c.

{
    BmUnit  *ptr, *end, *cp;
    int shift, n;
    int bits_left;
    int wid;
    
    ptr = data + step / BITMAP_BITS;
    end = bm_offset(data, h * stride);
    shift = FIRSTSHIFTAT(step);
    bits_left = w;
    n = 0;
    while(bits_left) {
#ifndef WORD_BIG_ENDIAN
        wid = BITMAP_BITS - shift;
#else
        wid = shift;
#endif
        if(wid > bits_left)
            wid = bits_left;
        if(wid > 8)
            wid = 8;
#ifdef WORD_BIG_ENDIAN
        shift -= wid;
#endif
        for(cp = ptr; cp < end; cp = bm_offset(cp, stride))
            n += sample_count[(*cp >> shift) & bit_masks[wid]];
#ifndef WORD_BIG_ENDIAN
        shift += wid;
#endif
#ifdef WORD_BIG_ENDIAN
        if(shift == 0) {
            shift = BITMAP_BITS;
            ptr++;
        }
#else
        if(shift == BITMAP_BITS) {
            shift = 0;
            ptr++;
        }
#endif
        bits_left -= wid;
    }
    return n;
}

Here is the caller graph for this function:

void mdvi_shrink_box	(	DviContext *	dvi,
		DviFont *	font,
		DviFontChar *	pk,
		DviGlyph *	dest
	)

Definition at line 803 of file bitmap.c.

{
    int x, y, z;
    DviGlyph *glyph;
    int hs, vs;
    
    hs = dvi->params.hshrink;
    vs = dvi->params.vshrink;
    glyph = &pk->glyph;
    
    x = (int)glyph->x / hs;
    if((int)glyph->x - x * hs > 0)
        x++;
    dest->w = x + ROUND((int)glyph->w - glyph->x, hs);

    z = (int)glyph->y + 1;
    y = z / vs;
    if(z - y * vs <= 0)
        y--;
    dest->h = y + ROUND((int)glyph->h - z, vs) + 1;
    dest->x = x;
    dest->y = glyph->y / vs;
    dest->data = MDVI_GLYPH_EMPTY;
    DEBUG((DBG_BITMAPS, "shrink_box: (%dw,%dh,%dx,%dy) -> (%dw,%dh,%dx,%dy)\n",
        glyph->w, glyph->h, glyph->x, glyph->y,
        dest->w, dest->h, dest->x, dest->y));
}

Here is the caller graph for this function:

void mdvi_shrink_glyph	(	DviContext *	dvi,
		DviFont *	font,
		DviFontChar *	pk,
		DviGlyph *	dest
	)

Definition at line 832 of file bitmap.c.

{
    int rows_left, rows, init_cols;
    int cols_left, cols;
    BmUnit  *old_ptr, *new_ptr;
    BITMAP  *oldmap, *newmap;
    BmUnit  m, *cp;
    DviGlyph *glyph;
    int sample, min_sample;
    int old_stride;
    int new_stride;
    int x, y;
    int w, h;
    int hs, vs;
    
    hs = dvi->params.hshrink;
    vs = dvi->params.vshrink;
    
    min_sample = vs * hs * dvi->params.density / 100;

    glyph = &pk->glyph;
    oldmap = (BITMAP *)glyph->data;
        
    x = (int)glyph->x / hs;
    init_cols = (int)glyph->x - x * hs;
    if(init_cols <= 0)
        init_cols += hs;
    else
        x++;
    w = x + ROUND((int)glyph->w - glyph->x, hs);

    cols = (int)glyph->y + 1;
    y = cols / vs;
    rows = cols - y * vs;
    if(rows <= 0) {
        rows += vs;
        y--;
    }
    h = y + ROUND((int)glyph->h - cols, vs) + 1;

    /* create the new glyph */
    newmap = bitmap_alloc(w, h);
    dest->data = newmap;
    dest->x = x;
    dest->y = glyph->y / vs;
    dest->w = w;
    dest->h = h;

    old_ptr = oldmap->data;
    old_stride = oldmap->stride;
    new_ptr = newmap->data;
    new_stride = newmap->stride;
    rows_left = glyph->h;

    while(rows_left) {
        if(rows > rows_left)
            rows = rows_left;
        cols_left = glyph->w;
        m = FIRSTMASK;
        cp = new_ptr;
        cols = init_cols;
        while(cols_left > 0) {
            if(cols > cols_left)
                cols = cols_left;
            sample = do_sample(old_ptr, old_stride,
                glyph->w - cols_left, cols, rows);
            if(sample >= min_sample)
                *cp |= m;
            if(m == LASTMASK) {
                m = FIRSTMASK;
                cp++;
            } else
                NEXTMASK(m);
            cols_left -= cols;
            cols = hs;
        }
        new_ptr = bm_offset(new_ptr, new_stride);
        old_ptr = bm_offset(old_ptr, rows * old_stride);
        rows_left -= rows;
        rows = vs;
    }   
    DEBUG((DBG_BITMAPS, "shrink_glyph: (%dw,%dh,%dx,%dy) -> (%dw,%dh,%dx,%dy)\n",
        glyph->w, glyph->h, glyph->x, glyph->y,
        dest->w, dest->h, dest->x, dest->y));
    if(DEBUGGING(BITMAP_DATA))
        bitmap_print(stderr, newmap);
}

Here is the caller graph for this function:

void mdvi_shrink_glyph_grey	(	DviContext *	dvi,
		DviFont *	font,
		DviFontChar *	pk,
		DviGlyph *	dest
	)

Definition at line 921 of file bitmap.c.

{
    int rows_left, rows;
    int cols_left, cols, init_cols;
    long    sampleval, samplemax;
    BmUnit  *old_ptr;
    void    *image;
    int w, h;
    int x, y;
    DviGlyph *glyph;
    BITMAP  *map;
    Ulong   *pixels;
    int npixels;
    Ulong   colortab[2];
    int hs, vs;
    DviDevice *dev;

    hs = dvi->params.hshrink;
    vs = dvi->params.vshrink;
    dev = &dvi->device;
    
    glyph = &pk->glyph;
    map = (BITMAP *)glyph->data;
    
    x = (int)glyph->x / hs;
    init_cols = (int)glyph->x - x * hs;
    if(init_cols <= 0)
        init_cols += hs;
    else
        x++;
    w = x + ROUND((int)glyph->w - glyph->x, hs);

    cols = (int)glyph->y + 1;
    y = cols / vs;
    rows = cols - y * vs;
    if(rows <= 0) {
        rows += vs;
        y--;
    }
    h = y + ROUND((int)glyph->h - cols, vs) + 1;
    ASSERT(w && h);
    
    /* before touching anything, do this */
    image = dev->create_image(dev->device_data, w, h, BITMAP_BITS);
    if(image == NULL) {
        mdvi_shrink_glyph(dvi, font, pk, dest);
        return;
    }
    
    /* save these colors */
    pk->fg = MDVI_CURRFG(dvi);
    pk->bg = MDVI_CURRBG(dvi);
    
    samplemax = vs * hs;
    npixels = samplemax + 1;
    pixels = get_color_table(&dvi->device, npixels, pk->fg, pk->bg,
            dvi->params.gamma, dvi->params.density);
    if(pixels == NULL) {
        npixels = 2;
        colortab[0] = pk->fg;
        colortab[1] = pk->bg;
        pixels = &colortab[0];
    }
    
    /* setup the new glyph */
    dest->data = image;
    dest->x = x;
    dest->y = glyph->y / vs;
    dest->w = w;
    dest->h = h;

    y = 0;
    old_ptr = map->data;
    rows_left = glyph->h;

    while(rows_left && y < h) {
        x = 0;
        if(rows > rows_left)
            rows = rows_left;
        cols_left = glyph->w;
        cols = init_cols;
        while(cols_left && x < w) {
            if(cols > cols_left)
                cols = cols_left;
            sampleval = do_sample(old_ptr, map->stride,
                glyph->w - cols_left, cols, rows);
            /* scale the sample value by the number of grey levels */
            if(npixels - 1 != samplemax)
                sampleval = ((npixels-1) * sampleval) / samplemax;
            ASSERT(sampleval < npixels);
            dev->put_pixel(image, x, y, pixels[sampleval]);
            cols_left -= cols;
            cols = hs;
            x++;
        }
        for(; x < w; x++)
            dev->put_pixel(image, x, y, pixels[0]);
        old_ptr = bm_offset(old_ptr, rows * map->stride);
        rows_left -= rows;
        rows = vs;
        y++;
    }
    
    for(; y < h; y++) {
        for(x = 0; x < w; x++)
            dev->put_pixel(image, x, y, pixels[0]);
    }

        dev->image_done(image);
    DEBUG((DBG_BITMAPS, "shrink_glyph_grey: (%dw,%dh,%dx,%dy) -> (%dw,%dh,%dx,%dy)\n",
        glyph->w, glyph->h, glyph->x, glyph->y,
        dest->w, dest->h, dest->x, dest->y));
}

Variable Documentation

BmUnit bit_masks[]

static

Initial value:

= {
    0x0,        0x1,        0x3,        0x7,
    0xf,        0x1f,       0x3f,       0x7f,
    0xff,

            0x1ff,      0x3ff,      0x7ff,
    0xfff,      0x1fff,     0x3fff,     0x7fff,
    0xffff,

            0x1ffff,    0x3ffff,    0x7ffff,
    0xfffff,    0x1fffff,   0x3fffff,   0x7fffff,
    0xffffff,   0x1ffffff,  0x3ffffff,  0x7ffffff,
    0xfffffff,  0x1fffffff, 0x3fffffff, 0x7fffffff,
    0xffffffff


}

Definition at line 29 of file bitmap.c.

Uchar bit_swap[]

static

Definition at line 85 of file bitmap.c.

int sample_count[]

static

Initial value:

= {
    0, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 3, 2, 3, 3, 4,
    1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5,
    1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5,
    2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
    1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5,
    2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
    2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
    3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7,
    1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5,
    2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
    2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
    3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7,
    2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
    3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7,
    3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7,
    4, 5, 5, 6, 5, 6, 6, 7, 5, 6, 6, 7, 6, 7, 7, 8
}

Definition at line 65 of file bitmap.c.