TakeV/dxx-rebirth
1
0
Fork 0
Code Issues Pull requests Packages Projects Releases Wiki Activity

more stuff from d2src, formatting

Browse source
This commit is contained in:
Bradley Bell 2002-09-05 07:57:11 +00:00
parent 2c30a29d99
commit b9ada0394b
1 changed files with 264 additions and 107 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

351
2d/rle.c
View file

@ -1,4 +1,4 @@
/* $Id: rle.c,v 1.9 2002-09-04 22:25:29 btb Exp $ */ /* $Id: rle.c,v 1.10 2002-09-05 07:57:11 btb Exp $ */
/* /*
THE COMPUTER CODE CONTAINED HEREIN IS THE SOLE PROPERTY OF PARALLAX THE COMPUTER CODE CONTAINED HEREIN IS THE SOLE PROPERTY OF PARALLAX
SOFTWARE CORPORATION ("PARALLAX"). PARALLAX, IN DISTRIBUTING THE CODE TO SOFTWARE CORPORATION ("PARALLAX"). PARALLAX, IN DISTRIBUTING THE CODE TO
@ -125,7 +125,7 @@ COPYRIGHT 1993-1998 PARALLAX SOFTWARE CORPORATION. ALL RIGHTS RESERVED.
#endif #endif
#ifdef RCS #ifdef RCS
static char rcsid[] = "$Id: rle.c,v 1.9 2002-09-04 22:25:29 btb Exp $"; static char rcsid[] = "$Id: rle.c,v 1.10 2002-09-05 07:57:11 btb Exp $";
#endif #endif
#include <stdlib.h> #include <stdlib.h>
@ -146,11 +146,10 @@ static char rcsid[] = "$Id: rle.c,v 1.9 2002-09-04 22:25:29 btb Exp $";
#define RLE_CODE 0xE0 #define RLE_CODE 0xE0
#define NOT_RLE_CODE 31 #define NOT_RLE_CODE 31
void rle_expand_texture_sub( grs_bitmap * bmp, grs_bitmap * rle_temp_bitmap_1 ); #if !defined(NO_ASM) && defined(__WATCOMC__)
#define RLE_DECODE_ASM
#ifndef NO_ASM ubyte *gr_rle_decode_asm( ubyte * src, ubyte * dest );
#ifdef __WATCOMC__
int gr_rle_decode_asm( ubyte * src, ubyte * dest );
#pragma aux gr_rle_decode_asm parm [esi] [edi] value [edi] modify exact [eax ebx ecx edx esi edi] = \ #pragma aux gr_rle_decode_asm parm [esi] [edi] value [edi] modify exact [eax ebx ecx edx esi edi] = \
" cld " \ " cld " \
" xor ecx, ecx " \ " xor ecx, ecx " \
@ -187,9 +186,9 @@ int gr_rle_decode_asm( ubyte * src, ubyte * dest );
" " \ " " \
"done: "; "done: ";
void rle_stosb(char *dest, int len, int color); #elif !defined(NO_ASM) && defined(__GNUC__)
#pragma aux rle_stosb = "cld rep stosb" parm [edi] [ecx] [eax] modify exact [edi ecx]; #define RLE_DECODE_ASM
#elif defined __GNUC__
static inline int gr_rle_decode_asm( ubyte * src, ubyte * dest ) { static inline int gr_rle_decode_asm( ubyte * src, ubyte * dest ) {
register int __ret; register int __ret;
int dummy; int dummy;
@ -224,14 +223,9 @@ static inline int gr_rle_decode_asm( ubyte * src, ubyte * dest ) {
return __ret; return __ret;
} }
static inline void rle_stosb(char *dest, int len, int color) { #elif !defined(NO_ASM) && defined(_MSC_VER)
int dummy[2]; #define RLE_DECODE_ASM
__asm__ __volatile__ (
"cld; rep; stosb"
: "=D" (dummy[0]), "=c" (dummy[1])
: "0" (dest), "1" (len), "a" (color) );
}
#elif defined _MSC_VER
__inline int gr_rle_decode_asm( ubyte * src, ubyte * dest ) __inline int gr_rle_decode_asm( ubyte * src, ubyte * dest )
{ {
int retval; int retval;
@ -271,6 +265,61 @@ done:
return retval; return retval;
} }
#endif
#ifdef RLE_DECODE_ASM
void gr_rle_decode( ubyte * src, ubyte * dest, int dest_len )
{
ubyte *dest_end;
dest_end = (ubyte *)gr_rle_decode_asm( src, dest );
Assert(dest_end-src < dest_len);
}
#else // NO_ASM or unknown compiler
void gr_rle_decode( ubyte * src, ubyte * dest )
{
int i;
ubyte data, count = 0;
while(1) {
data = *src++;
if ( (data & RLE_CODE) != RLE_CODE ) {
*dest++ = data;
} else {
count = data & NOT_RLE_CODE;
if (count == 0)
return;
data = *src++;
for (i = 0; i < count; i++)
*dest++ = data;
}
}
}
#endif
void rle_stosb(char *dest, int len, int color);
#if !defined(NO_ASM) && defined(__WATCOMC__)
#pragma aux rle_stosb = "cld rep stosb" parm [edi] [ecx] [eax] modify exact [edi ecx];
#elif !defined(NO_ASM) && defined(__GNUC__)
inline void rle_stosb(char *dest, int len, int color) {
int dummy[2];
__asm__ __volatile__ (
"cld; rep; stosb"
: "=D" (dummy[0]), "=c" (dummy[1])
: "0" (dest), "1" (len), "a" (color) );
}
#elif !defined(NO_ASM) && defined(_MSC_VER)
__inline void rle_stosb(char *dest, int len, int color) __inline void rle_stosb(char *dest, int len, int color)
{ {
__asm { __asm {
@ -282,56 +331,28 @@ __inline void rle_stosb(char *dest, int len, int color)
} }
} }
#else #else // NO_ASM or unknown compiler
# undef NO_ASM
# define NO_ASM 1
/* Well, if inline assembler is not supported for this compiler, we don't
**really** want ASM... */
#endif
#endif
#ifdef NO_ASM void rle_stosb(char *dest, int len, int color)
void rle_stosb(ubyte *dest, int len, int color)
{ {
int i; int i;
for (i=0; i<len; i++ ) for (i=0; i<len; i++ )
*dest++ = color; *dest++ = color;
} }
#endif
void gr_rle_decode( ubyte * src, ubyte * dest )
{
#ifdef NO_ASM
int i;
ubyte data, count = 0;
while(1) {
data = *src++;
if ( (data & RLE_CODE) != RLE_CODE ) {
*dest++ = data;
} else {
count = data & NOT_RLE_CODE;
if (count==0) return;
data = *src++;
for (i=0; i<count; i++ )
*dest++ = data;
}
}
#else
gr_rle_decode_asm( src, dest );
#endif #endif
}
// Given pointer to start of one scanline of rle data, uncompress it to // Given pointer to start of one scanline of rle data, uncompress it to
// dest, from source pixels x1 to x2. // dest, from source pixels x1 to x2.
void gr_rle_expand_scanline_masked( ubyte *dest, ubyte *src, int x1, int x2 ) void gr_rle_expand_scanline_masked( ubyte *dest, ubyte *src, int x1, int x2 )
{ {
int i = 0; int i = 0;
ubyte count=0; ubyte count;
ubyte color=0; ubyte color=0;
if ( x2 < x1 ) return; if ( x2 < x1 ) return;
count = 0;
while ( i < x1 ) { while ( i < x1 ) {
color = *src++; color = *src++;
if ( color == RLE_CODE ) return; if ( color == RLE_CODE ) return;
@ -386,11 +407,12 @@ void gr_rle_expand_scanline_masked( ubyte *dest, ubyte *src, int x1, int x2 )
void gr_rle_expand_scanline( ubyte *dest, ubyte *src, int x1, int x2 ) void gr_rle_expand_scanline( ubyte *dest, ubyte *src, int x1, int x2 )
{ {
int i = 0; int i = 0;
ubyte count=0; ubyte count;
ubyte color=0; ubyte color=0;
if ( x2 < x1 ) return; if ( x2 < x1 ) return;
count = 0;
while ( i < x1 ) { while ( i < x1 ) {
color = *src++; color = *src++;
if ( color == RLE_CODE ) return; if ( color == RLE_CODE ) return;
@ -635,6 +657,54 @@ void rle_cache_flush()
} }
} }
void rle_expand_texture_sub( grs_bitmap * bmp, grs_bitmap * rle_temp_bitmap_1 )
{
unsigned char * dbits;
unsigned char * sbits;
int i;
#ifdef RLE_DECODE_ASM
unsigned char * dbits1;
#endif
#ifdef D1XD3D
Assert (bmp->iMagic == BM_MAGIC_NUMBER);
#endif
sbits = &bmp->bm_data[4 + bmp->bm_h];
dbits = rle_temp_bitmap_1->bm_data;
rle_temp_bitmap_1->bm_flags = bmp->bm_flags & (~BM_FLAG_RLE);
for (i=0; i < bmp->bm_h; i++ ) {
#ifdef RLE_DECODE_ASM
dbits1=(unsigned char *)gr_rle_decode_asm( sbits, dbits );
#else
gr_rle_decode( sbits, dbits );
#endif
sbits += (int)bmp->bm_data[4+i];
dbits += bmp->bm_w;
#ifdef RLE_DECODE_ASM
Assert( dbits == dbits1 ); // Get John, bogus rle data!
#endif
}
#ifdef D1XD3D
gr_set_bitmap_data (rle_temp_bitmap_1, rle_temp_bitmap_1->bm_data);
#endif
}
#if defined(POLY_ACC)
grs_bitmap *rle_get_id_sub(grs_bitmap *bmp)
{
int i;
for (i=0;i<MAX_CACHE_BITMAPS;i++) {
if (rle_cache[i].expanded_bitmap == bmp) {
return rle_cache[i].rle_bitmap;
}
}
return NULL;
}
#endif
grs_bitmap * rle_expand_texture( grs_bitmap * bmp ) grs_bitmap * rle_expand_texture( grs_bitmap * bmp )
@ -686,49 +756,15 @@ grs_bitmap * rle_expand_texture( grs_bitmap * bmp )
} }
void rle_expand_texture_sub( grs_bitmap * bmp, grs_bitmap * rle_temp_bitmap_1 ) void gr_rle_expand_scanline_generic( grs_bitmap * dest, int dx, int dy, ubyte *src, int x1, int x2 )
{
unsigned char * dbits;
unsigned char * sbits;
int i;
#ifndef NO_ASM
unsigned char * dbits1;
#endif
#ifdef D1XD3D
Assert (bmp->iMagic == BM_MAGIC_NUMBER);
#endif
sbits = &bmp->bm_data[4 + bmp->bm_h];
dbits = rle_temp_bitmap_1->bm_data;
rle_temp_bitmap_1->bm_flags = bmp->bm_flags & (~BM_FLAG_RLE);
for (i=0; i < bmp->bm_h; i++ ) {
#ifndef NO_ASM
dbits1=(unsigned char *)gr_rle_decode_asm( sbits, dbits );
#else
gr_rle_decode( sbits, dbits );
#endif
sbits += (int)bmp->bm_data[4+i];
dbits += bmp->bm_w;
#ifndef NO_ASM
Assert( dbits == dbits1 ); // Get John, bogus rle data!
#endif
}
#ifdef D1XD3D
gr_set_bitmap_data (rle_temp_bitmap_1, rle_temp_bitmap_1->bm_data);
#endif
}
void gr_rle_expand_scanline_generic( grs_bitmap * dest, int dx, int dy, ubyte *src, int x1, int x2, int masked )
{ {
int i = 0, j; int i = 0, j;
int count=0; int count;
ubyte color=0; ubyte color=0;
if ( x2 < x1 ) return; if ( x2 < x1 ) return;
count = 0;
while ( i < x1 ) { while ( i < x1 ) {
color = *src++; color = *src++;
if ( color == RLE_CODE ) return; if ( color == RLE_CODE ) return;
@ -747,15 +783,11 @@ void gr_rle_expand_scanline_generic( grs_bitmap * dest, int dx, int dy, ubyte *s
if ( x1+count > x2 ) { if ( x1+count > x2 ) {
count = x2-x1+1; count = x2-x1+1;
if (!masked || color != 255)
for ( j=0; j<count; j++ ) for ( j=0; j<count; j++ )
gr_bm_pixel( dest, dx++, dy, color ); gr_bm_pixel( dest, dx++, dy, color );
return; return;
} }
if (masked && color == 255)
dx += count;
else
for ( j=0; j<count; j++ ) for ( j=0; j<count; j++ )
gr_bm_pixel( dest, dx++, dy, color ); gr_bm_pixel( dest, dx++, dy, color );
i += count; i += count;
@ -772,17 +804,11 @@ void gr_rle_expand_scanline_generic( grs_bitmap * dest, int dx, int dy, ubyte *s
} }
// we know have '*count' pixels of 'color'. // we know have '*count' pixels of 'color'.
if ( i+count <= x2 ) { if ( i+count <= x2 ) {
if (masked && color == 255)
dx += count;
else
for ( j=0; j<count; j++ ) for ( j=0; j<count; j++ )
gr_bm_pixel( dest, dx++, dy, color ); gr_bm_pixel( dest, dx++, dy, color );
i += count; i += count;
} else { } else {
count = x2-i+1; count = x2-i+1;
if (masked && color == 255)
dx += count;
else
for ( j=0; j<count; j++ ) for ( j=0; j<count; j++ )
gr_bm_pixel( dest, dx++, dy, color ); gr_bm_pixel( dest, dx++, dy, color );
i += count; i += count;
@ -861,6 +887,137 @@ void gr_rle_expand_scanline_generic_masked( grs_bitmap * dest, int dx, int dy, u
} }
} }
#ifdef __MSDOS__
void gr_rle_expand_scanline_svga_masked( grs_bitmap * dest, int dx, int dy, ubyte *src, int x1, int x2 )
{
int i = 0, j;
int count;
ubyte color;
ubyte * vram = (ubyte *)0xA0000;
int VideoLocation,page,offset;
if ( x2 < x1 ) return;
VideoLocation = (unsigned int)dest->bm_data + (dest->bm_rowsize * dy) + dx;
page = VideoLocation >> 16;
offset = VideoLocation & 0xFFFF;
gr_vesa_setpage( page );
if ( (offset + (x2-x1+1)) < 65536 ) {
// We don't cross a svga page, so blit it fast!
gr_rle_expand_scanline_masked( &vram[offset], src, x1, x2 );
return;
}
count = 0;
while ( i < x1 ) {
color = *src++;
if ( color == RLE_CODE ) return;
if ( (color & RLE_CODE) == RLE_CODE ) {
count = color & NOT_RLE_CODE;
color = *src++;
} else {
// unique
count = 1;
}
i += count;
}
count = i - x1;
i = x1;
// we know have '*count' pixels of 'color'.
if ( x1+count > x2 ) {
count = x2-x1+1;
if (color != TRANSPARENCY_COLOR) {
for ( j=0; j<count; j++ ) {
vram[offset++] = color;
if ( offset >= 65536 ) {
offset -= 65536;
page++;
gr_vesa_setpage(page);
}
}
}
return;
}
if ( color != TRANSPARENCY_COLOR ) {
for ( j=0; j<count; j++ ) {
vram[offset++] = color;
if ( offset >= 65536 ) {
offset -= 65536;
page++;
gr_vesa_setpage(page);
}
}
} else {
offset += count;
if ( offset >= 65536 ) {
offset -= 65536;
page++;
gr_vesa_setpage(page);
}
}
i += count;
while( i <= x2 ) {
color = *src++;
if ( color == RLE_CODE ) return;
if ( (color & RLE_CODE) == RLE_CODE ) {
count = color & NOT_RLE_CODE;
color = *src++;
} else {
// unique
count = 1;
}
// we know have '*count' pixels of 'color'.
if ( i+count <= x2 ) {
if ( color != TRANSPARENCY_COLOR ) {
for ( j=0; j<count; j++ ) {
vram[offset++] = color;
if ( offset >= 65536 ) {
offset -= 65536;
page++;
gr_vesa_setpage(page);
}
}
} else {
offset += count;
if ( offset >= 65536 ) {
offset -= 65536;
page++;
gr_vesa_setpage(page);
}
}
i += count;
} else {
count = x2-i+1;
if ( color != TRANSPARENCY_COLOR ) {
for ( j=0; j<count; j++ ) {
vram[offset++] = color;
if ( offset >= 65536 ) {
offset -= 65536;
page++;
gr_vesa_setpage(page);
}
}
} else {
offset += count;
if ( offset >= 65536 ) {
offset -= 65536;
page++;
gr_vesa_setpage(page);
}
}
i += count;
}
}
}
#endif // __MSDOS__
/* /*
* swaps entries 0 and 255 in an RLE bitmap without uncompressing it * swaps entries 0 and 255 in an RLE bitmap without uncompressing it
* *