void scale_up_bitmap_rle(grs_bitmap *source_bmp, grs_bitmap *dest_bmp, int x0, int y0, int x1, int y1, fix u0, fix v0, fix u1, fix v1, int orientation )
{
fix dv, v;
int y, last_row = -1;
if (orientation & 1) {
int t;
t = u0; u0 = u1; u1 = t;
}
if (orientation & 2) {
int t;
t = v0; v0 = v1; v1 = t;
if (v1 < v0)
v0--;
}
dv = (v1-v0) / (y1-y0);
rls_stretch_scanline_setup( (int)(x1-x0), f2i(u1)-f2i(u0) );
if ( scale_ydelta_minus_1 < 1 ) return;
v = v0;
for (y=y0; y<=y1; y++ ) {
if ( f2i(v) != last_row ) {
last_row = f2i(v);
decode_row( source_bmp, last_row );
}
scale_source_ptr = &scale_rle_data[f2i(u0)];
scale_dest_ptr = &dest_bmp->bm_data[dest_bmp->bm_rowsize*y+x0];
rls_stretch_scanline( );
v += dv;
}
}
void scale_bitmap_cc_asm_rle(grs_bitmap *source_bmp, grs_bitmap *dest_bmp, int x0, int y0, int x1, int y1, fix u0, fix v0, fix u1, fix v1 )
{
fix dv, v;
int y, last_row = -1;
dv = (v1-v0) / (y1-y0);
rls_stretch_scanline_setup( (int)(x1-x0), f2i(u1)-f2i(u0) );
if ( scale_ydelta_minus_1 < 1 ) return;
rls_do_cc_setup_asm();
v = v0;
for (y=y0; y<=y1; y++ ) {
if ( f2i(v) != last_row ) {
last_row = f2i(v);
decode_row( source_bmp, last_row );
}
//scale_source_ptr = &source_bmp->bm_data[source_bmp->bm_rowsize*f2i(v)+f2i(u0)];
scale_source_ptr = &scale_rle_data[f2i(u0)];
scale_dest_ptr = &dest_bmp->bm_data[dest_bmp->bm_rowsize*y+x0];
scale_do_cc_scanline();
v += dv;
}
}
void ResultResponse::decode_first_row() {
if (row_count_ > 0 &&
metadata_ && // Valid metadata required for column count
first_row_.values.empty()) { // Only decode the first row once
first_row_.values.reserve(column_count());
rows_ = decode_row(rows_, this, first_row_.values);
}
}
void _3dfx_BlitScale( grs_bitmap *source_bmp, grs_bitmap *dest_bmp,
int x0, int y0, int x1, int y1,
fix u0, fix v0, fix u1, fix v1, int orient )
{
if ( _3dfx_available )
{
if ( source_bmp->bm_flags & BM_FLAG_RLE )
{
fix u, v, du, dv;
int x, y;
ubyte * sbits;
unsigned long * dbits;
unsigned long * fb;
du = (u1-u0) / (x1-x0);
dv = (v1-v0) / (y1-y0);
v = v0;
grLfbBegin();
grLfbBypassMode( GR_LFBBYPASS_ENABLE );
fb = ( unsigned long * ) grLfbGetWritePtr( GR_BUFFER_BACKBUFFER );
grLfbWriteMode( GR_LFBWRITEMODE_8888 );
guColorCombineFunction( GR_COLORCOMBINE_DECAL_TEXTURE );
for ( y = y0; y <= y1; y++, v += dv )
{
extern ubyte scale_rle_data[];
decode_row( source_bmp, f2i( v ) );
sbits = scale_rle_data + f2i( u0 );
dbits = fb + _3DFX_FB_WIDTH * y + x0;
u = u0;
for ( x = x0; x <= x1; x++ )
{
int pindex = sbits[ u >> 16 ];
if ( pindex != 255 )
*dbits = _3dfx_PaletteToARGB( pindex );
dbits++;
u += du;
}
}
grLfbBypassMode( GR_LFBBYPASS_DISABLE );
grLfbEnd();
}
else
{
virtual bool next() {
if (index_ + 1 >= result_->row_count()) {
return false;
}
++index_;
if (index_ > 0) {
position_ = decode_row(position_, result_, row_.values);
}
return true;
}
static void scale_bitmap_c_rle(grs_bitmap *source_bmp, grs_bitmap *dest_bmp, int x0, int y0, int x1, int y1, fix u0, fix v0, fix u1, fix v1, int orientation )
{
fix du, dv, v;
int y, last_row=-1;
// Rotation doesn't work because explosions are not square!
// -- if (orientation & 4) {
// -- int t;
// -- t = u0; u0 = v0; v0 = t;
// -- t = u1; u1 = v1; v1 = t;
// -- }
du = (u1-u0) / (x1-x0);
dv = (v1-v0) / (y1-y0);
if (orientation & 1) {
u0 = u1;
du = -du;
}
if (orientation & 2) {
v0 = v1;
dv = -dv;
if (dv < 0)
v0--;
}
v = v0;
if (v<0) { //was: Assert(v >= 0);
//Int3(); //this should be checked in higher-level routine
return;
}
for (y=y0; y<=y1; y++ ) {
if ( f2i(v) != last_row ) {
last_row = f2i(v);
decode_row( source_bmp, last_row );
}
scale_row_transparent( scale_rle_data, &dest_bmp->bm_data[dest_bmp->bm_rowsize*y+x0], x1-x0+1, u0, du );
v += dv;
}
}
void scale_bitmap_asm_rle(grs_bitmap *source_bmp, grs_bitmap *dest_bmp, int x0, int y0, int x1, int y1, fix u0, fix v0, fix u1, fix v1 )
{
fix du, dv, v;
int y, last_row=-1;
du = (u1-u0) / (x1-x0);
dv = (v1-v0) / (y1-y0);
v = v0;
for (y=y0; y<=y1; y++ ) {
if ( f2i(v) != last_row ) {
last_row = f2i(v);
decode_row( source_bmp, last_row );
}
scale_row_asm_transparent( scale_rle_data, &dest_bmp->bm_data[dest_bmp->bm_rowsize*y+x0], x1-x0+1, u0, du );
v += dv;
}
}
int dd_gfx_loadbitmap2D(unsigned short handle, void *buf, int rleflag)
{
HRESULT ddresult;
DDSURFACEDESC ddsd;
char *ptr;
int pitch, i;
grs_bitmap tbmp;
Assert(handle != 0);
if (!dd_gfx_initialized) return 0;
handle--; // Convert to valid handle
RedoLock:
memset(&ddsd, 0, sizeof(ddsd));
ddsd.dwSize = sizeof(ddsd);
ddresult = IDirectDrawSurface_Lock(gfxBitmap[handle].lpdds, NULL, &ddsd, DDLOCK_WAIT, NULL);
if (ddresult != DD_OK) {
if (ddresult == DDERR_SURFACELOST) {
ddresult = IDirectDrawSurface_Restore(gfxBitmap[handle].lpdds);
if (ddresult != DD_OK) {
if (ddresult != DDERR_WRONGMODE) {
logentry("DDGFX::Restore::Surface err: %x\n", ddresult);
return 1;
}
else {
LPDIRECTDRAWSURFACE lpdds;
DDCOLORKEY ddck;
IDirectDrawSurface_Release(lpdds);
gfxBitmap[handle].lpdds = NULL;
memset(&ddsd, 0, sizeof(ddsd));
ddsd.dwSize = sizeof(ddsd);
ddsd.dwFlags = DDSD_CAPS | DDSD_HEIGHT | DDSD_WIDTH;
ddsd.ddsCaps.dwCaps = DDSCAPS_OFFSCREENPLAIN | DDSCAPS_VIDEOMEMORY;
ddsd.dwWidth = gfxBitmap[handle].w;
ddsd.dwHeight = gfxBitmap[handle].h;
ddresult = IDirectDraw_CreateSurface(_lpDD, &ddsd, &lpdds, NULL);
if (ddresult != DD_OK) {
mprintf((0, "DDGFX: Failed to restore vidmem 2d bitmap.\n"));
return 1;
}
ddck.dwColorSpaceLowValue = TRANSPARENCY_COLOR;
ddck.dwColorSpaceHighValue = TRANSPARENCY_COLOR;
IDirectDrawSurface_SetColorKey(lpdds, DDCKEY_SRCBLT, &ddck);
gfxBitmap[handle].lpdds = lpdds;
}
}
goto RedoLock;
}
else {
mprintf((0, "DDGFX:Unable to lock surface!!\n"));
return 1;
}
}
// Locked!
ptr = ddsd.lpSurface;
pitch = ddsd.lPitch;
gr_init_bitmap(&tbmp, BM_LINEAR, 0,0,gfxBitmap[handle].w, gfxBitmap[handle].h, gfxBitmap[handle].w, buf);
if (rleflag) tbmp.bm_flags = BM_FLAG_RLE;
for(i = 0; i < gfxBitmap[handle].h; i++)
{
extern ubyte scale_rle_data[];
if (rleflag) {
decode_row(&tbmp,i);
memcpy(ptr+(i*pitch), scale_rle_data, gfxBitmap[handle].w);
}
else memcpy(ptr+(i*pitch), (ubyte*)(buf)+(i*gfxBitmap[handle].w), gfxBitmap[handle].w);
}
IDirectDrawSurface_Unlock(gfxBitmap[handle].lpdds, ptr);
// Unlocked...
return 0;
}
unsigned char *
simage_gif_load(std::istream& fin,
int *width_ret,
int *height_ret,
int *numComponents_ret,
GifImageStream** obj)
{
int i, j, n, row, col, width, height, extcode;
unsigned char * rowdata;
unsigned char * buffer, * ptr;
unsigned char bg;
int transparent, delaytime;
GifRecordType recordtype;
GifByteType * extension;
GifFileType * giffile;
GifColorType * bgcol;
/* The way an interlaced image should be read - offsets and jumps */
int interlacedoffset[] = { 0, 4, 2, 1 };
int interlacedjumps[] = { 8, 8, 4, 2 };
#if (GIFLIB_MAJOR >= 5)
int Error;
giffile = DGifOpen(&fin,gif_read_stream, &Error);
#else
giffile = DGifOpen(&fin,gif_read_stream);
#endif
if (!giffile)
{
giferror = ERR_OPEN;
return NULL;
}
transparent = -1; /* no transparent color by default */
delaytime = 8; /* delay time of a frame */
n = giffile->SHeight * giffile->SWidth;
buffer = new unsigned char [n * 4];
if (!buffer)
{
giferror = ERR_MEM;
return NULL;
}
rowdata = new unsigned char [giffile->SWidth];
if (!rowdata)
{
giferror = ERR_MEM;
delete [] buffer;
return NULL;
}
bg = giffile->SBackGroundColor;
if (giffile->SColorMap && bg < giffile->SColorMap->ColorCount)
{
bgcol = &giffile->SColorMap->Colors[bg];
}
else bgcol = NULL;
ptr = buffer;
for (i = 0; i < n; i++)
{
if (bgcol)
{
*ptr++ = bgcol->Red;
*ptr++ = bgcol->Green;
*ptr++ = bgcol->Blue;
*ptr++ = 0xff;
}
else
{
*ptr++ = 0x00;
*ptr++ = 0x00;
*ptr++ = 0x00;
*ptr++ = 0xff;
}
}
/* Scan the content of the GIF file and load the image(s) in: */
int gif_num=0;
do
{
if (DGifGetRecordType(giffile, &recordtype) == GIF_ERROR)
{
giferror = ERR_READ;
delete [] buffer;
delete [] rowdata;
return NULL;
}
switch (recordtype)
{
case IMAGE_DESC_RECORD_TYPE:
/* start recording image stream if more than one image found */
gif_num++;
if ( gif_num==2 )
{
*obj = new GifImageStream;
(*obj)->addToImageStream( giffile->SWidth, giffile->SHeight, 1, 4, delaytime, buffer );
unsigned char* destbuffer = new unsigned char [n * 4];
buffer = (unsigned char*)memcpy( destbuffer, buffer, n*4 );
}
if (DGifGetImageDesc(giffile) == GIF_ERROR)
{
giferror = ERR_READ;
delete [] buffer;
delete [] rowdata;
return NULL;
}
/* subimage position in composite image */
row = giffile->Image.Top;
col = giffile->Image.Left;
width = giffile->Image.Width;
height = giffile->Image.Height;
if (giffile->Image.Left + giffile->Image.Width > giffile->SWidth ||
giffile->Image.Top + giffile->Image.Height > giffile->SHeight)
{
/* image is not confined to screen dimension */
giferror = ERR_READ;
delete [] buffer;
delete [] rowdata;
return NULL;
}
if (giffile->Image.Interlace)
{
//fprintf(stderr,"interlace\n");
/* Need to perform 4 passes on the images: */
for (i = 0; i < 4; i++)
{
for (j = row + interlacedoffset[i]; j < row + height;
j += interlacedjumps[i])
{
if (DGifGetLine(giffile, rowdata, width) == GIF_ERROR)
{
giferror = ERR_READ;
delete [] buffer;
delete [] rowdata;
return NULL;
}
else decode_row(giffile, buffer, rowdata, col, j, width, transparent);
}
}
}
else
{
for (i = 0; i < height; i++, row++)
{
if (DGifGetLine(giffile, rowdata, width) == GIF_ERROR)
{
giferror = ERR_READ;
delete [] buffer;
delete [] rowdata;
return NULL;
}
else decode_row(giffile, buffer, rowdata, col, row, width, transparent);
}
}
// Record gif image stream
if ( *obj && obj )
{
(*obj)->addToImageStream( giffile->SWidth, giffile->SHeight, 1, 4, delaytime, buffer );
unsigned char* destbuffer = new unsigned char [n * 4];
buffer = (unsigned char*)memcpy( destbuffer, buffer, n*4 );
}
break;
case EXTENSION_RECORD_TYPE:
/* Skip any extension blocks in file: */
if (DGifGetExtension(giffile, &extcode, &extension) == GIF_ERROR)
{
giferror = ERR_READ;
delete [] buffer;
delete [] rowdata;
return NULL;
}
/* transparent test from the gimp gif-plugin. Open Source rulez! */
else if (extcode == 0xf9)
{
if (extension[0] >= 4 && extension[1] & 0x1) transparent = extension[4];
else transparent = -1;
delaytime = (extension[3]<<8)+extension[2]; // minimum unit 1/100s, so 8 here means 8/100s
}
while (extension != NULL)
{
if (DGifGetExtensionNext(giffile, &extension) == GIF_ERROR)
{
giferror = ERR_READ;
delete [] buffer;
delete [] rowdata;
return NULL;
}
}
break;
case TERMINATE_RECORD_TYPE:
break;
default: /* Should be trapped by DGifGetRecordType. */
break;
}
}
while (recordtype != TERMINATE_RECORD_TYPE);
// Delete the last allocated buffer to avoid memory leaks if we using GifImageStream
if ( obj && *obj )
{
delete [] buffer;
buffer = 0;
}
delete [] rowdata;
*width_ret = giffile->SWidth;
*height_ret = giffile->SHeight;
*numComponents_ret = 4;
#if (GIFLIB_MAJOR >= 5&& !(GIFLIB_MAJOR == 5 && GIFLIB_MINOR == 0))
DGifCloseFile(giffile, &Error);
#else
DGifCloseFile(giffile);
#endif
return buffer;
}
void ResultResponse::decode_first_row() {
if (row_count_ > 0) {
first_row_.values.reserve(column_count());
rows_ = decode_row(rows_, this, first_row_.values);
}
}
