bitmap.__h File Reference

#include "bitmap.h"
#include "bitmap._h"

Go to the source code of this file.

Compounds
struct	geBitmap
struct	geBitmap_Palette
Defines
#define	GEBM_VERSION_MAJOR   (0x0004)
#define	GEBM_VERSION_MINOR   (0x0000)
#define	MAXMIPLEVELS   (8)
#define	PALETTE_FORMAT_DEFAULT   (GE_PIXELFORMAT_24BIT_RGB)
#define	ALPHA_TO_TRANSPARENCY_THRESHOLD   (80)
Functions
geBoolean	geBitmap_IsValid (const geBitmap *Bmp)
geBoolean	geBitmap_Info_IsValid (const geBitmap_Info *Info)
geBoolean	geBitmap_Palette_IsValid (const geBitmap_Palette *Pal)
geBoolean	geBitmap_BlitMipRect (const geBitmap *Src, int SrcMip, int SrcX, int SrcY, geBitmap *Dst, int DstMip, int DstX, int DstY, int SizeX, int SizeY)
geBitmap *	geBitmap_CreateLock_CopyInfo (geBitmap *BmpSrc, int LockCnt, int mip)
geBitmap *	geBitmap_CreateLockFromMip (geBitmap *Src, int mip, gePixelFormat Format, geBoolean HasColorKey, uint32 ColorKey, int LockCnt)
geBitmap *	geBitmap_CreateLockFromMipSystem (geBitmap *Src, int mip, int LockCnt)
geBitmap *	geBitmap_CreateLockFromMipOnDriver (geBitmap *Src, int mip, int LockCnt)
geBoolean	geBitmap_UnLock_NoChange (geBitmap *Bmp)
geBoolean	geBitmap_UnLockArray_NoChange (geBitmap **Locks, int Size)
geBoolean	geBitmap_Update_SystemToDriver (geBitmap *Bmp)
geBoolean	geBitmap_Update_DriverToSystem (geBitmap *Bmp)
geBoolean	geBitmap_MakeSystemMips (geBitmap *Bmp, int low, int high)
geBoolean	geBitmap_UpdateMips_Data (geBitmap_Info *FmInfo, void *FmBits, geBitmap_Info *ToInfo, void *ToBits)
geBoolean	geBitmap_UpdateMips_System (geBitmap *Bmp, int fm, int to)
geBoolean	geBitmap_UsesColorKey (const geBitmap *Bmp)
void	geBitmap_MakeMipInfo (geBitmap_Info *Src, int mip, geBitmap_Info *Into)
geBoolean	geBitmap_MakeDriverLockInfo (geBitmap *Bmp, int mip, geBitmap_Info *Into)
geBoolean	geBitmap_AllocSystemMip (geBitmap *Bmp, int mip)
geBoolean	geBitmap_AllocPalette (geBitmap *Bmp, gePixelFormat Format, DRV_Driver *Driver)
geBoolean	geBitmap_ReadInfo (geBitmap *Bmp, geVFile *F)
geBoolean	geBitmap_WriteInfo (const geBitmap *Bmp, geVFile *F)
geBoolean	geBitmap_FixDriverFlags (uint32 *pFlags)

---

Define Documentation

#define ALPHA_TO_TRANSPARENCY_THRESHOLD   (80)

Definition at line 43 of file bitmap.__h. Referenced by BlitData_DePalettize(), BlitData_FromSeparateAlpha(), and BlitData_Raw().

#define GEBM_VERSION_MAJOR   (0x0004)

Definition at line 36 of file bitmap.__h.

#define GEBM_VERSION_MINOR   (0x0000)

Definition at line 37 of file bitmap.__h.

#define MAXMIPLEVELS   (8)

Definition at line 39 of file bitmap.__h. Referenced by geBitmap_CreateLockFromMip(), geBitmap_CreateLockFromMipSystem(), geBitmap_Info_IsValid(), geBitmap_LockForRead(), geBitmap_LockForReadNative(), geBitmap_LockForWrite(), geBitmap_LockForWriteFormat(), geBitmap_MakeMipInfo(), geBitmap_MakeSystemMips(), geBitmap_RefreshMips(), geBitmap_Update_DriverToSystem(), geBitmap_Update_SystemToDriver(), geBitmap_UpdateMips(), and geBitmap_UpdateMips_System().

#define PALETTE_FORMAT_DEFAULT   (GE_PIXELFORMAT_24BIT_RGB)

Definition at line 41 of file bitmap.__h. Referenced by geBitmap_BlitData_Sub().

---

Function Documentation

geBoolean geBitmap_AllocPalette (  geBitmap *  Bmp, gePixelFormat  Format, DRV_Driver *  Driver )

