| /****************************************************************************/ |
| /* */ |
| /* The FreeType project -- a free and portable quality TrueType renderer. */ |
| /* */ |
| /* Copyright 1996-1999 by */ |
| /* D. Turner, R.Wilhelm, and W. Lemberg */ |
| /* */ |
| /* blitter.c: Support for blitting of bitmaps with various depth. */ |
| /* */ |
| /****************************************************************************/ |
| |
| #include "grblit.h" |
| #include "grobjs.h" |
| |
| static |
| int compute_clips( grBlitter* blit, |
| int x_offset, |
| int y_offset ) |
| { |
| int xmin, ymin, xmax, ymax, width, height, target_width; |
| |
| /* perform clipping and setup variables */ |
| width = blit->source.width; |
| height = blit->source.rows; |
| |
| switch ( blit->source.mode ) |
| { |
| case gr_pixel_mode_mono: |
| width = (width + 7) & -8; |
| break; |
| |
| case gr_pixel_mode_pal4: |
| width = (width + 1) & -2; |
| break; |
| |
| default: |
| ; |
| } |
| |
| xmin = x_offset; |
| ymin = y_offset; |
| xmax = xmin + width-1; |
| ymax = ymin + height-1; |
| |
| /* clip if necessary */ |
| if ( width == 0 || height == 0 || |
| xmax < 0 || xmin >= blit->target.width || |
| ymax < 0 || ymin >= blit->target.rows ) |
| return 1; |
| |
| /* set up clipping and cursors */ |
| blit->yread = 0; |
| if ( ymin < 0 ) |
| { |
| blit->yread -= ymin; |
| height += ymin; |
| blit->ywrite = 0; |
| } |
| else |
| blit->ywrite = ymin; |
| |
| if ( ymax >= blit->target.rows ) |
| height -= ymax - blit->target.rows + 1; |
| |
| blit->xread = 0; |
| if ( xmin < 0 ) |
| { |
| blit->xread -= xmin; |
| width += xmin; |
| blit->xwrite = 0; |
| } |
| else |
| blit->xwrite = xmin; |
| |
| target_width = blit->target.width; |
| |
| switch ( blit->target.mode ) |
| { |
| case gr_pixel_mode_mono: |
| target_width = (target_width + 7) & -8; |
| break; |
| case gr_pixel_mode_pal4: |
| target_width = (target_width + 1) & -2; |
| break; |
| |
| default: |
| ; |
| } |
| |
| blit->right_clip = xmax - target_width + 1; |
| if ( blit->right_clip > 0 ) |
| width -= blit->right_clip; |
| else |
| blit->right_clip = 0; |
| |
| blit->width = width; |
| blit->height = height; |
| |
| /* set read and write to the top-left corner of the read */ |
| /* and write areas before clipping. */ |
| |
| blit->read = (unsigned char*)blit->source.buffer; |
| blit->write = (unsigned char*)blit->target.buffer; |
| |
| blit->read_line = blit->source.pitch; |
| blit->write_line = blit->target.pitch; |
| |
| if ( blit->read_line < 0 ) |
| blit->read -= (blit->source.rows-1) * blit->read_line; |
| |
| if ( blit->write_line < 0 ) |
| blit->write -= (blit->target.rows-1) * blit->write_line; |
| |
| /* now go to the start line. Note that we do not move the */ |
| /* x position yet, as this is dependent on the pixel format */ |
| blit->read += blit->yread * blit->read_line; |
| blit->write += blit->ywrite * blit->write_line; |
| |
| return 0; |
| } |
| |
| |
| /**************************************************************************/ |
| /* */ |
| /* <Function> blit_mono_to_mono */ |
| /* */ |
| /**************************************************************************/ |
| |
| static |
| void blit_mono_to_mono( grBlitter* blit, |
| grColor color ) |
| { |
| int shift, left_clip, x, y; |
| byte* read; |
| byte* write; |
| |
| (void)color; /* unused argument */ |
| |
| left_clip = ( blit->xread > 0 ); |
| shift = ( blit->xwrite - blit->xread ) & 7; |
| |
| read = blit->read + (blit->xread >> 3); |
| write = blit->write + (blit->xwrite >> 3); |
| |
| if ( shift == 0 ) |
| { |
| y = blit->height; |
| do |
| { |
| byte* _read = read; |
| byte* _write = write; |
| |
| x = blit->width; |
| |
| do |
| { |
| *_write++ |= *_read++; |
| x -= 8; |
| } while ( x > 0 ); |
| |
| read += blit->read_line; |
| write += blit->write_line; |
| y--; |
| } while ( y > 0 ); |
| } |
| else |
| { |
| int first, last, count; |
| |
| |
| first = blit->xwrite >> 3; |
| last = (blit->xwrite + blit->width-1) >> 3; |
| |
| count = last - first; |
| |
| if ( blit->right_clip ) |
| count++; |
| |
| y = blit->height; |
| |
| do |
| { |
| unsigned char* _read = read; |
| unsigned char* _write = write; |
| unsigned char old; |
| int shift2 = (8-shift); |
| |
| if ( left_clip ) |
| old = (*_read++) << shift2; |
| else |
| old = 0; |
| |
| x = count; |
| while ( x > 0 ) |
| { |
| unsigned char val; |
| |
| val = *_read++; |
| *_write++ |= ( (val >> shift) | old ); |
| old = val << shift2; |
| x--; |
| } |
| |
| if ( !blit->right_clip ) |
| *_write |= old; |
| |
| read += blit->read_line; |
| write += blit->write_line; |
| y--; |
| |
| } while ( y > 0 ); |
| } |
| } |
| |
| |
| /**************************************************************************/ |
| /* */ |
| /* <Function> blit_mono_to_pal8 */ |
| /* */ |
| /**************************************************************************/ |
| |
| static |
| void blit_mono_to_pal8( grBlitter* blit, |
| grColor color ) |
| { |
| int x, y; |
| unsigned int left_mask; |
| unsigned char* read; |
| unsigned char* write; |
| |
| read = blit->read + (blit->xread >> 3); |
| write = blit->write + blit->xwrite; |
| |
| left_mask = 0x80 >> (blit->xread & 7); |
| |
| y = blit->height; |
| do |
| { |
| unsigned char* _read = read; |
| unsigned char* _write = write; |
| unsigned int mask = left_mask; |
| unsigned int val = *_read; |
| |
| |
| x = blit->width; |
| do |
| { |
| if ( mask == 0x80 ) |
| val = *_read++; |
| |
| if ( val & mask ) |
| *_write = (unsigned char)color.value; |
| |
| mask >>= 1; |
| if ( mask == 0 ) |
| mask = 0x80; |
| |
| _write++; |
| x--; |
| } while ( x > 0 ); |
| |
| read += blit->read_line; |
| write += blit->write_line; |
| y--; |
| } while ( y > 0 ); |
| } |
| |
| |
| /**************************************************************************/ |
| /* */ |
| /* <Function> blit_mono_to_pal4 */ |
| /* */ |
| /**************************************************************************/ |
| |
| static |
| void blit_mono_to_pal4( grBlitter* blit, |
| grColor color ) |
| { |
| int x, y, phase; |
| unsigned int left_mask; |
| unsigned char* read; |
| unsigned char* write; |
| unsigned char col; |
| |
| |
| col = color.value & 15; |
| read = blit->read + (blit->xread >> 3); |
| write = blit->write + (blit->xwrite >> 1); |
| |
| /* now begin blit */ |
| left_mask = 0x80 >> (blit->xread & 7); |
| phase = blit->xwrite & 1; |
| |
| y = blit->height; |
| do |
| { |
| unsigned char* _read = read; |
| unsigned char* _write = write; |
| unsigned int mask = left_mask; |
| int _phase = phase; |
| unsigned int val = *_read; |
| |
| x = blit->width; |
| do |
| { |
| if ( mask == 0x80 ) |
| val = *_read++; |
| |
| if ( val & mask ) |
| { |
| if ( _phase ) |
| *_write = (*_write & 0xF0) | col; |
| else |
| *_write = (*_write & 0x0F) | (col << 4); |
| } |
| |
| mask >>= 1; |
| if ( mask == 0 ) |
| mask = 0x80; |
| |
| _write += _phase; |
| _phase ^= 1; |
| x--; |
| } while ( x > 0 ); |
| |
| read += blit->read_line; |
| write += blit->write_line; |
| y--; |
| } while ( y > 0 ); |
| } |
| |
| |
| /**************************************************************************/ |
| /* */ |
| /* <Function> blit_mono_to_rgb16 */ |
| /* */ |
| /**************************************************************************/ |
| |
| static |
| void blit_mono_to_rgb16( grBlitter* blit, |
| grColor color ) |
| { |
| int x, y; |
| unsigned int left_mask; |
| unsigned char* read; |
| unsigned char* write; |
| |
| read = blit->read + (blit->xread >> 3); |
| write = blit->write + blit->xwrite*2; |
| |
| left_mask = 0x80 >> (blit->xread & 7); |
| |
| y = blit->height; |
| do |
| { |
| unsigned char* _read = read; |
| unsigned char* _write = write; |
| unsigned int mask = left_mask; |
| unsigned int val = *_read; |
| |
| x = blit->width; |
| do |
| { |
| if ( mask == 0x80 ) |
| val = *_read++; |
| |
| if ( val & mask ) |
| *(short*)_write = (short)color.value; |
| |
| mask >>= 1; |
| if ( mask == 0 ) |
| mask = 0x80; |
| |
| _write +=2; |
| x--; |
| } while ( x > 0 ); |
| |
| read += blit->read_line; |
| write += blit->write_line; |
| y--; |
| } while ( y > 0 ); |
| } |
| |
| |
| /**************************************************************************/ |
| /* */ |
| /* <Function> blit_mono_to_rgb24 */ |
| /* */ |
| /**************************************************************************/ |
| |
| static |
| void blit_mono_to_rgb24( grBlitter* blit, |
| grColor color ) |
| { |
| int x, y; |
| unsigned int left_mask; |
| unsigned char* read; |
| unsigned char* write; |
| |
| read = blit->read + (blit->xread >> 3); |
| write = blit->write + blit->xwrite*3; |
| |
| left_mask = 0x80 >> (blit->xread & 7); |
| |
| y = blit->height; |
| do |
| { |
| unsigned char* _read = read; |
| unsigned char* _write = write; |
| unsigned int mask = left_mask; |
| unsigned int val = *_read; |
| |
| x = blit->width; |
| do |
| { |
| if ( mask == 0x80 ) |
| val = *_read++; |
| |
| if ( val & mask ) |
| { |
| _write[0] = color.chroma[0]; |
| _write[1] = color.chroma[1]; |
| _write[2] = color.chroma[2]; |
| } |
| |
| mask >>= 1; |
| if ( mask == 0 ) |
| mask = 0x80; |
| |
| _write += 3; |
| x--; |
| } while ( x > 0 ); |
| |
| read += blit->read_line; |
| write += blit->write_line; |
| y--; |
| } while ( y > 0 ); |
| } |
| |
| |
| /**************************************************************************/ |
| /* */ |
| /* <Function> blit_mono_to_rgb32 */ |
| /* */ |
| /**************************************************************************/ |
| |
| static |
| void blit_mono_to_rgb32( grBlitter* blit, |
| grColor color ) |
| { |
| int x, y; |
| unsigned int left_mask; |
| unsigned char* read; |
| unsigned char* write; |
| |
| read = blit->read + (blit->xread >> 3); |
| write = blit->write + blit->xwrite*4; |
| |
| left_mask = 0x80 >> (blit->xread & 7); |
| |
| y = blit->height; |
| do |
| { |
| unsigned char* _read = read; |
| unsigned char* _write = write; |
| unsigned int mask = left_mask; |
| unsigned int val = *_read; |
| |
| x = blit->width; |
| do |
| { |
| if ( mask == 0x80 ) |
| val = *_read++; |
| |
| if ( val & mask ) |
| { |
| /* this could be greatly optimised as a *(long*)_write = color.value */ |
| /* but this wouldn't work on 64-bits systems... stupid C types! */ |
| _write[0] = color.chroma[0]; |
| _write[1] = color.chroma[1]; |
| _write[2] = color.chroma[2]; |
| _write[3] = color.chroma[3]; |
| } |
| |
| mask >>= 1; |
| if ( mask == 0 ) |
| mask = 0x80; |
| |
| _write += 4; |
| x--; |
| } while ( x > 0 ); |
| |
| read += blit->read_line; |
| write += blit->write_line; |
| y--; |
| } while ( y > 0 ); |
| } |
| |
| |
| |
| static |
| const grBlitterFunc gr_mono_blitters[gr_pixel_mode_max] = |
| { |
| 0, |
| blit_mono_to_mono, |
| blit_mono_to_pal4, |
| blit_mono_to_pal8, |
| blit_mono_to_pal8, |
| blit_mono_to_rgb16, |
| blit_mono_to_rgb16, |
| blit_mono_to_rgb24, |
| blit_mono_to_rgb32 |
| }; |
| |
| |
| /*******************************************************************/ |
| /* */ |
| /* Saturation tables */ |
| /* */ |
| /*******************************************************************/ |
| |
| typedef struct grSaturation_ |
| { |
| int count; |
| const byte* table; |
| |
| } grSaturation; |
| |
| |
| static |
| const byte gr_saturation_5[8] = { 0, 1, 2, 3, 4, 4, 4, 4 }; |
| |
| |
| static |
| const byte gr_saturation_17[32] = |
| { |
| 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, |
| 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, |
| }; |
| |
| |
| static |
| grSaturation gr_saturations[ GR_MAX_SATURATIONS ] = |
| { |
| { 5, gr_saturation_5 }, |
| { 17, gr_saturation_17 } |
| }; |
| |
| static |
| int gr_num_saturations = 2; |
| |
| static |
| grSaturation* gr_last_saturation = gr_saturations; |
| |
| |
| extern |
| const byte* grGetSaturation( int num_grays ) |
| { |
| /* first of all, scan the current saturations table */ |
| grSaturation* sat = gr_saturations; |
| grSaturation* limit = sat + gr_num_saturations; |
| |
| if ( num_grays < 2 ) |
| { |
| grError = gr_err_bad_argument; |
| return 0; |
| } |
| |
| for ( ; sat < limit; sat++ ) |
| { |
| if ( sat->count == num_grays ) |
| { |
| gr_last_saturation = sat; |
| return sat->table; |
| } |
| } |
| |
| /* not found, simply create a new entry if there is room */ |
| if (gr_num_saturations < GR_MAX_SATURATIONS) |
| { |
| int i; |
| const byte* table; |
| |
| table = (const byte*)grAlloc( (3*num_grays-1)*sizeof(byte) ); |
| if (!table) return 0; |
| |
| sat->count = num_grays; |
| sat->table = table; |
| |
| for ( i = 0; i < num_grays; i++, table++ ) |
| *(unsigned char*)table = (unsigned char)i; |
| |
| for ( i = 2*num_grays-1; i > 0; i--, table++ ) |
| *(unsigned char*)table = (unsigned char)(num_grays-1); |
| |
| gr_num_saturations++; |
| gr_last_saturation = sat; |
| return sat->table; |
| } |
| grError = gr_err_saturation_overflow; |
| return 0; |
| } |
| |
| |
| |
| /*******************************************************************/ |
| /* */ |
| /* conversion tables */ |
| /* */ |
| /*******************************************************************/ |
| |
| typedef struct grConversion_ |
| { |
| int target_grays; |
| int source_grays; |
| const byte* table; |
| |
| } grConversion; |
| |
| |
| |
| static |
| const byte gr_gray5_to_gray17[5] = { 0, 4, 8, 12, 16 }; |
| |
| |
| static |
| const byte gr_gray5_to_gray128[5] = { 0, 32, 64, 96, 127 }; |
| |
| |
| static |
| const unsigned char gr_gray17_to_gray128[17] = |
| { |
| 0, 8, 16, 24, 32, 40, 48, 56, 64, 72, 80, 88, 96, 104, 112, 120, 127 |
| }; |
| |
| static |
| grConversion gr_conversions[ GR_MAX_CONVERSIONS ] = |
| { |
| { 17, 5, gr_gray5_to_gray17 }, |
| { 128, 5, gr_gray5_to_gray128 }, |
| { 128, 17, gr_gray17_to_gray128 } |
| }; |
| |
| static |
| int gr_num_conversions = 3; |
| |
| static |
| grConversion* gr_last_conversion = gr_conversions; |
| |
| |
| extern |
| const byte* grGetConversion( int target_grays, |
| int source_grays ) |
| { |
| grConversion* conv = gr_conversions; |
| grConversion* limit = conv + gr_num_conversions; |
| |
| if ( target_grays < 2 || source_grays < 2 ) |
| { |
| grError = gr_err_bad_argument; |
| return 0; |
| } |
| |
| /* otherwise, scan table */ |
| for ( ; conv < limit; conv++ ) |
| { |
| if ( conv->target_grays == target_grays && |
| conv->source_grays == source_grays ) |
| { |
| gr_last_conversion = conv; |
| return conv->table; |
| } |
| } |
| |
| /* not found, add a new conversion to the table */ |
| if (gr_num_conversions < GR_MAX_CONVERSIONS) |
| { |
| const byte* table; |
| int n; |
| |
| table = (const byte*)grAlloc( source_grays*sizeof(byte) ); |
| if (!table) |
| return 0; |
| |
| conv->target_grays = target_grays; |
| conv->source_grays = source_grays; |
| conv->table = table; |
| |
| for ( n = 0; n < source_grays; n++ ) |
| ((unsigned char*)table)[n] = (unsigned char)(n*(target_grays-1)) / |
| (source_grays-1); |
| |
| gr_num_conversions++; |
| gr_last_conversion = conv; |
| return table; |
| } |
| grError = gr_err_conversion_overflow; |
| return 0; |
| } |
| |
| |
| |
| |
| /**************************************************************************/ |
| /* */ |
| /* <Function> blit_gray_to_gray */ |
| /* */ |
| /**************************************************************************/ |
| |
| static |
| void blit_gray_to_gray( grBlitter* blit, |
| const byte* saturation, |
| const byte* conversion ) |
| { |
| int y; |
| unsigned char* read; |
| unsigned char* write; |
| unsigned char max1; |
| unsigned char max2; |
| |
| max1 = (unsigned char)(blit->source.grays-1); |
| max2 = (unsigned char)(blit->target.grays-1); |
| |
| read = (unsigned char*)blit->read + blit->xread; |
| write = (unsigned char*)blit->write + blit->xwrite; |
| |
| y = blit->height; |
| do |
| { |
| unsigned char* _read = read; |
| unsigned char* _write = write; |
| int x = blit->width; |
| |
| while (x > 0) |
| { |
| #ifdef GR_CONFIG_GRAY_SKIP_WHITE |
| unsigned char val = *_read; |
| |
| if (val) |
| { |
| if (val == max) |
| *_write = max2; |
| else |
| *_write = saturation[ (int)*_write + conversion[ *_read ] ]; |
| } |
| #else |
| *_write = saturation[ (int)*_write + conversion[ *_read ] ]; |
| #endif |
| _write++; |
| _read++; |
| x--; |
| } |
| |
| read += blit->read_line; |
| write += blit->write_line; |
| y--; |
| } |
| while (y > 0); |
| } |
| |
| |
| /**************************************************************************/ |
| /* */ |
| /* <Function> blit_gray_to_gray_simple */ |
| /* */ |
| /**************************************************************************/ |
| |
| static |
| void blit_gray_to_gray_simple( grBlitter* blit, |
| const byte* saturation ) |
| { |
| int y; |
| unsigned char* read; |
| unsigned char* write; |
| unsigned char max; |
| |
| max = (unsigned char)(blit->source.grays-1); |
| |
| read = (unsigned char*)blit->read + blit->xread; |
| write = (unsigned char*)blit->write + blit->xwrite; |
| |
| y = blit->height; |
| do |
| { |
| unsigned char* _read = read; |
| unsigned char* _write = write; |
| int x = blit->width; |
| |
| while (x > 0) |
| { |
| #ifdef GR_CONFIG_GRAY_SKIP_WHITE |
| unsigned char val = *_read; |
| |
| if (val) |
| { |
| if (val == max) |
| *_write = val; |
| else |
| *_write = saturation[ (int)*_write + *_read ]; |
| } |
| #else |
| *_write = saturation[ (int)*_write + *_read ]; |
| #endif |
| _write++; |
| _read++; |
| x--; |
| } |
| |
| read += blit->read_line; |
| write += blit->write_line; |
| y--; |
| } |
| while (y > 0); |
| } |
| |
| |
| |
| #define compose_pixel( a, b, n, max ) \ |
| { \ |
| int d, half = max >> 1; \ |
| \ |
| d = (int)b.chroma[0] - a.chroma[0]; \ |
| a.chroma[0] += (n*d + half)/max; \ |
| \ |
| d = (int)b.chroma[1] - a.chroma[1]; \ |
| a.chroma[1] += (n*d + half)/max; \ |
| \ |
| d = (int)b.chroma[2] - a.chroma[2]; \ |
| a.chroma[2] += (n*d + half)/max; \ |
| } |
| |
| |
| #define extract555( pixel, color ) \ |
| color.chroma[0] = (pixel >> 10) & 0x1F; \ |
| color.chroma[1] = (pixel >> 5) & 0x1F; \ |
| color.chroma[2] = (pixel ) & 0x1F; |
| |
| |
| #define extract565( pixel, color ) \ |
| color.chroma[0] = (pixel >> 11) & 0x1F; \ |
| color.chroma[1] = (pixel >> 5) & 0x3F; \ |
| color.chroma[2] = (pixel ) & 0x1F; |
| |
| |
| #define inject555( color ) \ |
| ( ( (unsigned short)color.chroma[0] << 10 ) | \ |
| ( (unsigned short)color.chroma[1] << 5 ) | \ |
| color.chroma[2] ) |
| |
| |
| #define inject565( color ) \ |
| ( ( (unsigned short)color.chroma[0] << 11 ) | \ |
| ( (unsigned short)color.chroma[1] << 5 ) | \ |
| color.chroma[2] ) |
| |
| |
| /**************************************************************************/ |
| /* */ |
| /* <Function> blit_gray_to_555 */ |
| /* */ |
| /**************************************************************************/ |
| |
| static |
| void blit_gray_to_555( grBlitter* blit, |
| grColor color, |
| int max ) |
| { |
| int y; |
| unsigned char* read; |
| unsigned char* write; |
| long color2; |
| |
| read = blit->read + blit->xread; |
| write = blit->write + 2*blit->xwrite; |
| |
| /* convert color to R:G:B triplet */ |
| color2 = color.value; |
| extract555( color2, color ); |
| |
| y = blit->height; |
| do |
| { |
| unsigned char* _read = read; |
| unsigned char* _write = write; |
| int x = blit->width; |
| |
| while (x > 0) |
| { |
| unsigned char val; |
| |
| val = *_read; |
| if (val) |
| { |
| unsigned short* pixel = (unsigned short*)_write; |
| |
| if (val == max) |
| { |
| pixel[0] = (short)color2; |
| } |
| else |
| { |
| /* compose gray value */ |
| unsigned short pix16 = *pixel; |
| grColor pix; |
| |
| extract555( pix16, pix ); |
| |
| compose_pixel( pix, color, val, max ); |
| *pixel = inject555(pix); |
| } |
| } |
| _write += 2; |
| _read ++; |
| x--; |
| } |
| |
| read += blit->read_line; |
| write += blit->write_line; |
| y--; |
| } |
| while (y > 0); |
| } |
| |
| |
| /**************************************************************************/ |
| /* */ |
| /* <Function> blit_gray_to_565 */ |
| /* */ |
| /**************************************************************************/ |
| |
| static |
| void blit_gray_to_565( grBlitter* blit, |
| grColor color, |
| int max ) |
| { |
| int y; |
| unsigned char* read; |
| unsigned char* write; |
| long color2; |
| |
| read = blit->read + blit->xread; |
| write = blit->write + 2*blit->xwrite; |
| |
| color2 = color.value; |
| extract565( color2, color ); |
| |
| y = blit->height; |
| do |
| { |
| unsigned char* _read = read; |
| unsigned char* _write = write; |
| int x = blit->width; |
| |
| while (x > 0) |
| { |
| unsigned char val; |
| |
| val = *_read; |
| if (val) |
| { |
| unsigned short* pixel = (unsigned short*)_write; |
| |
| if (val == max) |
| { |
| pixel[0] = (short)color2; |
| } |
| else |
| { |
| /* compose gray value */ |
| unsigned short pix16 = *pixel; |
| grColor pix; |
| |
| extract565( pix16, pix ); |
| |
| compose_pixel( pix, color, val, max ); |
| *pixel = inject565( pix ); |
| } |
| } |
| _write +=2; |
| _read ++; |
| x--; |
| } |
| |
| read += blit->read_line; |
| write += blit->write_line; |
| y--; |
| } |
| while (y > 0); |
| } |
| |
| |
| /**************************************************************************/ |
| /* */ |
| /* <Function> blit_gray_to_24 */ |
| /* */ |
| /**************************************************************************/ |
| |
| static |
| void blit_gray_to_24( grBlitter* blit, |
| grColor color, |
| int max ) |
| { |
| int y; |
| unsigned char* read; |
| unsigned char* write; |
| |
| read = blit->read + blit->xread; |
| write = blit->write + 3*blit->xwrite; |
| |
| y = blit->height; |
| do |
| { |
| unsigned char* _read = read; |
| unsigned char* _write = write; |
| int x = blit->width; |
| |
| while (x > 0) |
| { |
| unsigned char val; |
| |
| val = *_read; |
| if (val) |
| { |
| if (val == max) |
| { |
| _write[0] = color.chroma[0]; |
| _write[1] = color.chroma[1]; |
| _write[2] = color.chroma[2]; |
| } |
| else |
| { |
| /* compose gray value */ |
| grColor pix; |
| |
| pix.chroma[0] = _write[0]; |
| pix.chroma[1] = _write[1]; |
| pix.chroma[2] = _write[2]; |
| |
| compose_pixel( pix, color, val, max ); |
| |
| _write[0] = pix.chroma[0]; |
| _write[1] = pix.chroma[1]; |
| _write[2] = pix.chroma[2]; |
| } |
| } |
| _write += 3; |
| _read ++; |
| x--; |
| } |
| |
| read += blit->read_line; |
| write += blit->write_line; |
| y--; |
| } |
| while (y > 0); |
| } |
| |
| |
| /**************************************************************************/ |
| /* */ |
| /* <Function> blit_gray_to_32 */ |
| /* */ |
| /**************************************************************************/ |
| |
| static |
| void blit_gray_to_32( grBlitter* blit, |
| grColor color, |
| int max ) |
| { |
| int y; |
| unsigned char* read; |
| unsigned char* write; |
| |
| read = blit->read + blit->xread; |
| write = blit->write + 4*blit->xwrite; |
| |
| y = blit->height; |
| do |
| { |
| unsigned char* _read = read; |
| unsigned char* _write = write; |
| int x = blit->width; |
| |
| while (x > 0) |
| { |
| unsigned char val; |
| |
| val = *_read; |
| if (val) |
| { |
| if (val == max) |
| { |
| _write[0] = color.chroma[0]; |
| _write[1] = color.chroma[1]; |
| _write[2] = color.chroma[2]; |
| _write[3] = color.chroma[3]; |
| } |
| else |
| { |
| /* compose gray value */ |
| grColor pix; |
| |
| pix.chroma[0] = _write[0]; |
| pix.chroma[1] = _write[1]; |
| pix.chroma[2] = _write[2]; |
| |
| compose_pixel( pix, color, val, max ); |
| |
| _write[0] = pix.chroma[0]; |
| _write[1] = pix.chroma[1]; |
| _write[2] = pix.chroma[2]; |
| } |
| } |
| _write += 4; |
| _read ++; |
| x--; |
| } |
| |
| read += blit->read_line; |
| write += blit->write_line; |
| y--; |
| } |
| while (y > 0); |
| } |
| |
| |
| /********************************************************************** |
| * |
| * <Function> |
| * grBlitGlyphBitmap |
| * |
| * <Description> |
| * writes a given glyph bitmap to a target surface. |
| * |
| * <Input> |
| * surface :: handle to target surface |
| * x :: position of left-most pixel of glyph image in surface |
| * y :: position of top-most pixel of glyph image in surface |
| * bitmap :: source glyph image |
| * |
| * <Return> |
| * Error code. 0 means success |
| * |
| **********************************************************************/ |
| |
| typedef void (*grColorGlyphBlitter)( grBlitter* blit, |
| grColor color, |
| int max_gray ); |
| |
| static |
| const grColorGlyphBlitter gr_color_blitters[gr_pixel_mode_max] = |
| { |
| 0, |
| 0, |
| 0, |
| 0, |
| blit_gray_to_555, |
| blit_gray_to_565, |
| blit_gray_to_24, |
| blit_gray_to_32 |
| }; |
| |
| |
| extern int grBlitGlyphToBitmap( grBitmap* target, |
| grBitmap* glyph, |
| grPos x, |
| grPos y, |
| grColor color ) |
| { |
| grBlitter blit; |
| grPixelMode mode; |
| |
| /* check arguments */ |
| if (!target || !glyph) |
| { |
| grError = gr_err_bad_argument; |
| return -1; |
| } |
| |
| |
| /* set up blitter and compute clipping. Return immediately if needed */ |
| blit.source = *glyph; |
| blit.target = *target; |
| mode = target->mode; |
| |
| if ( compute_clips( &blit, x, y ) ) |
| return 0; |
| |
| |
| /* handle monochrome bitmap blitting */ |
| if (glyph->mode == gr_pixel_mode_mono) |
| { |
| if ( mode <= gr_pixel_mode_none || mode >= gr_pixel_mode_max ) |
| { |
| grError = gr_err_bad_source_depth; |
| return -1; |
| } |
| |
| gr_mono_blitters[mode]( &blit, color ); |
| goto End; |
| } |
| |
| /* handle gray bitmap composition */ |
| if (glyph->mode == gr_pixel_mode_gray && |
| glyph->grays > 1 ) |
| { |
| int target_grays = target->grays; |
| int source_grays = glyph->grays; |
| const byte* saturation; |
| |
| if ( mode == gr_pixel_mode_gray && target_grays > 1 ) |
| { |
| /* rendering into a gray target - use special composition */ |
| /* routines.. */ |
| if ( gr_last_saturation->count == target_grays ) |
| saturation = gr_last_saturation->table; |
| else |
| { |
| saturation = grGetSaturation( target_grays ); |
| if (!saturation) return -3; |
| } |
| |
| |
| if ( target_grays == source_grays ) |
| blit_gray_to_gray_simple( &blit, saturation ); |
| else |
| { |
| const byte* conversion; |
| |
| if ( gr_last_conversion->target_grays == target_grays && |
| gr_last_conversion->source_grays == source_grays ) |
| conversion = gr_last_conversion->table; |
| else |
| { |
| conversion = grGetConversion( target_grays, source_grays ); |
| if (!conversion) return -3; |
| }; |
| |
| blit_gray_to_gray( &blit, saturation, conversion ); |
| } |
| } |
| else |
| { |
| /* rendering into a color target */ |
| if ( mode <= gr_pixel_mode_gray || |
| mode >= gr_pixel_mode_max ) |
| { |
| grError = gr_err_bad_target_depth; |
| return -1; |
| } |
| |
| gr_color_blitters[mode]( &blit, color, source_grays-1 ); |
| } |
| goto End; |
| } |
| |
| /* we don't support the blitting of bitmaps of the following */ |
| /* types : pal4, pal8, rgb555, rgb565, rgb24, rgb32 */ |
| /* */ |
| grError = gr_err_bad_source_depth; |
| return -2; |
| |
| End: |
| return 0; |
| } |
| |
| |
| /* End */ |
