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); } }