Definition at line 327 of file bitmap.c. References geBitmap_Palette::ColorKey, geBitmap_Info::ColorKey, geBitmap_Palette::ColorKeyIndex, geBitmap::DriverHandle, geBitmap_Palette::DriverHandle, geBitmap::DriverInfo, geBitmap_Info::Format, geBitmap_Palette::Format, GE_FALSE, GE_PIXELFORMAT_32BIT_ARGB, GE_PIXELFORMAT_32BIT_XRGB, GE_PIXELFORMAT_8BIT_PAL, GE_TRUE, geBitmap_Palette_Create(), geBitmap_Palette_CreateCopy(), geBitmap_Palette_CreateFromDriver(), geBoolean, geErrorLog_AddString, gePixelFormat_HasGoodAlpha(), gePixelFormat_IsRaw(), geBitmap_Info::HasColorKey, geBitmap_Palette::HasColorKey, geBitmap::Info, NULL, geBitmap_Info::Palette, and DRV_Driver::THandle_SetPalette. Referenced by geBitmap_BlitData_Sub(), and geBitmap_SetPalette(). { geBitmap_Info * BmpInfo; assert(Bmp); if ( Driver ) BmpInfo = &(Bmp->DriverInfo); else BmpInfo = &(Bmp->Info); if ( ! gePixelFormat_IsRaw(Format) ) Format = GE_PIXELFORMAT_32BIT_XRGB; if ( ! BmpInfo->Palette ) { assert( BmpInfo->Format == GE_PIXELFORMAT_8BIT_PAL ); if ( Driver ) { geBoolean BmpHasAlpha; BmpHasAlpha = GE_FALSE; if ( gePixelFormat_HasGoodAlpha(Bmp->Info.Format) ) BmpHasAlpha = GE_TRUE; else if ( Bmp->Info.Palette && gePixelFormat_HasGoodAlpha(Bmp->Info.Palette->Format) ) BmpHasAlpha = GE_TRUE; if ( BmpHasAlpha || (Bmp->Info.HasColorKey && ! Bmp->DriverInfo.HasColorKey ) ) Format = GE_PIXELFORMAT_32BIT_ARGB; BmpInfo->Palette = geBitmap_Palette_CreateFromDriver(Driver,Format,256); } else { BmpInfo->Palette = geBitmap_Palette_Create(Format,256); } } if ( ! BmpInfo->Palette ) return GE_FALSE; if ( BmpInfo->HasColorKey ) { if ( ! BmpInfo->Palette->HasColorKey ) { BmpInfo->Palette->HasColorKey = GE_TRUE; BmpInfo->Palette->ColorKey = 1; // <> } BmpInfo->Palette->ColorKeyIndex = BmpInfo->ColorKey; } if ( Driver ) { assert( Bmp->DriverHandle ); assert( BmpInfo->Palette->DriverHandle ); if ( ! Driver->THandle_SetPalette(Bmp->DriverHandle,BmpInfo->Palette->DriverHandle) ) { geErrorLog_AddString(-1,"AllocPal : THandle_SetPalette", NULL); return GE_FALSE; } } if ( ! Bmp->Info.Palette ) { Bmp->Info.Palette = geBitmap_Palette_CreateCopy(BmpInfo->Palette); } return GE_TRUE; }

geBoolean geBitmap_AllocSystemMip (  geBitmap *  Bmp, int  mip )

Definition at line 303 of file bitmap.c. References geBitmap::Data, GE_FALSE, GE_TRUE, geBitmap_MipBytes(), geBoolean, geRam_Allocate, geBitmap::LockOwner, and NULL. Referenced by geBitmap_CreateFromFile(), geBitmap_CreateLockFromMip(), geBitmap_MakeSystemMips(), geBitmap_ReadFromBMP(), geBitmap_ReadFromTGA(), geBitmap_SetFormat(), geBitmap_Update_DriverToSystem(), and geBitmap_UpdateMips_System(). { if ( ! Bmp ) { return GE_FALSE; } if ( Bmp->LockOwner && mip != 0 ) return GE_FALSE; if ( ! Bmp->Data[mip] ) { int bytes; bytes = geBitmap_MipBytes(Bmp,mip); if ( bytes == 0 ) { Bmp->Data[mip] = NULL; return GE_TRUE; } Bmp->Data[mip] = geRam_Allocate( bytes ); } return (Bmp->Data[mip]) ? GE_TRUE : GE_FALSE; }

geBoolean geBitmap_BlitMipRect (  const geBitmap *  Src, int  SrcMip, int  SrcX, int  SrcY, geBitmap *  Dst, int  DstMip, int  DstX, int  DstY, int  SizeX, int  SizeY )

Definition at line 2938 of file bitmap.c. References geBitmap::DriverHandle, geBitmap::DriverInfo, geBitmap_Info::Format, GE_FALSE, GE_TRUE, geBitmap_BlitData(), geBitmap_GetBits(), geBitmap_LockForReadNative(), geBitmap_LockForWrite(), geBitmap_UnLock(), geBoolean, geErrorLog_AddString, gePixelFormat_BytesPerPel(), geBitmap_Info::Height, geBitmap::Info, geBitmap::LockCount, geBitmap::LockOwner, min, NULL, SizeX, SizeY, geBitmap_Info::Stride, uint8, and geBitmap_Info::Width. Referenced by geBitmap_Blit(), geBitmap_BlitBestMip(), geBitmap_BlitBitmap(), and geBitmap_BlitMip(). { geBitmap * SrcLock=NULL,* DstLock=NULL; geBoolean SrcUnLock,DstUnLock; geBitmap_Info *SrcLockInfo,*DstLockInfo; uint8 *SrcBits,*DstBits; assert(Src && Dst); assert( Src != Dst ); // <> if Src == Dst we could still do this, but we assert SrcMip != DstMip & be smart SrcUnLock = DstUnLock = GE_FALSE; if ( Src->LockOwner ) { assert( Src->LockOwner->LockCount ); if ( SrcMip != 0 ) { geErrorLog_AddString(-1,"BlitMipRect : Src is a lock and mip != 0", NULL); goto fail; } SrcLock = (geBitmap *)Src; } else { if ( ! geBitmap_LockForReadNative((geBitmap *)Src,&SrcLock,SrcMip,SrcMip) ) { geErrorLog_AddString(-1,"BlitMipRect : LockForReadNative", NULL); goto fail; } SrcUnLock = GE_TRUE; } if ( Dst->LockOwner ) { if ( DstMip != 0 ) goto fail; // if ( Dst->LockOwner->LockCount >= 0 ) // goto fail; // {} can't check this, cuz we use _BlitMip to create locks for read DstLock = Dst; } else { if ( ! geBitmap_LockForWrite(Dst,&DstLock,DstMip,DstMip) ) { geErrorLog_AddString(-1,"BlitMipRect : LockForWrite", NULL); goto fail; } DstUnLock = GE_TRUE; } Src = Dst = NULL; if ( SrcLock->DriverHandle ) SrcLockInfo = &(SrcLock->DriverInfo); else SrcLockInfo = &(SrcLock->Info); if ( DstLock->DriverHandle ) DstLockInfo = &(DstLock->DriverInfo); else DstLockInfo = &(DstLock->Info); if ( ! (SrcBits = geBitmap_GetBits(SrcLock)) || ! (DstBits = geBitmap_GetBits(DstLock)) ) { geErrorLog_AddString(-1,"BlitMipRect : GetBits", NULL); goto fail; } if ( SizeX < 0 ) SizeX = min(SrcLockInfo->Width,DstLockInfo->Width); if ( SizeY < 0 ) SizeY = min(SrcLockInfo->Height,DstLockInfo->Height); if (( (SrcX + SizeX) > SrcLockInfo->Width ) || ( (SrcY + SizeY) > SrcLockInfo->Height) || ( (DstX + SizeX) > DstLockInfo->Width ) || ( (DstY + SizeY) > DstLockInfo->Height)) { geErrorLog_AddString(-1,"BlitMipRect : dimensions bad", NULL); goto fail; } SrcBits += gePixelFormat_BytesPerPel(SrcLockInfo->Format) * ( SrcY * SrcLockInfo->Stride + SrcX ); DstBits += gePixelFormat_BytesPerPel(DstLockInfo->Format) * ( DstY * DstLockInfo->Stride + DstX ); // _BlitMipRect : made palette if ( ! geBitmap_BlitData( SrcLockInfo,SrcBits,SrcLock, DstLockInfo,DstBits,DstLock, SizeX,SizeY) ) { goto fail; } if ( SrcUnLock ) geBitmap_UnLock(SrcLock); if ( DstUnLock ) geBitmap_UnLock(DstLock); return GE_TRUE; fail: if ( SrcUnLock ) geBitmap_UnLock(SrcLock); if ( DstUnLock ) geBitmap_UnLock(DstLock); return GE_FALSE; }

geBitmap* geBitmap_CreateLock_CopyInfo (  geBitmap *  BmpSrc, int  LockCnt, int  mip )

Definition at line 851 of file bitmap.c. References geBitmap::Driver, geBitmap::DriverFlags, geBitmap::DriverGamma, geBitmap::DriverGammaLast, geBitmap::DriverInfo, geBitmap_Create_Base(), geBitmap_CreateRef(), geBitmap_IsValid(), geBitmap_MakeMipInfo(), geBitmap::Info, geBitmap::LockCount, geBitmap::LockOwner, NULL, geBitmap_Info::Palette, and geBitmap::PreferredFormat. Referenced by geBitmap_CreateLockFromMip(), geBitmap_CreateLockFromMipOnDriver(), and geBitmap_CreateLockFromMipSystem(). { geBitmap * Bmp; assert( geBitmap_IsValid(BmpSrc) ); // all _CreateLocks go through here Bmp = geBitmap_Create_Base(); if ( ! Bmp ) return NULL; geBitmap_MakeMipInfo(&(BmpSrc->Info),mip,&(Bmp->Info)); geBitmap_MakeMipInfo(&(BmpSrc->DriverInfo),mip,&(Bmp->DriverInfo)); Bmp->DriverFlags = BmpSrc->DriverFlags; Bmp->DriverGamma = BmpSrc->DriverGamma; Bmp->DriverGammaLast = BmpSrc->DriverGammaLast; Bmp->Info.Palette = NULL; Bmp->DriverInfo.Palette = NULL; Bmp->Driver = BmpSrc->Driver; Bmp->PreferredFormat= BmpSrc->PreferredFormat; Bmp->LockOwner = BmpSrc; geBitmap_CreateRef(BmpSrc); // we do a _Destroy() in UnLock() BmpSrc->LockCount += LockCnt; return Bmp; }

geBitmap* geBitmap_CreateLockFromMip (  geBitmap *  Src, int  mip, gePixelFormat  Format, geBoolean  HasColorKey, uint32  ColorKey, int  LockCnt )

Definition at line 895 of file bitmap.c. References geBitmap::Alpha, geBitmap_Info::ColorKey, geBitmap::Data, geBitmap::DriverHandle, geBitmap::DriverInfo, geBitmap_Info::Format, GE_BOOLSAME, GE_PIXELFORMAT_8BIT_GRAY, geBitmap_AllocSystemMip(), geBitmap_BlitMip(), geBitmap_CreateLock_CopyInfo(), geBitmap_CreateLockFromMipOnDriver(), geBitmap_CreateLockFromMipSystem(), geBitmap_Destroy(), geBitmap_IsValid(), geBitmap_LockForRead(), geBitmap_MakeSystemMips(), geBitmap_Palette_CreateRef(), geBitmap_Update_DriverToSystem(), geErrorLog_AddString, gePixelFormat_BytesPerPel(), gePixelFormat_HasGoodAlpha(), gePixelFormat_HasPalette(), geBitmap_Info::HasColorKey, geBitmap::Info, geBitmap_Info::MaximumMip, MAXMIPLEVELS, geBitmap_Info::MinimumMip, NULL, geBitmap_Info::Palette, geBitmap_Info::Stride, and geBitmap_Info::Width. Referenced by geBitmap_LockForRead(). { geBitmap * Ret; assert( geBitmap_IsValid(Src) ); if ( mip < 0 || mip >= MAXMIPLEVELS ) return NULL; // LockForRead always goes through here if ( gePixelFormat_BytesPerPel(Format) < 1 ) return NULL; if ( Src->DriverInfo.Format == Format && GE_BOOLSAME(Src->DriverInfo.HasColorKey,HasColorKey) && (!HasColorKey || Src->DriverInfo.ColorKey == ColorKey) && mip >= Src->DriverInfo.MinimumMip && mip <= Src->DriverInfo.MaximumMip ) { return geBitmap_CreateLockFromMipOnDriver(Src,mip,LockCnt); } if ( Src->DriverHandle ) { if ( ! geBitmap_Update_DriverToSystem(Src) ) { return NULL; } } if ( ! Src->Data[mip] ) { if ( ! geBitmap_MakeSystemMips(Src,mip,mip) ) return NULL; } if ( Src->Info.Format == Format && GE_BOOLSAME(Src->Info.HasColorKey,HasColorKey) && (!HasColorKey || Src->Info.ColorKey == ColorKey) ) { return geBitmap_CreateLockFromMipSystem(Src,mip,LockCnt); } Ret = geBitmap_CreateLock_CopyInfo(Src,LockCnt,mip); if ( ! Ret ) return NULL; Ret->Info.Stride = Ret->Info.Width; // {} ? Ret->Info.Format = Format; Ret->Info.ColorKey = ColorKey; Ret->Info.HasColorKey = HasColorKey; if ( gePixelFormat_HasPalette(Format) && Src->Info.Palette ) { Ret->Info.Palette = Src->Info.Palette; geBitmap_Palette_CreateRef(Ret->Info.Palette); } assert( Ret->Alpha == NULL ); if ( ! gePixelFormat_HasGoodAlpha(Format) && Src->Alpha ) { if ( ! geBitmap_LockForRead(Src->Alpha,&(Ret->Alpha),mip,mip,GE_PIXELFORMAT_8BIT_GRAY,0,0) ) { geErrorLog_AddString(-1,"CreateLockFromMip : LockForRead failed", NULL); geBitmap_Destroy(&Ret); return NULL; } assert( Ret->Alpha ); } assert( geBitmap_IsValid(Ret) ); if ( ! geBitmap_AllocSystemMip(Ret,0) ) { geBitmap_Destroy(&Ret); return NULL; } if ( ! geBitmap_BlitMip( Src, mip, Ret, 0 ) ) { geErrorLog_AddString(-1,"CreateLockFromMip : BlitMip failed", NULL); geBitmap_Destroy(&Ret); return NULL; } return Ret; }

geBitmap* geBitmap_CreateLockFromMipOnDriver (  geBitmap *  Src, int  mip, int  LockCnt )

Definition at line 1035 of file bitmap.c. References geBitmap::DataOwner, geBitmap::Driver, geBitmap::DriverHandle, geBitmap::DriverInfo, geBitmap::DriverMipLock, geBitmap_Info::Format, geBitmap_CreateLock_CopyInfo(), geBitmap_CreateRef(), geBitmap_Destroy(), geBitmap_IsValid(), geBitmap_MakeDriverLockInfo(), geBitmap_Palette_CreateRef(), geErrorLog_AddString, gePixelFormat_BytesPerPel(), geBitmap::Info, geBitmap_Info::MaximumMip, geBitmap_Info::MinimumMip, NULL, and geBitmap_Info::Palette. Referenced by geBitmap_CreateLockFromMip(), geBitmap_LockForReadNative(), geBitmap_LockForWrite(), and geBitmap_LockForWriteFormat(). { geBitmap * Ret; assert( geBitmap_IsValid(Src) ); if ( ! Src->DriverHandle || ! Src->Driver || Src->DriverMipLock || mip < Src->DriverInfo.MinimumMip || mip > Src->DriverInfo.MaximumMip ) return NULL; // the driver can never have Wavelet data // {} it could have S3TC data, though.. assert( gePixelFormat_BytesPerPel(Src->DriverInfo.Format) > 0); Ret = geBitmap_CreateLock_CopyInfo(Src,LockCnt,mip); if ( ! Ret ) return NULL; Ret->DriverMipLock = mip; Ret->DriverHandle = Src->DriverHandle; Ret->DataOwner = Src; geBitmap_CreateRef(Src); Ret->DriverInfo.Palette = Src->DriverInfo.Palette; if ( ! geBitmap_MakeDriverLockInfo(Ret,mip,&(Ret->DriverInfo)) ) { geErrorLog_AddString(-1,"CreateLockFromMipOnDriver : UpdateInfo failed", NULL); geBitmap_Destroy(&Ret); return NULL; } assert(Ret->DriverInfo.Palette == Src->DriverInfo.Palette); Ret->Info = Ret->DriverInfo; //{} shouldn't be necessary if ( Ret->DriverInfo.Palette ) geBitmap_Palette_CreateRef(Ret->DriverInfo.Palette); if ( Ret->Info.Palette ) geBitmap_Palette_CreateRef(Ret->Info.Palette); assert( geBitmap_IsValid(Ret) ); return Ret; }

geBitmap* geBitmap_CreateLockFromMipSystem (  geBitmap *  Src, int  mip, int  LockCnt )

Definition at line 988 of file bitmap.c. References geBitmap::Alpha, geBitmap::Data, geBitmap::DataOwner, geBitmap_Info::Format, GE_PIXELFORMAT_8BIT_GRAY, geBitmap_CreateLock_CopyInfo(), geBitmap_CreateRef(), geBitmap_Destroy(), geBitmap_IsValid(), geBitmap_LockForRead(), geBitmap_MakeSystemMips(), geBitmap_Palette_CreateRef(), geErrorLog_AddString, gePixelFormat_BytesPerPel(), gePixelFormat_HasGoodAlpha(), geBitmap::Info, MAXMIPLEVELS, geBitmap_Info::MinimumMip, NULL, and geBitmap_Info::Palette. Referenced by geBitmap_CreateLockFromMip(), geBitmap_LockForReadNative(), geBitmap_LockForWrite(), and geBitmap_LockForWriteFormat(). { geBitmap * Ret; assert( geBitmap_IsValid(Src) ); if ( mip < Src->Info.MinimumMip || mip >= MAXMIPLEVELS ) return NULL; if ( gePixelFormat_BytesPerPel(Src->Info.Format) < 1 ) return NULL; if ( ! Src->Data[mip] ) { if ( ! geBitmap_MakeSystemMips(Src,mip,mip) ) return NULL; } Ret = geBitmap_CreateLock_CopyInfo(Src,LockCnt,mip); if ( ! Ret ) return NULL; Ret->Data[0] = Src->Data[mip]; Ret->Info.Palette = Src->Info.Palette; if ( Ret->Info.Palette ) geBitmap_Palette_CreateRef(Ret->Info.Palette); Ret->DataOwner = Src; geBitmap_CreateRef(Src); assert( Ret->Alpha == NULL ); if ( ! gePixelFormat_HasGoodAlpha(Src->Info.Format) && Src->Alpha ) { if ( ! geBitmap_LockForRead(Src->Alpha,&(Ret->Alpha),mip,mip,GE_PIXELFORMAT_8BIT_GRAY,0,0) ) { geErrorLog_AddString(-1,"CreateLockFromMipSystem : LockForRead failed", NULL); geBitmap_Destroy(&Ret); return NULL; } assert( Ret->Alpha ); } assert( geBitmap_IsValid(Ret) ); return Ret; }

geBoolean geBitmap_FixDriverFlags (  uint32 *  pFlags  )

Definition at line 1718 of file bitmap.c. References GE_FALSE, GE_TRUE, geBoolean, NumBitsOn(), RDRIVER_PF_3D, RDRIVER_PF_CAN_DO_COLORKEY, RDRIVER_PF_COMBINE_LIGHTMAP, RDRIVER_PF_LIGHTMAP, RDRIVER_PF_MAJOR_MASK, RDRIVER_PF_PALETTE, and uint32. Referenced by geBitmap_SetDriverFlags(). { uint32 DriverFlags; assert(pFlags); DriverFlags = *pFlags; if ( DriverFlags & RDRIVER_PF_COMBINE_LIGHTMAP ) DriverFlags |= RDRIVER_PF_3D; if ( DriverFlags & RDRIVER_PF_CAN_DO_COLORKEY ) { // <> someone is doing this! // bad! DriverFlags ^= RDRIVER_PF_CAN_DO_COLORKEY; // return GE_FALSE; } if ( (DriverFlags & RDRIVER_PF_COMBINE_LIGHTMAP) && (DriverFlags & (RDRIVER_PF_LIGHTMAP | RDRIVER_PF_PALETTE) ) ) return GE_FALSE; if ( NumBitsOn(DriverFlags & RDRIVER_PF_MAJOR_MASK) == 0 ) return GE_FALSE; *pFlags = DriverFlags; return GE_TRUE; }

geBoolean geBitmap_Info_IsValid (  const geBitmap_Info *  Info  )

Definition at line 5525 of file bitmap.c. References geBitmap_Info::Format, GE_FALSE, GE_PIXELFORMAT_COUNT, GE_PIXELFORMAT_NO_DATA, GE_TRUE, geBitmap_Palette_IsValid(), geBoolean, geBitmap_Info::Height, geBitmap_Info::MaximumMip, MAXMIPLEVELS, geBitmap_Info::MinimumMip, geBitmap_Info::Palette, geBitmap_Info::Stride, and geBitmap_Info::Width. Referenced by geBitmap_CreateFromInfo(), and geBitmap_IsValid(). { if ( ! Info ) return GE_FALSE; assert( Info->Width > 0 && Info->Height > 0 && Info->Stride >= Info->Width ); assert( Info->MinimumMip >= 0 && Info->MaximumMip < MAXMIPLEVELS && Info->MinimumMip <= Info->MaximumMip ); assert( Info->Format > GE_PIXELFORMAT_NO_DATA && Info->Format < GE_PIXELFORMAT_COUNT ); // ok to have palette on non-palettized // if ( ! gePixelFormat_HasPalette(Info->Format) && Info->Palette ) // return GE_FALSE; if ( Info->Palette ) if ( ! geBitmap_Palette_IsValid(Info->Palette) ) return GE_FALSE; return GE_TRUE; }

geBoolean geBitmap_IsValid (  const geBitmap *  Bmp  )

Definition at line 5482 of file bitmap.c. Referenced by geSprite_GetBackfaceBitmap(), and geSprite_GetBitmap(). { if ( ! Bmp ) return GE_FALSE; assert( Bmp->RefCount >= 1 ); assert( ! (Bmp->LockCount && Bmp->LockOwner) ); assert( !( (Bmp->DriverDataChanged || Bmp->DriverBitsLocked) && ! Bmp->DriverHandle ) ); assert( ! (Bmp->DriverHandle && ! Bmp->Driver) ); if ( ! geBitmap_Info_IsValid(&(Bmp->Info)) ) return GE_FALSE; if ( Bmp->DriverHandle && ! geBitmap_Info_IsValid(&(Bmp->DriverInfo)) ) return GE_FALSE; if ( Bmp->LockOwner && Bmp->Alpha ) assert( Bmp->Alpha->LockOwner ); if ( Bmp->LockOwner ) { assert(Bmp->LockOwner != Bmp); assert( Bmp->LockOwner->LockCount ); } if ( Bmp->DataOwner ) { assert(Bmp->DataOwner != Bmp); assert( Bmp->DataOwner->RefCount >= 2 ); } if ( Bmp->Alpha ) { assert(Bmp->Alpha != Bmp); if ( ! geBitmap_IsValid(Bmp->Alpha) ) return GE_FALSE; } return GE_TRUE; }

geBoolean geBitmap_MakeDriverLockInfo (  geBitmap *  Bmp, int  mip, geBitmap_Info *  Into )

Definition at line 2847 of file bitmap.c. References geBitmap_Info::ColorKey, geRDriver_THandleInfo::ColorKey, geBitmap_Palette::ColorKeyIndex, geBitmap::Driver, geBitmap::DriverFlags, geBitmap::DriverHandle, geBitmap::DriverInfo, geBitmap::DriverMipLock, geRDriver_PixelFormat::Flags, geRDriver_THandleInfo::Flags, geBitmap_Info::Format, GE_FALSE, GE_TRUE, geBoolean, geErrorLog_AddString, gePixelFormat_HasPalette(), geBitmap_Info::HasColorKey, geBitmap_Palette::HasColorKey, geBitmap_Info::Height, geRDriver_THandleInfo::Height, geBitmap_Info::MaximumMip, geBitmap_Info::MinimumMip, NULL, geBitmap_Info::Palette, geRDriver_THandleInfo::PixelFormat, geRDriver_PixelFormat::PixelFormat, RDRIVER_THANDLE_HAS_COLORKEY, geBitmap_Info::Stride, geRDriver_THandleInfo::Stride, DRV_Driver::THandle_GetInfo, geBitmap_Info::Width, and geRDriver_THandleInfo::Width. Referenced by geBitmap_AttachToDriver(), geBitmap_CreateLockFromMipOnDriver(), and geBitmap_Update_SystemToDriver(). { geRDriver_THandleInfo TInfo; // MakeDriverLockInfo also doesn't full out the full info, so it must be a valid info first! // Bmp also gets some stuff written into him. assert(Bmp && Into); // not necessarily valid if ( ! Bmp->DriverHandle || ! Bmp->Driver || mip < Bmp->DriverInfo.MinimumMip || mip > Bmp->DriverInfo.MaximumMip ) return GE_FALSE; if ( ! Bmp->Driver->THandle_GetInfo(Bmp->DriverHandle,mip,&TInfo) ) { geErrorLog_AddString(-1,"MakeDriverLockInfo : THandle_GetInfo", NULL); return GE_FALSE; } Bmp->DriverMipLock = mip; Bmp->DriverFlags = TInfo.PixelFormat.Flags; Into->Width = TInfo.Width; Into->Height = TInfo.Height; Into->Stride = TInfo.Stride; Into->Format = TInfo.PixelFormat.PixelFormat; Into->ColorKey = TInfo.ColorKey; if ( TInfo.Flags & RDRIVER_THANDLE_HAS_COLORKEY ) Into->HasColorKey = GE_TRUE; else Into->HasColorKey = GE_FALSE; Into->MinimumMip = Into->MaximumMip = mip; if ( gePixelFormat_HasPalette(Into->Format) && Into->Palette && Into->Palette->HasColorKey ) { Into->HasColorKey = GE_TRUE; Into->ColorKey = Into->Palette->ColorKeyIndex; } return GE_TRUE; }

void geBitmap_MakeMipInfo (  geBitmap_Info *  Src, int  mip, geBitmap_Info *  Into )

Definition at line 883 of file bitmap.c. References geBitmap_Info::Height, geBitmap_Info::MaximumMip, MAXMIPLEVELS, geBitmap_Info::MinimumMip, SHIFT_R_ROUNDUP, geBitmap_Info::Stride, and geBitmap_Info::Width. Referenced by geBitmap_CreateLock_CopyInfo(), and geBitmap_Update_DriverToSystem(). { assert( Src && Target ); assert( mip >= 0 && mip < MAXMIPLEVELS ); *Target = *Src; Target->Width = SHIFT_R_ROUNDUP(Target->Width,mip); Target->Height = SHIFT_R_ROUNDUP(Target->Height,mip); Target->Stride = SHIFT_R_ROUNDUP(Target->Stride,mip); Target->MinimumMip = Target->MaximumMip = mip; }

geBoolean geBitmap_MakeSystemMips (  geBitmap *  Bmp, int  low, int  high )

Definition at line 2770 of file bitmap.c. References geBitmap::Data, geBitmap::DataOwner, geBitmap_Info::Format, GE_FALSE, GE_TRUE, geBitmap_AllocSystemMip(), geBitmap_IsValid(), geBitmap_UpdateMips_System(), geBoolean, gePixelFormat_BytesPerPel(), geBitmap::Info, geBitmap::LockOwner, max, geBitmap_Info::MaximumMip, MAXMIPLEVELS, min, and geBitmap_Info::MinimumMip. Referenced by geBitmap_CreateLockFromMip(), geBitmap_CreateLockFromMipSystem(), geBitmap_LockForWrite(), and geBitmap_LockForWriteFormat(). { int mip; assert( geBitmap_IsValid(Bmp) ); // this is that CreateLockFromMip uses to make its new data if ( Bmp->LockOwner ) Bmp = Bmp->LockOwner; // if ( Bmp->LockCount > 0 ) // return GE_FALSE; if ( Bmp->DataOwner ) return GE_FALSE; // {} for compressed data, just don't make mips and say we did! if ( gePixelFormat_BytesPerPel(Bmp->Info.Format) < 1 ) return GE_TRUE; if ( low < 0 || high >= MAXMIPLEVELS || low > high ) return GE_FALSE; for( mip = low; mip <= high; mip++) { if ( ! Bmp->Data[mip] ) { if ( ! geBitmap_AllocSystemMip(Bmp,mip) ) return GE_FALSE; if ( mip != 0 ) { if ( ! geBitmap_UpdateMips_System(Bmp,mip-1,mip) ) return GE_FALSE; } } } Bmp->Info.MinimumMip = min(Bmp->Info.MinimumMip,low); Bmp->Info.MaximumMip = max(Bmp->Info.MaximumMip,high); return GE_TRUE; }

geBoolean geBitmap_Palette_IsValid (  const geBitmap_Palette *  Pal  )

Definition at line 5546 of file bitmap.c. References geBitmap_Palette::Data, geBitmap_Palette::Driver, geBitmap_Palette::DriverHandle, geBitmap_Palette::Format, GE_FALSE, GE_PIXELFORMAT_COUNT, GE_PIXELFORMAT_NO_DATA, GE_TRUE, geBoolean, geBitmap_Palette::RefCount, and geBitmap_Palette::Size. Referenced by geBitmap_Info_IsValid(), and geBitmap_SetPalette(). { if ( ! Pal ) return GE_FALSE; assert( Pal->Data || Pal->DriverHandle ); assert( !Pal->Data || !Pal->DriverHandle ); assert( (Pal->Driver && Pal->DriverHandle) || (! Pal->Driver && ! Pal->DriverHandle) ); assert( Pal->RefCount >= 1 && Pal->Size >= 1 ); assert( Pal->Format > GE_PIXELFORMAT_NO_DATA && Pal->Format < GE_PIXELFORMAT_COUNT ); return GE_TRUE; }

geBoolean geBitmap_ReadInfo (  geBitmap *  Bmp, geVFile *  F )

Definition at line 4538 of file bitmap.c. References geBitmap::Alpha, geBitmap_Info::ColorKey, geBitmap_Info::Format, GE_FALSE, GE_TRUE, geBoolean, gePixelFormat_BytesPerPel(), gePixelFormat_GetPixel(), geVFile_Read(), geBitmap_Info::HasColorKey, geBitmap_Info::Height, geBitmap::Info, INFO_FLAG_HAS_ALPHA, INFO_FLAG_HAS_CK, INFO_FLAG_HAS_PAL, INFO_FLAG_IF_NOT_LOG2_ARE_BYTE, INFO_FLAG_WH_ARE_LOG2, geBitmap_Info::MaximumMip, geBitmap_Info::Palette, geBitmap::SeekMipCount, geBitmap_Info::Stride, uint16, uint8, and geBitmap_Info::Width. Referenced by geBitmap_CreateFromFile(). { uint8 data[4]; uint8 flags; uint8 b; uint16 w; geBitmap_Info * pi; pi = &(Bmp->Info); if ( ! geVFile_Read(F,data,3) ) return GE_FALSE; flags = data[0]; pi->Format = data[1]; // could go in 5 bits b = data[2]; pi->MaximumMip = (b>>4)&0xF; Bmp->SeekMipCount = (b)&0xF; if ( flags & INFO_FLAG_HAS_PAL ) pi->Palette = (geBitmap_Palette *)1; if ( flags & INFO_FLAG_HAS_ALPHA ) Bmp->Alpha = (geBitmap *)1; if ( flags & INFO_FLAG_WH_ARE_LOG2 ) { int logw,logh; if ( ! geVFile_Read(F,&b,1) ) return GE_FALSE; logw = (b>>4)&0xF; logh = (b )&0xF; pi->Width = 1<<logw; pi->Height= 1<<logh; } else if ( flags & INFO_FLAG_IF_NOT_LOG2_ARE_BYTE ) { if ( ! geVFile_Read(F,&b,1) ) return GE_FALSE; pi->Width = b; if ( ! geVFile_Read(F,&b,1) ) return GE_FALSE; pi->Height = b; } else { if ( ! geVFile_Read(F,&w,2) ) return GE_FALSE; pi->Width = w; if ( ! geVFile_Read(F,&w,2) ) return GE_FALSE; pi->Height = w; } if ( (flags & INFO_FLAG_HAS_CK) && gePixelFormat_BytesPerPel(pi->Format) > 0 ) { uint8 * ptr; pi->HasColorKey = GE_TRUE; if ( ! geVFile_Read(F,data,gePixelFormat_BytesPerPel(pi->Format)) ) return GE_FALSE; ptr = data; pi->ColorKey = gePixelFormat_GetPixel(pi->Format,&ptr); } pi->Stride = pi->Width; return GE_TRUE; }

geBoolean geBitmap_UnLock_NoChange (  geBitmap *  Bmp  )

Definition at line 807 of file bitmap.c. References GE_FALSE, geBitmap_UnLock_Internal(), and geBoolean. Referenced by geBitmap_UnLockArray_NoChange(). { return geBitmap_UnLock_Internal(Bmp,GE_FALSE); }

geBoolean geBitmap_UnLockArray_NoChange (  geBitmap **  Locks, int  Size )

Definition at line 666 of file bitmap.c. References GE_FALSE, GE_TRUE, geBitmap_UnLock_NoChange(), and geBoolean. Referenced by geBitmap_Gamma_Apply(), and geBitmap_UpdateMips(). { int i; geBoolean Ret = GE_TRUE; assert(Locks); for(i=0;i<Size;i++) { if ( ! geBitmap_UnLock_NoChange(Locks[i]) ) Ret = GE_FALSE; } return Ret; }

geBoolean geBitmap_Update_DriverToSystem (  geBitmap *  Bmp  )

Definition at line 2162 of file bitmap.c. References geBitmap::Data, geBitmap::DataOwner, geBitmap::DriverBitsLocked, geBitmap::DriverDataChanged, geBitmap::DriverHandle, geBitmap::DriverInfo, GE_FALSE, GE_TRUE, geBitmap_AllocSystemMip(), geBitmap_BlitData(), geBitmap_Gamma_Apply(), geBitmap_GetBits(), geBitmap_IsValid(), geBitmap_LockForReadNative(), geBitmap_MakeMipInfo(), geBitmap_Palette_Copy(), geBitmap_UnLock(), geBoolean, geErrorLog_AddString, geBitmap_Info::Height, geBitmap::Info, geBitmap::LockCount, geBitmap::LockOwner, Log_Puts, geBitmap_Info::MaximumMip, MAXMIPLEVELS, geBitmap_Info::MinimumMip, geBitmap::Modified, NULL, geBitmap_Info::Palette, and geBitmap_Info::Width. Referenced by geBitmap_CreateLockFromMip(), geBitmap_DetachDriver(), geBitmap_GetAverageColor(), geBitmap_LockForWriteFormat(), geBitmap_SetAlpha(), geBitmap_SetColorKey(), geBitmap_SetGammaCorrection(), and geBitmap_WriteToFile(). { geBitmap *DriverLocks[MAXMIPLEVELS]; geBoolean Ret; int mip; assert( geBitmap_IsValid(Bmp) ); if ( Bmp->LockOwner ) Bmp = Bmp->LockOwner; if ( Bmp->LockCount > 0 || Bmp->DataOwner ) { geErrorLog_AddString(-1,"Update_DriverToSystem : not an original bitmap", NULL); return GE_FALSE; } if ( ! Bmp->DriverHandle ) { geErrorLog_AddString(-1,"Update_DriverToSystem : no driver data", NULL); return GE_FALSE; } if ( ! Bmp->DriverDataChanged ) return GE_TRUE; // bits are on driver; undo the gamma to copy them home Log_Puts("Bitmap : Doing Update_DriverToSystem"); if ( ! geBitmap_Gamma_Apply(Bmp,GE_TRUE) ) // undo the gamma! return GE_FALSE; if ( Bmp->Info.Palette && Bmp->DriverInfo.Palette ) { if ( ! geBitmap_Palette_Copy(Bmp->DriverInfo.Palette,Bmp->Info.Palette) ) { geErrorLog_AddString(-1,"Update_DriverToSystem : Palette_Copy", NULL); } } if ( geBitmap_LockForReadNative(Bmp,DriverLocks, Bmp->DriverInfo.MinimumMip,Bmp->DriverInfo.MaximumMip) ) { Ret = GE_TRUE; for(mip=Bmp->DriverInfo.MinimumMip;mip <=Bmp->DriverInfo.MaximumMip;mip++) { geBitmap *MipBmp; geBitmap_Info SystemInfo; MipBmp = DriverLocks[mip]; if ( Bmp->Modified[mip] ) { void *DriverBits,*SystemBits; DriverBits = geBitmap_GetBits(MipBmp); assert( MipBmp->DriverBitsLocked ); if ( ! geBitmap_AllocSystemMip(Bmp,mip) ) Ret = GE_FALSE; SystemBits = Bmp->Data[mip]; geBitmap_MakeMipInfo(&(Bmp->Info),mip,&SystemInfo); if ( DriverBits && SystemBits ) { // _Update_DriverToSystem // {} palette (not) made in AttachToDriver; must be made in here-> if ( ! geBitmap_BlitData( &(MipBmp->Info), DriverBits, MipBmp, &SystemInfo, SystemBits, Bmp, SystemInfo.Width,SystemInfo.Height) ) Ret = GE_FALSE; } else { Ret = GE_FALSE; } } geBitmap_UnLock(DriverLocks[mip]); } Bmp->DriverDataChanged = GE_FALSE; } else { Ret = GE_FALSE; } if ( ! Ret ) { geErrorLog_AddString(-1,"Update_DriverToSystem : Locking and Blitting error", NULL); } if ( ! geBitmap_Gamma_Apply(Bmp,GE_FALSE) ) // redo the gamma! return GE_FALSE; return Ret; }

geBoolean geBitmap_Update_SystemToDriver (  geBitmap *  Bmp  )

this function is totally hacked out, because what we really need to do is lock Bmp for Read (system) & Write (driver) , but that's illegal! Bmp is a driver BMP the SrcLocks are locks of the system bits. Definition at line 1930 of file bitmap.c. References geBitmap::Alpha, geBitmap::Data, geBitmap::DataOwner, geBitmap::Driver, geBitmap::DriverBitsLocked, geBitmap::DriverDataChanged, geBitmap::DriverFlags, geBitmap::DriverHandle, geBitmap::DriverInfo, geBitmap::DriverMipLock, DstInfo, geBitmap_Info::Format, GE_FALSE, GE_TRUE, geBitmap_AttachToDriver(), geBitmap_BlitData(), geBitmap_DetachDriver(), geBitmap_Gamma_Apply(), geBitmap_GetBits(), geBitmap_IsValid(), geBitmap_LockForReadNative(), geBitmap_MakeDriverLockInfo(), geBitmap_Palette_Destroy(), geBitmap_SetPalette(), geBitmap_UnLockArray(), geBitmap_UpdateMips(), geBoolean, geErrorLog_AddString, gePixelFormat_HasGoodAlpha(), geBitmap_Info::Height, geBitmap::Info, geBitmap::LockCount, geBitmap::LockOwner, geBitmap_Info::MaximumMip, MAXMIPLEVELS, geBitmap_Info::MinimumMip, geBitmap::Modified, NULL, geBitmap_Info::Palette, RDRIVER_PF_ALPHA, RDRIVER_PF_HAS_ALPHA, DRV_Driver::THandle_GetAlpha, DRV_Driver::THandle_Lock, DRV_Driver::THandle_SetAlpha, DRV_Driver::THandle_UnLock, and geBitmap_Info::Width. Referenced by geBitmap_AttachToDriver(), geBitmap_SetAlpha(), geBitmap_SetColorKey(), geBitmap_SetGammaCorrection(), geBitmap_SetPalette(), and geBitmap_UnLock_Internal(). { geBitmap * SrcLocks[MAXMIPLEVELS]; geBoolean Ret,MipsChanged; int mip,mipMin,mipMax; geRDriver_THandle * SaveDriverHandle; geBitmap * SaveAlpha; int SaveMaxMip; assert( geBitmap_IsValid(Bmp) ); if ( Bmp->LockOwner ) Bmp = Bmp->LockOwner; if ( Bmp->LockCount > 0 || Bmp->DataOwner ) { geErrorLog_AddString(-1,"Update_SystemToDriver : not an original bitmap", NULL); return GE_FALSE; } if ( ! Bmp->DriverHandle ) { geErrorLog_AddString(-1,"Update_SystemToDriver : no driver data", NULL); return GE_FALSE; } MipsChanged = GE_FALSE; for(mip=Bmp->DriverInfo.MinimumMip;mip<=Bmp->DriverInfo.MaximumMip;mip++) { if ( Bmp->Modified[mip] && mip != Bmp->Info.MinimumMip ) { assert(Bmp->Data[mip]); MipsChanged = GE_TRUE; } } //make mips after driver blit #if 0 MipsChanged = GE_TRUE; #endif mipMin = Bmp->DriverInfo.MinimumMip; if ( MipsChanged ) mipMax = Bmp->DriverInfo.MaximumMip; else mipMax = mipMin; SaveDriverHandle = Bmp->DriverHandle; Bmp->DriverHandle = NULL; // so Lock() won't use the driver data SaveAlpha = Bmp->Alpha; if ( Bmp->Alpha && ! gePixelFormat_HasGoodAlpha(Bmp->DriverInfo.Format) && (Bmp->DriverFlags & RDRIVER_PF_HAS_ALPHA) ) { // hide the alpha so that it won't be used to make a colorkey in the target // we'll blit it independently later Bmp->Alpha = NULL; } if ( ! geBitmap_LockForReadNative(Bmp,SrcLocks,mipMin,mipMax) ) { geErrorLog_AddString(-1,"Update_SystemToDriver : LockForReadNative", NULL); return GE_FALSE; } Ret = GE_TRUE; Bmp->DriverHandle = SaveDriverHandle; Bmp->Alpha = NULL; // we should have always updated the driver to system before fiddling the system assert( ! Bmp->DriverDataChanged ); for(mip=mipMin;mip <=mipMax;mip++) { geBitmap *SrcMip; void * SrcBits,*DstBits; geBitmap_Info DstInfo; SrcMip = SrcLocks[mip - mipMin]; SrcBits = geBitmap_GetBits(SrcMip); DstInfo = Bmp->DriverInfo; if ( ! geBitmap_MakeDriverLockInfo(Bmp,mip,&DstInfo) ) { geErrorLog_AddString(-1,"Update_SystemToDriver : MakeInfo", NULL); Ret = GE_FALSE; continue; } // Zooma! THandle_Lock might lock the Win16 Lock ! // this is really bad when _BlitData is a wavelet decompress ! // {} try this : decompress to a buffer in memory (on a thread) // then THandle_Lock and just do a (prefetching) memcpy //#pragma message("Bitmap : minimize time spent in a THandle_Lock!") if ( ! Bmp->Driver->THandle_Lock(SaveDriverHandle,mip,&DstBits) ) { geErrorLog_AddString(-1,"Update_SystemToDriver : THandle_Lock", NULL); Ret = GE_FALSE; continue; } if ( ! SrcBits || ! DstBits ) { geErrorLog_AddString(-1,"Update_SystemToDriver : No Bits", NULL); Ret = GE_FALSE; continue; } assert( DstInfo.Palette == Bmp->DriverInfo.Palette ); if ( ! geBitmap_BlitData( &(SrcMip->Info),SrcBits,SrcMip, &DstInfo, DstBits,Bmp, SrcMip->Info.Width,SrcMip->Info.Height) ) { geErrorLog_AddString(-1,"Update_SystemToDriver : BlitData", NULL); //assert(0); Ret = GE_FALSE; continue; } if ( ! Bmp->Driver->THandle_UnLock(SaveDriverHandle,mip) ) { geErrorLog_AddString(-1,"Update_SystemToDriver : THandle_UnLock", NULL); Ret = GE_FALSE; continue; } // normally this would be done by the Bitmap_UnLock , // but since we don't lock .. if ( DstInfo.Palette != Bmp->DriverInfo.Palette ) { //assert( OldDstPal == NULL ); geBitmap_SetPalette(Bmp,DstInfo.Palette); geBitmap_Palette_Destroy(&(DstInfo.Palette)); // must destroy here, since DstInfo is on the stack! } } Bmp->Alpha = SaveAlpha; Bmp->DriverBitsLocked = GE_FALSE; Bmp->DriverMipLock = 0; Bmp->DriverDataChanged = GE_FALSE; geBitmap_UnLockArray(SrcLocks, mipMax - mipMin + 1 ); if ( ! Ret ) { geErrorLog_AddString(-1,"Update_SystemToDriver : Locking and Blitting error", NULL); } if ( Bmp->Alpha && ! gePixelFormat_HasGoodAlpha(Bmp->DriverInfo.Format) && (Bmp->DriverFlags & RDRIVER_PF_HAS_ALPHA) ) { geRDriver_THandle * AlphaTH; // blit the alpha surface to the separate alpha AlphaTH = Bmp->Driver->THandle_GetAlpha(Bmp->DriverHandle); if ( !AlphaTH || AlphaTH != Bmp->Alpha->DriverHandle) { if ( ! geBitmap_AttachToDriver(Bmp->Alpha,Bmp->Driver,Bmp->Alpha->DriverFlags | RDRIVER_PF_ALPHA) ) { geErrorLog_AddString(-1,"AttachToDriver : attach Alpha", NULL); return GE_FALSE; } assert(Bmp->Alpha->DriverHandle); if ( ! Bmp->Driver->THandle_SetAlpha(Bmp->DriverHandle,Bmp->Alpha->DriverHandle) ) { geErrorLog_AddString(-1,"AttachToDriver : THandle_SetAlpha", NULL); geBitmap_DetachDriver(Bmp->Alpha,GE_FALSE); geBitmap_DetachDriver(Bmp,GE_FALSE); return GE_FALSE; } AlphaTH = Bmp->Driver->THandle_GetAlpha(Bmp->DriverHandle); assert(AlphaTH == Bmp->Alpha->DriverHandle); } } // now bits are on driver , gamma correct them //for gamma : just Gamma up to mipMax then make mips from it // seems to work SaveMaxMip = Bmp->DriverInfo.MaximumMip; Bmp->DriverInfo.MaximumMip = mipMax; if ( ! geBitmap_Gamma_Apply(Bmp,GE_FALSE) ) { geErrorLog_AddString(-1,"AttachToDriver : Gamma_Apply failed!", NULL); Ret = GE_FALSE; } Bmp->DriverInfo.MaximumMip = SaveMaxMip; if ( ! MipsChanged && mipMax < Bmp->DriverInfo.MaximumMip ) { for(mip=mipMax+1;mip<= Bmp->DriverInfo.MaximumMip; mip++) { if ( ! geBitmap_UpdateMips(Bmp,mip-1,mip) ) { geErrorLog_AddString(-1,"AttachToDriver : UpdateMips on driver failed!", NULL); return GE_FALSE; } } } Bmp->DriverDataChanged = GE_FALSE; // in case _SetPal freaks us out return Ret; }

geBoolean geBitmap_UpdateMips_Data (  geBitmap_Info *  FmInfo, void *  FmBits, geBitmap_Info *  ToInfo, void *  ToBits )

Definition at line 2402 of file bitmap.c. References B, B1, B2, closestPal(), closestPalFree(), closestPalInit(), geBitmap_Info::ColorKey, gePixelFormat_Operations::DecomposePixel, geBitmap_Info::Format, G, G1, G2, GE_FALSE, GE_PIXELFORMAT_24BIT_RGB, GE_TRUE, geBitmap_Palette_GetData(), geBoolean, geErrorLog_AddString, gePixelFormat_BytesPerPel(), gePixelFormat_ColorGetter, gePixelFormat_ColorPutter, gePixelFormat_Decomposer, gePixelFormat_GetOperations(), gePixelFormat_HasPalette(), gePixelFormat_PixelGetter, gePixelFormat_PixelPutter, gePixelFormat_Operations::GetColor, gePixelFormat_Operations::GetPixel, geBitmap_Info::HasColorKey, geBitmap_Info::Height, int32, NULL, geBitmap_Info::Palette, gePixelFormat_Operations::PutColor, gePixelFormat_Operations::PutPixel, R, R1, R2, geBitmap_Info::Stride, uint16, uint32, uint8, geBitmap_Info::Width, and y. Referenced by geBitmap_UpdateMips(), and geBitmap_UpdateMips_System(). { int fmxtra,tow,toh,toxtra,fmw,fmh,fmstep,x,y,bpp; assert( FmInfo && ToInfo && FmBits && ToBits ); assert( FmInfo->Format == ToInfo->Format && FmInfo->HasColorKey == ToInfo->HasColorKey ); tow = ToInfo->Width; toh = ToInfo->Height; toxtra = ToInfo->Stride - ToInfo->Width; x = ToInfo->Width; fmstep = 1; while( x < FmInfo->Width ) { fmstep += fmstep; x += x; } fmw = FmInfo->Width; fmh = FmInfo->Height; fmxtra = (FmInfo->Stride - tow) * fmstep; // amazingly simple and correct! think about it! // fmh == 15 // toh == 8 // fmstep == 2 // 7*2 <= 14 -> Ok if ( (toh-1)*fmstep > (fmh - 1) ) { geErrorLog_AddString(-1,"UpdateMips_Data : Vertical mip scaling doesn't match horizontal!", NULL); return GE_FALSE; } // {} todo : average for some special cases (16rgb,24rgb,32rgb) bpp = gePixelFormat_BytesPerPel(FmInfo->Format); if ( fmstep == 2 && bpp > 1 ) { int R1,G1,B1,A1,R2,G2,B2,A2,R3,G3,B3,A3,R4,G4,B4,A4; gePixelFormat_ColorGetter GetColor; gePixelFormat_ColorPutter PutColor; const gePixelFormat_Operations *ops; uint8 *fmp,*fmp2,*top; fmp = FmBits; top = ToBits; ops = gePixelFormat_GetOperations(FmInfo->Format); GetColor = ops->GetColor; PutColor = ops->PutColor; fmxtra *= bpp; toxtra *= bpp; if ( FmInfo->HasColorKey ) { uint32 ck,p1,p2,p3,p4; gePixelFormat_PixelGetter GetPixel; gePixelFormat_PixelPutter PutPixel; gePixelFormat_Decomposer DecomposePixel; int32 PixelComposeRTable[]={0x696C6345,0x21657370}; assert( FmInfo->ColorKey == ToInfo->ColorKey ); ck = FmInfo->ColorKey; GetPixel = ops->GetPixel; PutPixel = ops->PutPixel; DecomposePixel = ops->DecomposePixel; // {} the colorkey mip-subsampler // slow; yet another reason to not use CK ! for(y=toh;y--;) { //y = 7, fmh = 15; y*2+1 == fmh : last line is not a double line if ( (y+y + 1) == fmh ) fmp2 = fmp; else fmp2 = fmp + (FmInfo->Stride*bpp); for(x=tow;x--;) { p1 = GetPixel(&fmp); p2 = GetPixel(&fmp); p3 = GetPixel(&fmp2); p4 = GetPixel(&fmp2); if ( p1 == ck || p4 == ck ) { PutPixel(&top,ck); } else { // p1 and p4 are not ck; if ( p2 == ck ) p2 = p1; if ( p3 == ck ) p3 = p4; DecomposePixel(p1,&R1,&G1,&B1,&A1); DecomposePixel(p2,&R2,&G2,&B2,&A2); DecomposePixel(p3,&R3,&G3,&B3,&A3); DecomposePixel(p4,&R4,&G4,&B4,&A4); PutColor(&top,(R1+R2+R3+R4+2)>>2,(G1+G2+G3+G4+2)>>2,(B1+B2+B3+B4+2)>>2,(A1+A2+A3+A4+2)>>2); } } fmp += fmxtra; top += toxtra; } } else { for(y=toh;y--;) { //y = 7, fmh = 15; y*2+1 == fmh : last line is not a double line if ( (y+y + 1) == fmh ) fmp2 = fmp; else fmp2 = fmp + (FmInfo->Stride*bpp); for(x=tow;x--;) { GetColor(&fmp ,&R1,&G1,&B1,&A1); GetColor(&fmp ,&R2,&G2,&B2,&A2); GetColor(&fmp2,&R3,&G3,&B3,&A3); GetColor(&fmp2,&R4,&G4,&B4,&A4); PutColor(&top,(R1+R2+R3+R4+2)>>2,(G1+G2+G3+G4+2)>>2,(B1+B2+B3+B4+2)>>2,(A1+A2+A3+A4+2)>>2); } fmp += fmxtra; top += toxtra; } } assert( top == (((uint8 *)ToBits) + ToInfo->Stride * ToInfo->Height * bpp ) ); assert( fmp == (((uint8 *)FmBits) + FmInfo->Stride * ToInfo->Height * 2 * bpp ) ); } else if ( fmstep == 2 && gePixelFormat_HasPalette(FmInfo->Format) ) { int R,G,B; uint8 *fmp,*fmp2,*top; uint8 paldata[768],*palptr; int p; palInfo * PalInfo; assert(bpp == 1); assert(FmInfo->Palette); if ( ! geBitmap_Palette_GetData(FmInfo->Palette,paldata,GE_PIXELFORMAT_24BIT_RGB,256) ) return GE_FALSE; if ( ! (PalInfo = closestPalInit(paldata)) ) return GE_FALSE; fmp = FmBits; top = ToBits; // @@ colorkey? for(y=toh;y--;) { //y = 7, fmh = 15; y*2+1 == fmh : last line is not a double line if ( (y*2 + 1) == fmh ) fmp2 = fmp; else fmp2 = fmp + (FmInfo->Stride*bpp); for(x=tow;x--;) { p = *fmp++; palptr = paldata + p*3; R = palptr[0]; G = palptr[1]; B = palptr[2]; p = *fmp++; palptr = paldata + p*3; R += palptr[0]; G += palptr[1]; B += palptr[2]; p = *fmp2++; palptr = paldata + p*3; R += palptr[0]; G += palptr[1]; B += palptr[2]; p = *fmp2++; palptr = paldata + p*3; R += palptr[0]; G += palptr[1]; B += palptr[2]; R = (R+2)>>2; G = (G+2)>>2; B = (B+2)>>2; p = closestPal(R,G,B,PalInfo); *top++ = p; } fmp += fmxtra; top += toxtra; } closestPalFree(PalInfo); assert( top == (((uint8 *)ToBits) + ToInfo->Stride * ToInfo->Height * bpp ) ); assert( fmp == (((uint8 *)FmBits) + FmInfo->Stride * ToInfo->Height * 2 * bpp ) ); } else { // we just sub-sample to make mips, so we don't have to // know anything about pixelformat. // (btw this spoils the whole point of mips, so we might as well kill the mip!) //{} Blend correctly !? switch( bpp ) { default: { return GE_FALSE; } case 1: { uint8 *fmp,*top; fmp = FmBits; top = ToBits; for(y=toh;y--;) { for(x=tow;x--;) { *top++ = *fmp; fmp += fmstep; } fmp += fmxtra; top += toxtra; } break; } case 2: { uint16 *fmp,*top; fmp = FmBits; top = ToBits; for(y=toh;y--;) { for(x=tow;x--;) { *top++ = *fmp; fmp += fmstep; } fmp += fmxtra; top += toxtra; } break; } case 4: { uint32 *fmp,*top; fmp = FmBits; top = ToBits; for(y=toh;y--;) { for(x=tow;x--;) { *top++ = *fmp; fmp += fmstep; } fmp += fmxtra; top += toxtra; } break; } case 3: { uint8 *fmp,*top; fmp = FmBits; top = ToBits; fmstep = (fmstep - 1) * 3; fmxtra *= 3; toxtra *= 3; for(y=toh;y--;) { for(x=tow;x--;) { *top++ = *fmp++; *top++ = *fmp++; *top++ = *fmp++; fmp += fmstep; } fmp += fmxtra; top += toxtra; } break; } } } return GE_TRUE; }

geBoolean geBitmap_UpdateMips_System (  geBitmap *  Bmp, int  fm, int  to )

Definition at line 2346 of file bitmap.c. References geBitmap::Data, geBitmap::DataOwner, geBitmap_Info::Format, GE_FALSE, GE_TRUE, geBitmap_AllocSystemMip(), geBitmap_IsValid(), geBitmap_UpdateMips_Data(), geBoolean, gePixelFormat_BytesPerPel(), geBitmap_Info::Height, geBitmap::Info, geBitmap::LockOwner, max, geBitmap_Info::MaximumMip, MAXMIPLEVELS, geBitmap_Info::MinimumMip, NULL, SHIFT_R_ROUNDUP, geBitmap_Info::Stride, and geBitmap_Info::Width. Referenced by geBitmap_MakeSystemMips(), and geBitmap_UpdateMips(). { geBitmap_Info FmInfo,ToInfo; geBoolean Ret; assert( geBitmap_IsValid(Bmp) ); // this is called to create new mips in LockFor* -> CreateLockFrom* (through MakeSystemMips) if ( Bmp->LockOwner ) Bmp = Bmp->LockOwner; // if ( Bmp->LockCount > 0 ) // return GE_FALSE; if ( Bmp->DataOwner ) return GE_FALSE; // {} for compressed data, just don't make mips and say we did! if ( gePixelFormat_BytesPerPel(Bmp->Info.Format) < 1 ) return GE_TRUE; while(Bmp->Data[fm] == NULL || fm == to ) { fm--; if ( fm < 0 ) return GE_FALSE; } if ( fm < Bmp->Info.MinimumMip || fm > Bmp->Info.MaximumMip || to < fm || to >= MAXMIPLEVELS ) return GE_FALSE; if ( ! Bmp->Data[to] ) { if ( ! geBitmap_AllocSystemMip(Bmp,to) ) return GE_FALSE; } assert( to > fm && fm >= 0 ); FmInfo = ToInfo = Bmp->Info; FmInfo.Width = SHIFT_R_ROUNDUP(Bmp->Info.Width ,fm); FmInfo.Height= SHIFT_R_ROUNDUP(Bmp->Info.Height,fm); FmInfo.Stride= SHIFT_R_ROUNDUP(Bmp->Info.Stride,fm); ToInfo.Width = SHIFT_R_ROUNDUP(Bmp->Info.Width ,to); ToInfo.Height= SHIFT_R_ROUNDUP(Bmp->Info.Height,to); ToInfo.Stride= SHIFT_R_ROUNDUP(Bmp->Info.Stride,to); Ret = geBitmap_UpdateMips_Data( &FmInfo, Bmp->Data[fm], &ToInfo, Bmp->Data[to]); Bmp->Info.MaximumMip = max(Bmp->Info.MaximumMip,to); return Ret; }

geBoolean geBitmap_UsesColorKey (  const geBitmap *  Bmp  )

Definition at line 3370 of file bitmap.c. References gePixelFormat_Operations::BytesPerPel, geBitmap_Info::ColorKey, geBitmap::Data, geBitmap_Info::Format, GE_FALSE, GE_TRUE, geBoolean, geErrorLog_AddString, gePixelFormat_GetOperations(), geBitmap_Info::HasColorKey, geBitmap_Info::Height, geBitmap::Info, geBitmap_Info::MinimumMip, NULL, s, geBitmap_Info::Stride, uint16, uint32, uint8, geBitmap_Info::Width, and y. Referenced by geBitmap_SetColorKey(). { void * Bits; const gePixelFormat_Operations * ops; int x,y,w,h,s; uint32 pel,ColorKey; if ( ! Bmp->Info.HasColorKey ) return GE_FALSE; if ( ! Bmp->Data[0] ) { geErrorLog_AddString(-1,"UsesColorKey : no data!", NULL); return GE_TRUE; } assert( Bmp->Info.MinimumMip == 0 ); Bits = Bmp->Data[0]; ops = gePixelFormat_GetOperations(Bmp->Info.Format); assert(ops); w = Bmp->Info.Width; h = Bmp->Info.Height; s = Bmp->Info.Stride; ColorKey = Bmp->Info.ColorKey; switch(ops->BytesPerPel) { case 0: geErrorLog_AddString(-1,"UsesColorKey : invalid format", NULL); return GE_TRUE; //Start Dec2001DCS - Added new case 3 below // case 3: // #pragma message("Bitmap : UsesColorKey : no 24bit Smart ColorKey") // geErrorLog_AddString(-1,"UsesColorKey : no 24bit Smart ColorKey", NULL); // return GE_TRUE; //End Dec2001DCS case 1: { uint8 * ptr; ptr = Bits; for(y=h;y--;) { for(x=w;x--;) { pel = *ptr++; if ( pel == ColorKey ) { return GE_TRUE; } } ptr += (s-w); } break; } case 2: { uint16 * ptr; ptr = Bits; for(y=h;y--;) { for(x=w;x--;) { pel = *ptr++; if ( pel == ColorKey ) { return GE_TRUE; } } ptr += (s-w); } break; } //Start Dec2001DCS - Added new case 3 case 3: { uint8 * ptr; uint8 ckR, ckG, ckB; ckB = (uint8) (ColorKey & 0x000000ff); ckG = (uint8) ((ColorKey >> 8) & 0x000000ff); ckR = (uint8) ((ColorKey >> 16) & 0x000000ff); ptr = Bits; for(y=h;y--;) { for(x=w;x--;) { if ((*ptr == ckR) && (*(ptr+1) == ckG) && (*(ptr+2) == ckB)) { return GE_TRUE; } ptr += 3; } ptr += ((s-w)*3); } break; } //End Dec2001DCS case 4: { uint32 * ptr; ptr = Bits; for(y=h;y--;) { for(x=w;x--;) { pel = *ptr++; if ( pel == ColorKey ) { return GE_TRUE; } } ptr += (s-w); } break; } } return GE_FALSE; }

geBoolean geBitmap_WriteInfo (  const geBitmap *  Bmp, geVFile *  F )

Definition at line 4614 of file bitmap.c. References geBitmap::Alpha, geBitmap_Info::ColorKey, geBitmap_Info::Format, GE_FALSE, GE_TRUE, geBoolean, gePixelFormat_BytesPerPel(), gePixelFormat_IsValid(), gePixelFormat_PutPixel(), geVFile_Write(), geBitmap_Info::HasColorKey, geBitmap_Info::Height, geBitmap::Info, INFO_FLAG_HAS_ALPHA, INFO_FLAG_HAS_CK, INFO_FLAG_HAS_PAL, INFO_FLAG_IF_NOT_LOG2_ARE_BYTE, INFO_FLAG_WH_ARE_LOG2, geBitmap_Info::MaximumMip, geBitmap_Info::MinimumMip, geBitmap_Info::Palette, geBitmap::SeekMipCount, uint16, uint8, and geBitmap_Info::Width. Referenced by geBitmap_WriteToFile(). { uint8 data[64]; uint8 * ptr; uint8 flags; uint8 b; int len,logw,logh; const geBitmap_Info * pi; /* bit flags : W&H are log2 HasCK HasAlpha HasPal W&H logs in 1 byte, or W & H each in 2 bytes Format in 5 bits MaxMip in 3 bits Bmp->SeekMipCount in 3 bits CK in bpp bytes */ pi = &(Bmp->Info); flags = 0; ptr = data + 1; // flags will go there assert( pi->Width < 65536 && pi->Height < 65536 ); assert( pi->MinimumMip == 0 ); assert( gePixelFormat_IsValid(pi->Format) ); *ptr++ = pi->Format; // could go in 5 bits b = (pi->MaximumMip << 4) + Bmp->SeekMipCount; // could go in 6 bits *ptr++ = b; if ( pi->Palette ) flags |= INFO_FLAG_HAS_PAL; if ( Bmp->Alpha ) flags |= INFO_FLAG_HAS_ALPHA; for(logw=0;(1<<logw) < pi->Width;logw++); for(logh=0;(1<<logh) < pi->Height;logh++); if ( (1<<logw) == pi->Width && (1<<logh) == pi->Height ) { flags |= INFO_FLAG_WH_ARE_LOG2; assert( logw <= 0xF && logh <= 0xF ); b = (logw<<4) + logh; *ptr++ = b; } else { if ( pi->Width < 256 && pi->Height < 256 ) { flags |= INFO_FLAG_IF_NOT_LOG2_ARE_BYTE; *ptr++ = pi->Width; *ptr++ = pi->Height; } else { *((uint16 *)ptr) = pi->Width; ptr += 2; *((uint16 *)ptr) = pi->Height; ptr += 2; } } if ( pi->HasColorKey && gePixelFormat_BytesPerPel(pi->Format) > 0 ) { flags |= INFO_FLAG_HAS_CK; gePixelFormat_PutPixel(pi->Format,&ptr,pi->ColorKey); } *data = flags; len = (int)(ptr - data); if ( ! geVFile_Write(F,data,len) ) return GE_FALSE; return GE_TRUE; }

---