static bool replay_write_stage(ReplayStage *stg, SDL_RWops *file, uint16_t version) {
if(version >= REPLAY_STRUCT_VERSION_TS102000_REV1) {
SDL_WriteLE32(file, stg->flags);
}
SDL_WriteLE16(file, stg->stage);
SDL_WriteLE32(file, stg->seed);
SDL_WriteU8(file, stg->diff);
SDL_WriteLE32(file, stg->plr_points);
if(version >= REPLAY_STRUCT_VERSION_TS102000_REV1) {
SDL_WriteU8(file, stg->plr_continues_used);
}
SDL_WriteU8(file, stg->plr_char);
SDL_WriteU8(file, stg->plr_shot);
SDL_WriteLE16(file, stg->plr_pos_x);
SDL_WriteLE16(file, stg->plr_pos_y);
SDL_WriteU8(file, stg->plr_focus);
SDL_WriteLE16(file, stg->plr_power);
SDL_WriteU8(file, stg->plr_lives);
SDL_WriteU8(file, stg->plr_life_fragments);
SDL_WriteU8(file, stg->plr_bombs);
SDL_WriteU8(file, stg->plr_bomb_fragments);
SDL_WriteU8(file, stg->plr_inputflags);
SDL_WriteLE16(file, stg->numevents);
SDL_WriteLE32(file, 1 + ~replay_calc_stageinfo_checksum(stg, version));
return true;
}
void
WIN_SetWindowIcon(_THIS, SDL_Window * window, SDL_Surface * icon)
{
HWND hwnd = ((SDL_WindowData *) window->driverdata)->hwnd;
HICON hicon = NULL;
BYTE *icon_bmp;
int icon_len;
SDL_RWops *dst;
SDL_Surface *surface;
/* Create temporary bitmap buffer */
icon_len = 40 + icon->h * icon->w * 4;
icon_bmp = SDL_stack_alloc(BYTE, icon_len);
dst = SDL_RWFromMem(icon_bmp, icon_len);
if (!dst) {
SDL_stack_free(icon_bmp);
return;
}
/* Write the BITMAPINFO header */
SDL_WriteLE32(dst, 40);
SDL_WriteLE32(dst, icon->w);
SDL_WriteLE32(dst, icon->h * 2);
SDL_WriteLE16(dst, 1);
SDL_WriteLE16(dst, 32);
SDL_WriteLE32(dst, BI_RGB);
SDL_WriteLE32(dst, icon->h * icon->w * 4);
SDL_WriteLE32(dst, 0);
SDL_WriteLE32(dst, 0);
SDL_WriteLE32(dst, 0);
SDL_WriteLE32(dst, 0);
/* Convert the icon to a 32-bit surface with alpha channel */
surface = SDL_ConvertSurfaceFormat(icon, SDL_PIXELFORMAT_ARGB8888, 0);
if (surface) {
/* Write the pixels upside down into the bitmap buffer */
int y = surface->h;
while (y--) {
Uint8 *src = (Uint8 *) surface->pixels + y * surface->pitch;
SDL_RWwrite(dst, src, surface->pitch, 1);
}
SDL_FreeSurface(surface);
/* TODO: create the icon in WinCE (CreateIconFromResource isn't available) */
#ifndef _WIN32_WCE
hicon = CreateIconFromResource(icon_bmp, icon_len, TRUE, 0x00030000);
#endif
}
SDL_RWclose(dst);
SDL_stack_free(icon_bmp);
/* Set the icon for the window */
SendMessage(hwnd, WM_SETICON, ICON_SMALL, (LPARAM) hicon);
/* Set the icon in the task manager (should we do this?) */
SendMessage(hwnd, WM_SETICON, ICON_BIG, (LPARAM) hicon);
}
void KrEncoder::StartTag( U32 tag, bool _bCompressThisResource )
{
SDL_WriteLE32( stream, tag );
tagpos = SDL_RWtell( stream );
if(bSaveCompressed) SDL_WriteLE32( stream, 0 ); //Compressed size
SDL_WriteLE32( stream, 0 ); //Real size
realStream = stream;
//Redirect to temp file
if(bSaveCompressed) stream = SDL_RWFromFile( "gedTmp", "wb" );
bCompressThisResource = _bCompressThisResource;
}
void
WIN_SetWindowIcon(_THIS, SDL_Window * window, SDL_Surface * icon)
{
HWND hwnd = ((SDL_WindowData *) window->driverdata)->hwnd;
HICON hicon = NULL;
BYTE *icon_bmp;
int icon_len, mask_len, y;
SDL_RWops *dst;
/* Create temporary buffer for ICONIMAGE structure */
mask_len = (icon->h * (icon->w + 7)/8);
icon_len = 40 + icon->h * icon->w * sizeof(Uint32) + mask_len;
icon_bmp = SDL_stack_alloc(BYTE, icon_len);
dst = SDL_RWFromMem(icon_bmp, icon_len);
if (!dst) {
SDL_stack_free(icon_bmp);
return;
}
/* Write the BITMAPINFO header */
SDL_WriteLE32(dst, 40);
SDL_WriteLE32(dst, icon->w);
SDL_WriteLE32(dst, icon->h * 2);
SDL_WriteLE16(dst, 1);
SDL_WriteLE16(dst, 32);
SDL_WriteLE32(dst, BI_RGB);
SDL_WriteLE32(dst, icon->h * icon->w * sizeof(Uint32));
SDL_WriteLE32(dst, 0);
SDL_WriteLE32(dst, 0);
SDL_WriteLE32(dst, 0);
SDL_WriteLE32(dst, 0);
/* Write the pixels upside down into the bitmap buffer */
SDL_assert(icon->format->format == SDL_PIXELFORMAT_ARGB8888);
y = icon->h;
while (y--) {
Uint8 *src = (Uint8 *) icon->pixels + y * icon->pitch;
SDL_RWwrite(dst, src, icon->w * sizeof(Uint32), 1);
}
/* Write the mask */
SDL_memset(icon_bmp + icon_len - mask_len, 0xFF, mask_len);
hicon = CreateIconFromResource(icon_bmp, icon_len, TRUE, 0x00030000);
SDL_RWclose(dst);
SDL_stack_free(icon_bmp);
/* Set the icon for the window */
SendMessage(hwnd, WM_SETICON, ICON_SMALL, (LPARAM) hicon);
/* Set the icon in the task manager (should we do this?) */
SendMessage(hwnd, WM_SETICON, ICON_BIG, (LPARAM) hicon);
}
int Compression::DoCompression(const char *from, const char *to)
{
int lenght = 0, lenghtComp;
SDL_RWops *src = ged_SDL_RWFromFile(from, "rb");
if(!src) return lenght;
SDL_RWops *dst = ged_SDL_RWFromFile(to, "wb");
if(!dst)
{
SDL_RWclose(src);
return lenght;
}
SDL_RWseek( src, 0, SEEK_END );
lenght = SDL_RWtell( src );
SDL_RWseek( src, 0, SEEK_SET );
U8 *in = new U8[lenght];
U8 *out = new U8[lenght + lenght / 8 + 256];
SDL_RWread(src, in, lenght, 1);
lenghtComp = DoCompression(in, lenght, out, lenght + lenght / 8 + 256);
if(lenghtComp < lenght)
{
SDL_WriteLE32( dst, lenght );
SDL_WriteLE32( dst, lenghtComp );
SDL_RWwrite(dst, out, lenghtComp, 1);
}
else
{
//No compression
SDL_WriteLE32( dst, lenght );
SDL_WriteLE32( dst, lenght );
SDL_RWwrite(dst, in, lenght, 1);
lenghtComp = lenght;
}
delete [] in;
delete [] out;
SDL_RWclose(src);
SDL_RWclose(dst);
return lenghtComp + 2*sizeof(U32);
}
static bool replay_write_stage_event(ReplayEvent *evt, SDL_RWops *file) {
SDL_WriteLE32(file, evt->frame);
SDL_WriteU8(file, evt->type);
SDL_WriteLE16(file, evt->value);
return true;
}
bool KrEncoder::StartDat(const char* magic) //maks
{
numRGBA = 0;
// The header:
char version[16];
sprintf( version, "%d.%d.%d", KyraVersionMajor, KyraVersionMinor, KyraVersionBuild );
SDL_RWwrite( stream, magic, 4, 1 );
WriteString( stream, version, false );
numRlePos = SDL_RWtell( stream );
SDL_WriteLE32( stream, 0 ); // placeholder for number of RGBAs
SDL_WriteLE32( stream, 0 ); // placeholder for number of lines
SDL_WriteLE32( stream, 0 ); // placeholder for number of segments
return true;
}
bool KrEncoder::EndDat()
{
StartTag( KYRATAG_END );
EndTag();
SDL_RWseek( stream, numRlePos, SEEK_SET );
GLASSERT( numRGBA >= numSegment );
//GLASSERT( numSegment >= numLine ); //maks: Is be possible (GE_N.bmp)
SDL_WriteLE32( stream, numRGBA );
SDL_WriteLE32( stream, numLine );
SDL_WriteLE32( stream, numSegment );
#ifdef DEBUG
GLOUTPUT( "Tally count: rgba=%d line=%d segment=%d\n", numRGBA, numLine, numSegment );
#endif
cachedWrite.Flush();
return true;
}
void KrSpriteResource::Save( KrEncoder* encoder )
{
int i;
bool bCompressedResource = false; //true;
U32 actionSize = 0;
//maks: always use per frame compression to take advantage of malloc_gc
/*if(encoder->getCompressed())
{
//Save all actions at same compressed data?
for(i=0; i < NumActions(); ++i )
{
actionSize += actionArr[i]->GetTotalSize();
if(actionSize > 2*1024*1024)
{
//4MB ~ 13 frames (240x320)
//Compress by frame (load frame on demand)
bCompressedResource = false;
break;
}
}
}*/
encoder->StartTag( KYRATAG_SPRITE, bCompressedResource );
WriteString( encoder->Stream(), ResourceName() );
encoder->WriteCached( ResourceName() );
//maks: don't save unnecessary default icon
Uint32 n = NumActions();
/*bool bRemoveIcon = false; //Bug in create actor
if(n > 2) //icon, text, other animation
{
for( int i=0; i < NumActions(); ++i )
{
if(actionArr[i]->Name() == "icon")
{
n--;
bRemoveIcon = true;
break;
}
}
}*/
SDL_WriteLE32( encoder->Stream(), n );
for(i=0; i < NumActions(); ++i )
{
//if(actionArr[i]->Name() != "icon" || !bRemoveIcon)
actionArr[i]->Save( encoder, !bCompressedResource );
}
encoder->EndTag();
}
void RegionLoad::Save(SDL_RWops *src)
{
//Save region defination
SDL_WriteLE32(src, getImage()->X());
SDL_WriteLE32(src, getImage()->Y());
SDL_WriteLE32(src, ((SlowCanvas *)getImage())->Width());
SDL_WriteLE32(src, ((SlowCanvas *)getImage())->Height());
//Save default region in view
Uint8 bDefaultRegion = (defaultRegion == this)?1:0;
SDL_RWwrite(src, &bDefaultRegion, sizeof(Uint8), 1);
//Save actors list
SDL_WriteLE32(src, regionActors.size());
MapRegionActorsIterator it(regionActors);
for( it.Begin(); !it.Done(); it.Next() )
{
WriteString(src, *it.Key());
}
}
void Compression::DoCompression(const char *from, SDL_RWops *dst)
{
int lenght, lenghtComp;
SDL_RWops *src = ged_SDL_RWFromFile(from, "rb");
if(!src) return;
SDL_RWseek( src, 0, SEEK_END );
lenght = SDL_RWtell( src );
SDL_RWseek( src, 0, SEEK_SET );
U8 *in = new U8[lenght];
U8 *out = new U8[2*lenght/*lenght + lenght / 8 + 256*/]; //Solved crash when export Alittlecash_player.ged
SDL_RWread(src, in, lenght, 1);
lenghtComp = DoCompression(in, lenght, out, 2*lenght/*lenght + lenght / 8 + 256*/);
if(lenghtComp < lenght)
{
SDL_WriteLE32( dst, lenght );
SDL_WriteLE32( dst, lenghtComp );
SDL_RWwrite(dst, out, lenghtComp, 1);
}
else
{
//No compression
SDL_WriteLE32( dst, lenght );
SDL_WriteLE32( dst, lenght );
SDL_RWwrite(dst, in, lenght, 1);
}
delete [] in;
delete [] out;
SDL_RWclose(src);
}
void RegionLoad::SaveRegions(SDL_RWops *src)
{
//Save all regions
SDL_WriteLE32(src, regions.size());
if(regionTemp)
{
delete regionTemp;
regionTemp = NULL;
}
MapRegionsIterator it(regions);
RegionLoad *pRegion;
for( it.Begin(); !it.Done(); it.Next() )
{
pRegion = *it.Key();
pRegion->Save(src);
}
}
int
SDL_SaveBMP_RW(SDL_Surface * saveme, SDL_RWops * dst, int freedst)
{
long fp_offset;
int i, pad;
SDL_Surface *surface;
Uint8 *bits;
/* The Win32 BMP file header (14 bytes) */
char magic[2] = { 'B', 'M' };
Uint32 bfSize;
Uint16 bfReserved1;
Uint16 bfReserved2;
Uint32 bfOffBits;
/* The Win32 BITMAPINFOHEADER struct (40 bytes) */
Uint32 biSize;
Sint32 biWidth;
Sint32 biHeight;
Uint16 biPlanes;
Uint16 biBitCount;
Uint32 biCompression;
Uint32 biSizeImage;
Sint32 biXPelsPerMeter;
Sint32 biYPelsPerMeter;
Uint32 biClrUsed;
Uint32 biClrImportant;
/* Make sure we have somewhere to save */
surface = NULL;
if (dst) {
SDL_bool save32bit = SDL_FALSE;
#ifdef SAVE_32BIT_BMP
/* We can save alpha information in a 32-bit BMP */
if (saveme->map->info.flags & SDL_COPY_COLORKEY ||
saveme->format->Amask) {
save32bit = SDL_TRUE;
}
#endif /* SAVE_32BIT_BMP */
if (saveme->format->palette && !save32bit) {
if (saveme->format->BitsPerPixel == 8) {
surface = saveme;
} else {
SDL_SetError("%d bpp BMP files not supported",
saveme->format->BitsPerPixel);
}
} else if ((saveme->format->BitsPerPixel == 24) &&
#if SDL_BYTEORDER == SDL_LIL_ENDIAN
(saveme->format->Rmask == 0x00FF0000) &&
(saveme->format->Gmask == 0x0000FF00) &&
(saveme->format->Bmask == 0x000000FF)
#else
(saveme->format->Rmask == 0x000000FF) &&
(saveme->format->Gmask == 0x0000FF00) &&
(saveme->format->Bmask == 0x00FF0000)
#endif
) {
surface = saveme;
} else {
SDL_PixelFormat format;
/* If the surface has a colorkey or alpha channel we'll save a
32-bit BMP with alpha channel, otherwise save a 24-bit BMP. */
if (save32bit) {
SDL_InitFormat(&format,
#if SDL_BYTEORDER == SDL_LIL_ENDIAN
SDL_PIXELFORMAT_ARGB8888
#else
SDL_PIXELFORMAT_BGRA8888
#endif
);
} else {
SDL_InitFormat(&format, SDL_PIXELFORMAT_BGR24);
}
surface = SDL_ConvertSurface(saveme, &format, 0);
if (!surface) {
SDL_SetError("Couldn't convert image to %d bpp",
format.BitsPerPixel);
}
}
}
if (surface && (SDL_LockSurface(surface) == 0)) {
const int bw = surface->w * surface->format->BytesPerPixel;
/* Set the BMP file header values */
bfSize = 0; /* We'll write this when we're done */
bfReserved1 = 0;
bfReserved2 = 0;
bfOffBits = 0; /* We'll write this when we're done */
/* Write the BMP file header values */
fp_offset = SDL_RWtell(dst);
SDL_ClearError();
SDL_RWwrite(dst, magic, 2, 1);
SDL_WriteLE32(dst, bfSize);
SDL_WriteLE16(dst, bfReserved1);
SDL_WriteLE16(dst, bfReserved2);
SDL_WriteLE32(dst, bfOffBits);
/* Set the BMP info values */
biSize = 40;
biWidth = surface->w;
biHeight = surface->h;
biPlanes = 1;
biBitCount = surface->format->BitsPerPixel;
biCompression = BI_RGB;
biSizeImage = surface->h * surface->pitch;
biXPelsPerMeter = 0;
biYPelsPerMeter = 0;
if (surface->format->palette) {
biClrUsed = surface->format->palette->ncolors;
} else {
biClrUsed = 0;
}
biClrImportant = 0;
/* Write the BMP info values */
SDL_WriteLE32(dst, biSize);
SDL_WriteLE32(dst, biWidth);
SDL_WriteLE32(dst, biHeight);
SDL_WriteLE16(dst, biPlanes);
SDL_WriteLE16(dst, biBitCount);
SDL_WriteLE32(dst, biCompression);
SDL_WriteLE32(dst, biSizeImage);
SDL_WriteLE32(dst, biXPelsPerMeter);
SDL_WriteLE32(dst, biYPelsPerMeter);
SDL_WriteLE32(dst, biClrUsed);
SDL_WriteLE32(dst, biClrImportant);
/* Write the palette (in BGR color order) */
if (surface->format->palette) {
SDL_Color *colors;
int ncolors;
colors = surface->format->palette->colors;
ncolors = surface->format->palette->ncolors;
for (i = 0; i < ncolors; ++i) {
SDL_RWwrite(dst, &colors[i].b, 1, 1);
SDL_RWwrite(dst, &colors[i].g, 1, 1);
SDL_RWwrite(dst, &colors[i].r, 1, 1);
SDL_RWwrite(dst, &colors[i].unused, 1, 1);
}
}
/* Write the bitmap offset */
bfOffBits = SDL_RWtell(dst) - fp_offset;
if (SDL_RWseek(dst, fp_offset + 10, RW_SEEK_SET) < 0) {
SDL_Error(SDL_EFSEEK);
}
SDL_WriteLE32(dst, bfOffBits);
if (SDL_RWseek(dst, fp_offset + bfOffBits, RW_SEEK_SET) < 0) {
SDL_Error(SDL_EFSEEK);
}
/* Write the bitmap image upside down */
bits = (Uint8 *) surface->pixels + (surface->h * surface->pitch);
pad = ((bw % 4) ? (4 - (bw % 4)) : 0);
while (bits > (Uint8 *) surface->pixels) {
bits -= surface->pitch;
if (SDL_RWwrite(dst, bits, 1, bw) != bw) {
SDL_Error(SDL_EFWRITE);
break;
}
if (pad) {
const Uint8 padbyte = 0;
for (i = 0; i < pad; ++i) {
SDL_RWwrite(dst, &padbyte, 1, 1);
}
}
}
/* Write the BMP file size */
bfSize = SDL_RWtell(dst) - fp_offset;
if (SDL_RWseek(dst, fp_offset + 2, RW_SEEK_SET) < 0) {
SDL_Error(SDL_EFSEEK);
}
SDL_WriteLE32(dst, bfSize);
if (SDL_RWseek(dst, fp_offset + bfSize, RW_SEEK_SET) < 0) {
SDL_Error(SDL_EFSEEK);
}
/* Close it up.. */
SDL_UnlockSurface(surface);
if (surface != saveme) {
SDL_FreeSurface(surface);
}
}
if (freedst && dst) {
SDL_RWclose(dst);
}
return ((SDL_strcmp(SDL_GetError(), "") == 0) ? 0 : -1);
}
/**
* @brief Tests writing and reading from file using endian aware functions.
*
* \sa
* http://wiki.libsdl.org/moin.cgi/SDL_RWFromFile
* http://wiki.libsdl.org/moin.cgi/SDL_RWClose
* http://wiki.libsdl.org/moin.cgi/SDL_ReadBE16
* http://wiki.libsdl.org/moin.cgi/SDL_WriteBE16
*/
int
rwops_testFileWriteReadEndian(void)
{
SDL_RWops *rw;
Sint64 result;
int mode;
size_t objectsWritten;
Uint16 BE16value;
Uint32 BE32value;
Uint64 BE64value;
Uint16 LE16value;
Uint32 LE32value;
Uint64 LE64value;
Uint16 BE16test;
Uint32 BE32test;
Uint64 BE64test;
Uint16 LE16test;
Uint32 LE32test;
Uint64 LE64test;
int cresult;
for (mode = 0; mode < 3; mode++) {
/* Create test data */
switch (mode) {
case 0:
SDLTest_Log("All 0 values");
BE16value = 0;
BE32value = 0;
BE64value = 0;
LE16value = 0;
LE32value = 0;
LE64value = 0;
break;
case 1:
SDLTest_Log("All 1 values");
BE16value = 1;
BE32value = 1;
BE64value = 1;
LE16value = 1;
LE32value = 1;
LE64value = 1;
break;
case 2:
SDLTest_Log("Random values");
BE16value = SDLTest_RandomUint16();
BE32value = SDLTest_RandomUint32();
BE64value = SDLTest_RandomUint64();
LE16value = SDLTest_RandomUint16();
LE32value = SDLTest_RandomUint32();
LE64value = SDLTest_RandomUint64();
break;
}
/* Write test. */
rw = SDL_RWFromFile(RWopsWriteTestFilename, "w+");
SDLTest_AssertPass("Call to SDL_RWFromFile(..,\"w+\")");
SDLTest_AssertCheck(rw != NULL, "Verify opening file with SDL_RWFromFile in write mode does not return NULL");
/* Bail out if NULL */
if (rw == NULL) return TEST_ABORTED;
/* Write test data */
objectsWritten = SDL_WriteBE16(rw, BE16value);
SDLTest_AssertPass("Call to SDL_WriteBE16");
SDLTest_AssertCheck(objectsWritten == 1, "Validate number of objects written, expected: 1, got: %i", objectsWritten);
objectsWritten = SDL_WriteBE32(rw, BE32value);
SDLTest_AssertPass("Call to SDL_WriteBE32");
SDLTest_AssertCheck(objectsWritten == 1, "Validate number of objects written, expected: 1, got: %i", objectsWritten);
objectsWritten = SDL_WriteBE64(rw, BE64value);
SDLTest_AssertPass("Call to SDL_WriteBE64");
SDLTest_AssertCheck(objectsWritten == 1, "Validate number of objects written, expected: 1, got: %i", objectsWritten);
objectsWritten = SDL_WriteLE16(rw, LE16value);
SDLTest_AssertPass("Call to SDL_WriteLE16");
SDLTest_AssertCheck(objectsWritten == 1, "Validate number of objects written, expected: 1, got: %i", objectsWritten);
objectsWritten = SDL_WriteLE32(rw, LE32value);
SDLTest_AssertPass("Call to SDL_WriteLE32");
SDLTest_AssertCheck(objectsWritten == 1, "Validate number of objects written, expected: 1, got: %i", objectsWritten);
objectsWritten = SDL_WriteLE64(rw, LE64value);
SDLTest_AssertPass("Call to SDL_WriteLE64");
SDLTest_AssertCheck(objectsWritten == 1, "Validate number of objects written, expected: 1, got: %i", objectsWritten);
/* Test seek to start */
result = SDL_RWseek( rw, 0, RW_SEEK_SET );
SDLTest_AssertPass("Call to SDL_RWseek succeeded");
SDLTest_AssertCheck(result == 0, "Verify result from position 0 with SDL_RWseek, expected 0, got %i", result);
/* Read test data */
BE16test = SDL_ReadBE16(rw);
SDLTest_AssertPass("Call to SDL_ReadBE16");
SDLTest_AssertCheck(BE16test == BE16value, "Validate return value from SDL_ReadBE16, expected: %hu, got: %hu", BE16value, BE16test);
BE32test = SDL_ReadBE32(rw);
SDLTest_AssertPass("Call to SDL_ReadBE32");
SDLTest_AssertCheck(BE32test == BE32value, "Validate return value from SDL_ReadBE32, expected: %u, got: %u", BE32value, BE32test);
BE64test = SDL_ReadBE64(rw);
SDLTest_AssertPass("Call to SDL_ReadBE64");
SDLTest_AssertCheck(BE64test == BE64value, "Validate return value from SDL_ReadBE64, expected: %llu, got: %llu", BE64value, BE64test);
LE16test = SDL_ReadLE16(rw);
SDLTest_AssertPass("Call to SDL_ReadLE16");
SDLTest_AssertCheck(LE16test == LE16value, "Validate return value from SDL_ReadLE16, expected: %hu, got: %hu", LE16value, LE16test);
LE32test = SDL_ReadLE32(rw);
SDLTest_AssertPass("Call to SDL_ReadLE32");
SDLTest_AssertCheck(LE32test == LE32value, "Validate return value from SDL_ReadLE32, expected: %u, got: %u", LE32value, LE32test);
LE64test = SDL_ReadLE64(rw);
SDLTest_AssertPass("Call to SDL_ReadLE64");
SDLTest_AssertCheck(LE64test == LE64value, "Validate return value from SDL_ReadLE64, expected: %llu, got: %llu", LE64value, LE64test);
/* Close handle */
cresult = SDL_RWclose(rw);
SDLTest_AssertPass("Call to SDL_RWclose() succeeded");
SDLTest_AssertCheck(cresult == 0, "Verify result value is 0; got: %d", cresult);
}
return TEST_COMPLETED;
}
bool GraphicsHelps::setWindowIcon(SDL_Window *window, FIBITMAP *img, int iconSize)
{
#ifdef _WIN32
struct SDL_SysWMinfo wmInfo;
SDL_VERSION(&wmInfo.version);
if(-1 == SDL_GetWindowWMInfo(window, &wmInfo))
return false;
if(wmInfo.subsystem != SDL_SYSWM_WINDOWS)
return false;
HWND windowH = wmInfo.info.win.window;
HICON hicon = NULL;
BYTE *icon_bmp;
unsigned int icon_len, y;
SDL_RWops *dst;
unsigned int w = FreeImage_GetWidth(img);
unsigned int h = FreeImage_GetWidth(img);
Uint8 *bits = (Uint8 *)FreeImage_GetBits(img);
unsigned int pitch = FreeImage_GetPitch(img);
/* Create temporary bitmap buffer */
icon_len = 40 + h * w * 4;
icon_bmp = SDL_stack_alloc(BYTE, icon_len);
dst = SDL_RWFromMem(icon_bmp, icon_len);
if(!dst)
{
SDL_stack_free(icon_bmp);
return false;
}
/* Write the BITMAPINFO header */
SDL_WriteLE32(dst, 40);
SDL_WriteLE32(dst, w);
SDL_WriteLE32(dst, h * 2);
SDL_WriteLE16(dst, 1);
SDL_WriteLE16(dst, 32);
SDL_WriteLE32(dst, BI_RGB);
SDL_WriteLE32(dst, h * w * 4);
SDL_WriteLE32(dst, 0);
SDL_WriteLE32(dst, 0);
SDL_WriteLE32(dst, 0);
SDL_WriteLE32(dst, 0);
y = 0;
do
{
Uint8 *src = bits + y * pitch;
SDL_RWwrite(dst, src, pitch, 1);
}
while(++y < h);
hicon = CreateIconFromResource(icon_bmp, icon_len, TRUE, 0x00030000);
SDL_RWclose(dst);
SDL_stack_free(icon_bmp);
/* Set the icon for the window */
SendMessage(windowH, WM_SETICON, (iconSize < 32) ? ICON_SMALL : ICON_BIG, (LPARAM) hicon);
#else
(void)iconSize;
SDL_Surface *sicon = GraphicsHelps::fi2sdl(img);
SDL_SetWindowIcon(window, sicon);
SDL_FreeSurface(sicon);
const char *error = SDL_GetError();
if(*error != '\0')
return false;
#endif
return true;
}
int
SDL_SaveBMP_RW(SDL_Surface * saveme, SDL_RWops * dst, int freedst)
{
Sint64 fp_offset;
int i, pad;
SDL_Surface *surface;
Uint8 *bits;
SDL_bool save32bit = SDL_FALSE;
SDL_bool saveLegacyBMP = SDL_FALSE;
/* The Win32 BMP file header (14 bytes) */
char magic[2] = { 'B', 'M' };
Uint32 bfSize;
Uint16 bfReserved1;
Uint16 bfReserved2;
Uint32 bfOffBits;
/* The Win32 BITMAPINFOHEADER struct (40 bytes) */
Uint32 biSize;
Sint32 biWidth;
Sint32 biHeight;
Uint16 biPlanes;
Uint16 biBitCount;
Uint32 biCompression;
Uint32 biSizeImage;
Sint32 biXPelsPerMeter;
Sint32 biYPelsPerMeter;
Uint32 biClrUsed;
Uint32 biClrImportant;
/* The additional header members from the Win32 BITMAPV4HEADER struct (108 bytes in total) */
Uint32 bV4RedMask = 0;
Uint32 bV4GreenMask = 0;
Uint32 bV4BlueMask = 0;
Uint32 bV4AlphaMask = 0;
Uint32 bV4CSType = 0;
Sint32 bV4Endpoints[3 * 3] = {0};
Uint32 bV4GammaRed = 0;
Uint32 bV4GammaGreen = 0;
Uint32 bV4GammaBlue = 0;
/* Make sure we have somewhere to save */
surface = NULL;
if (dst) {
#ifdef SAVE_32BIT_BMP
/* We can save alpha information in a 32-bit BMP */
if (saveme->format->BitsPerPixel >= 8 && (saveme->format->Amask ||
saveme->map->info.flags & SDL_COPY_COLORKEY)) {
save32bit = SDL_TRUE;
}
#endif /* SAVE_32BIT_BMP */
if (saveme->format->palette && !save32bit) {
if (saveme->format->BitsPerPixel == 8) {
surface = saveme;
} else {
SDL_SetError("%d bpp BMP files not supported",
saveme->format->BitsPerPixel);
}
} else if ((saveme->format->BitsPerPixel == 24) && !save32bit &&
#if SDL_BYTEORDER == SDL_LIL_ENDIAN
(saveme->format->Rmask == 0x00FF0000) &&
(saveme->format->Gmask == 0x0000FF00) &&
(saveme->format->Bmask == 0x000000FF)
#else
(saveme->format->Rmask == 0x000000FF) &&
(saveme->format->Gmask == 0x0000FF00) &&
(saveme->format->Bmask == 0x00FF0000)
#endif
) {
surface = saveme;
} else {
SDL_PixelFormat format;
/* If the surface has a colorkey or alpha channel we'll save a
32-bit BMP with alpha channel, otherwise save a 24-bit BMP. */
if (save32bit) {
SDL_InitFormat(&format, SDL_PIXELFORMAT_BGRA32);
} else {
SDL_InitFormat(&format, SDL_PIXELFORMAT_BGR24);
}
surface = SDL_ConvertSurface(saveme, &format, 0);
if (!surface) {
SDL_SetError("Couldn't convert image to %d bpp",
format.BitsPerPixel);
}
}
} else {
/* Set no error here because it may overwrite a more useful message from
SDL_RWFromFile() if SDL_SaveBMP_RW() is called from SDL_SaveBMP(). */
return -1;
}
if (save32bit) {
saveLegacyBMP = SDL_GetHintBoolean(SDL_HINT_BMP_SAVE_LEGACY_FORMAT, SDL_FALSE);
}
if (surface && (SDL_LockSurface(surface) == 0)) {
const int bw = surface->w * surface->format->BytesPerPixel;
/* Set the BMP file header values */
bfSize = 0; /* We'll write this when we're done */
bfReserved1 = 0;
bfReserved2 = 0;
bfOffBits = 0; /* We'll write this when we're done */
/* Write the BMP file header values */
fp_offset = SDL_RWtell(dst);
SDL_ClearError();
SDL_RWwrite(dst, magic, 2, 1);
SDL_WriteLE32(dst, bfSize);
SDL_WriteLE16(dst, bfReserved1);
SDL_WriteLE16(dst, bfReserved2);
SDL_WriteLE32(dst, bfOffBits);
/* Set the BMP info values */
biSize = 40;
biWidth = surface->w;
biHeight = surface->h;
biPlanes = 1;
biBitCount = surface->format->BitsPerPixel;
biCompression = BI_RGB;
biSizeImage = surface->h * surface->pitch;
biXPelsPerMeter = 0;
biYPelsPerMeter = 0;
if (surface->format->palette) {
biClrUsed = surface->format->palette->ncolors;
} else {
biClrUsed = 0;
}
biClrImportant = 0;
/* Set the BMP info values for the version 4 header */
if (save32bit && !saveLegacyBMP) {
biSize = 108;
biCompression = BI_BITFIELDS;
/* The BMP format is always little endian, these masks stay the same */
bV4RedMask = 0x00ff0000;
bV4GreenMask = 0x0000ff00;
bV4BlueMask = 0x000000ff;
bV4AlphaMask = 0xff000000;
bV4CSType = LCS_WINDOWS_COLOR_SPACE;
bV4GammaRed = 0;
bV4GammaGreen = 0;
bV4GammaBlue = 0;
}
/* Write the BMP info values */
SDL_WriteLE32(dst, biSize);
SDL_WriteLE32(dst, biWidth);
SDL_WriteLE32(dst, biHeight);
SDL_WriteLE16(dst, biPlanes);
SDL_WriteLE16(dst, biBitCount);
SDL_WriteLE32(dst, biCompression);
SDL_WriteLE32(dst, biSizeImage);
SDL_WriteLE32(dst, biXPelsPerMeter);
SDL_WriteLE32(dst, biYPelsPerMeter);
SDL_WriteLE32(dst, biClrUsed);
SDL_WriteLE32(dst, biClrImportant);
/* Write the BMP info values for the version 4 header */
if (save32bit && !saveLegacyBMP) {
SDL_WriteLE32(dst, bV4RedMask);
SDL_WriteLE32(dst, bV4GreenMask);
SDL_WriteLE32(dst, bV4BlueMask);
SDL_WriteLE32(dst, bV4AlphaMask);
SDL_WriteLE32(dst, bV4CSType);
for (i = 0; i < 3 * 3; i++) {
SDL_WriteLE32(dst, bV4Endpoints[i]);
}
SDL_WriteLE32(dst, bV4GammaRed);
SDL_WriteLE32(dst, bV4GammaGreen);
SDL_WriteLE32(dst, bV4GammaBlue);
}
/* Write the palette (in BGR color order) */
if (surface->format->palette) {
SDL_Color *colors;
int ncolors;
colors = surface->format->palette->colors;
ncolors = surface->format->palette->ncolors;
for (i = 0; i < ncolors; ++i) {
SDL_RWwrite(dst, &colors[i].b, 1, 1);
SDL_RWwrite(dst, &colors[i].g, 1, 1);
SDL_RWwrite(dst, &colors[i].r, 1, 1);
SDL_RWwrite(dst, &colors[i].a, 1, 1);
}
}
/* Write the bitmap offset */
bfOffBits = (Uint32)(SDL_RWtell(dst) - fp_offset);
if (SDL_RWseek(dst, fp_offset + 10, RW_SEEK_SET) < 0) {
SDL_Error(SDL_EFSEEK);
}
SDL_WriteLE32(dst, bfOffBits);
if (SDL_RWseek(dst, fp_offset + bfOffBits, RW_SEEK_SET) < 0) {
SDL_Error(SDL_EFSEEK);
}
/* Write the bitmap image upside down */
bits = (Uint8 *) surface->pixels + (surface->h * surface->pitch);
pad = ((bw % 4) ? (4 - (bw % 4)) : 0);
while (bits > (Uint8 *) surface->pixels) {
bits -= surface->pitch;
if (SDL_RWwrite(dst, bits, 1, bw) != bw) {
SDL_Error(SDL_EFWRITE);
break;
}
if (pad) {
const Uint8 padbyte = 0;
for (i = 0; i < pad; ++i) {
SDL_RWwrite(dst, &padbyte, 1, 1);
}
}
}
/* Write the BMP file size */
bfSize = (Uint32)(SDL_RWtell(dst) - fp_offset);
if (SDL_RWseek(dst, fp_offset + 2, RW_SEEK_SET) < 0) {
SDL_Error(SDL_EFSEEK);
}
SDL_WriteLE32(dst, bfSize);
if (SDL_RWseek(dst, fp_offset + bfSize, RW_SEEK_SET) < 0) {
SDL_Error(SDL_EFSEEK);
}
/* Close it up.. */
SDL_UnlockSurface(surface);
if (surface != saveme) {
SDL_FreeSurface(surface);
}
}
if (freedst && dst) {
SDL_RWclose(dst);
}
return ((SDL_strcmp(SDL_GetError(), "") == 0) ? 0 : -1);
}
int SDL_SaveBMP_RW (SDL_Surface *saveme, SDL_RWops *dst, int freedst)
{
long fp_offset;
int i, pad;
SDL_Surface *surface;
Uint8 *bits;
/* The Win32 BMP file header (14 bytes) */
char magic[2] = { 'B', 'M' };
Uint32 bfSize;
Uint16 bfReserved1;
Uint16 bfReserved2;
Uint32 bfOffBits;
/* The Win32 BITMAPINFOHEADER struct (40 bytes) */
Uint32 biSize;
Sint32 biWidth;
Sint32 biHeight;
Uint16 biPlanes;
Uint16 biBitCount;
Uint32 biCompression;
Uint32 biSizeImage;
Sint32 biXPelsPerMeter;
Sint32 biYPelsPerMeter;
Uint32 biClrUsed;
Uint32 biClrImportant;
/* Make sure we have somewhere to save */
surface = NULL;
if ( dst ) {
if ( saveme->format->palette ) {
if ( saveme->format->BitsPerPixel == 8 ) {
surface = saveme;
} else {
SDL_SetError("%d bpp BMP files not supported",
saveme->format->BitsPerPixel);
}
}
else if ( (saveme->format->BitsPerPixel == 24) &&
#if SDL_BYTEORDER == SDL_LIL_ENDIAN
(saveme->format->Rmask == 0x00FF0000) &&
(saveme->format->Gmask == 0x0000FF00) &&
(saveme->format->Bmask == 0x000000FF)
#else
(saveme->format->Rmask == 0x000000FF) &&
(saveme->format->Gmask == 0x0000FF00) &&
(saveme->format->Bmask == 0x00FF0000)
#endif
) {
surface = saveme;
} else {
SDL_Rect bounds;
/* Convert to 24 bits per pixel */
surface = SDL_CreateRGBSurface(SDL_SWSURFACE,
saveme->w, saveme->h, 24,
#if SDL_BYTEORDER == SDL_LIL_ENDIAN
0x00FF0000, 0x0000FF00, 0x000000FF,
#else
0x000000FF, 0x0000FF00, 0x00FF0000,
#endif
0);
if ( surface != NULL ) {
bounds.x = 0;
bounds.y = 0;
bounds.w = saveme->w;
bounds.h = saveme->h;
if ( SDL_LowerBlit(saveme, &bounds, surface,
&bounds) < 0 ) {
SDL_FreeSurface(surface);
SDL_SetError(
"Couldn't convert image to 24 bpp");
surface = NULL;
}
}
}
}
if ( surface && (SDL_LockSurface(surface) == 0) ) {
/* Set the BMP file header values */
bfSize = 0; /* We'll write this when we're done */
bfReserved1 = 0;
bfReserved2 = 0;
bfOffBits = 0; /* We'll write this when we're done */
/* Write the BMP file header values */
fp_offset = SDL_RWtell(dst);
SDL_ClearError();
SDL_RWwrite(dst, magic, 2, 1);
SDL_WriteLE32(dst, bfSize);
SDL_WriteLE16(dst, bfReserved1);
SDL_WriteLE16(dst, bfReserved2);
SDL_WriteLE32(dst, bfOffBits);
/* Set the BMP info values */
biSize = 40;
biWidth = surface->w;
biHeight = surface->h;
biPlanes = 1;
biBitCount = surface->format->BitsPerPixel;
biCompression = BI_RGB;
biSizeImage = surface->h*surface->pitch;
biXPelsPerMeter = 0;
biYPelsPerMeter = 0;
if ( surface->format->palette ) {
biClrUsed = surface->format->palette->ncolors;
} else {
biClrUsed = 0;
}
biClrImportant = 0;
/* Write the BMP info values */
SDL_WriteLE32(dst, biSize);
SDL_WriteLE32(dst, biWidth);
SDL_WriteLE32(dst, biHeight);
SDL_WriteLE16(dst, biPlanes);
SDL_WriteLE16(dst, biBitCount);
SDL_WriteLE32(dst, biCompression);
SDL_WriteLE32(dst, biSizeImage);
SDL_WriteLE32(dst, biXPelsPerMeter);
SDL_WriteLE32(dst, biYPelsPerMeter);
SDL_WriteLE32(dst, biClrUsed);
SDL_WriteLE32(dst, biClrImportant);
/* Write the palette (in BGR color order) */
if ( surface->format->palette ) {
SDL_Color *colors;
int ncolors;
colors = surface->format->palette->colors;
ncolors = surface->format->palette->ncolors;
for ( i=0; i<ncolors; ++i ) {
SDL_RWwrite(dst, &colors[i].b, 1, 1);
SDL_RWwrite(dst, &colors[i].g, 1, 1);
SDL_RWwrite(dst, &colors[i].r, 1, 1);
SDL_RWwrite(dst, &colors[i].unused, 1, 1);
}
}
/* Write the bitmap offset */
bfOffBits = SDL_RWtell(dst)-fp_offset;
if ( SDL_RWseek(dst, fp_offset+10, SEEK_SET) < 0 ) {
SDL_Error(SDL_EFSEEK);
}
SDL_WriteLE32(dst, bfOffBits);
if ( SDL_RWseek(dst, fp_offset+bfOffBits, SEEK_SET) < 0 ) {
SDL_Error(SDL_EFSEEK);
}
/* Write the bitmap image upside down */
bits = (Uint8 *)surface->pixels+(surface->h*surface->pitch);
pad = ((surface->pitch%4) ? (4-(surface->pitch%4)) : 0);
while ( bits > (Uint8 *)surface->pixels ) {
bits -= surface->pitch;
if ( SDL_RWwrite(dst, bits, 1, surface->pitch)
!= surface->pitch) {
SDL_Error(SDL_EFWRITE);
break;
}
if ( pad ) {
const Uint8 padbyte = 0;
for ( i=0; i<pad; ++i ) {
SDL_RWwrite(dst, &padbyte, 1, 1);
}
}
}
/* Write the BMP file size */
bfSize = SDL_RWtell(dst)-fp_offset;
if ( SDL_RWseek(dst, fp_offset+2, SEEK_SET) < 0 ) {
SDL_Error(SDL_EFSEEK);
}
SDL_WriteLE32(dst, bfSize);
if ( SDL_RWseek(dst, fp_offset+bfSize, SEEK_SET) < 0 ) {
SDL_Error(SDL_EFSEEK);
}
/* Close it up.. */
SDL_UnlockSurface(surface);
if ( surface != saveme ) {
SDL_FreeSurface(surface);
}
}
if ( freedst && dst ) {
SDL_RWclose(dst);
}
return((strcmp(SDL_GetError(), "") == 0) ? 0 : -1);
}
int
main(int argc, char **argv)
{
SDL_AudioSpec spec;
SDL_AudioCVT cvt;
Uint32 len = 0;
Uint8 *data = NULL;
int cvtfreq = 0;
int bitsize = 0;
int blockalign = 0;
int avgbytes = 0;
SDL_RWops *io = NULL;
if (argc != 4) {
fprintf(stderr, "USAGE: %s in.wav out.wav newfreq\n", argv[0]);
return 1;
}
cvtfreq = SDL_atoi(argv[3]);
if (SDL_Init(SDL_INIT_AUDIO) == -1) {
fprintf(stderr, "SDL_Init() failed: %s\n", SDL_GetError());
return 2;
}
if (SDL_LoadWAV(argv[1], &spec, &data, &len) == NULL) {
fprintf(stderr, "failed to load %s: %s\n", argv[1], SDL_GetError());
SDL_Quit();
return 3;
}
if (SDL_BuildAudioCVT(&cvt, spec.format, spec.channels, spec.freq,
spec.format, spec.channels, cvtfreq) == -1) {
fprintf(stderr, "failed to build CVT: %s\n", SDL_GetError());
SDL_FreeWAV(data);
SDL_Quit();
return 4;
}
cvt.len = len;
cvt.buf = (Uint8 *) SDL_malloc(len * cvt.len_mult);
if (cvt.buf == NULL) {
fprintf(stderr, "Out of memory.\n");
SDL_FreeWAV(data);
SDL_Quit();
return 5;
}
SDL_memcpy(cvt.buf, data, len);
if (SDL_ConvertAudio(&cvt) == -1) {
fprintf(stderr, "Conversion failed: %s\n", SDL_GetError());
SDL_free(cvt.buf);
SDL_FreeWAV(data);
SDL_Quit();
return 6;
}
/* write out a WAV header... */
io = SDL_RWFromFile(argv[2], "wb");
if (io == NULL) {
fprintf(stderr, "fopen('%s') failed: %s\n", argv[2], SDL_GetError());
SDL_free(cvt.buf);
SDL_FreeWAV(data);
SDL_Quit();
return 7;
}
bitsize = SDL_AUDIO_BITSIZE(spec.format);
blockalign = (bitsize / 8) * spec.channels;
avgbytes = cvtfreq * blockalign;
SDL_WriteLE32(io, 0x46464952); /* RIFF */
SDL_WriteLE32(io, len * cvt.len_mult + 36);
SDL_WriteLE32(io, 0x45564157); /* WAVE */
SDL_WriteLE32(io, 0x20746D66); /* fmt */
SDL_WriteLE32(io, 16); /* chunk size */
SDL_WriteLE16(io, 1); /* uncompressed */
SDL_WriteLE16(io, spec.channels); /* channels */
SDL_WriteLE32(io, cvtfreq); /* sample rate */
SDL_WriteLE32(io, avgbytes); /* average bytes per second */
SDL_WriteLE16(io, blockalign); /* block align */
SDL_WriteLE16(io, bitsize); /* significant bits per sample */
SDL_WriteLE32(io, 0x61746164); /* data */
SDL_WriteLE32(io, cvt.len_cvt); /* size */
SDL_RWwrite(io, cvt.buf, cvt.len_cvt, 1);
if (SDL_RWclose(io) == -1) {
fprintf(stderr, "fclose('%s') failed: %s\n", argv[2], SDL_GetError());
SDL_free(cvt.buf);
SDL_FreeWAV(data);
SDL_Quit();
return 8;
} // if
SDL_free(cvt.buf);
SDL_FreeWAV(data);
SDL_Quit();
return 0;
} // main
bool replay_write(Replay *rpy, SDL_RWops *file, uint16_t version) {
uint16_t base_version = (version & ~REPLAY_VERSION_COMPRESSION_BIT);
bool compression = (version & REPLAY_VERSION_COMPRESSION_BIT);
int i, j;
SDL_RWwrite(file, replay_magic_header, sizeof(replay_magic_header), 1);
SDL_WriteLE16(file, version);
if(base_version >= REPLAY_STRUCT_VERSION_TS102000_REV0) {
TaiseiVersion v;
TAISEI_VERSION_GET_CURRENT(&v);
if(taisei_version_write(file, &v) != TAISEI_VERSION_SIZE) {
log_warn("Failed to write game version: %s", SDL_GetError());
return false;
}
}
void *buf;
SDL_RWops *abuf = NULL;
SDL_RWops *vfile = file;
if(compression) {
abuf = SDL_RWAutoBuffer(&buf, 64);
vfile = SDL_RWWrapZWriter(abuf, REPLAY_COMPRESSION_CHUNK_SIZE, false);
}
replay_write_string(vfile, config_get_str(CONFIG_PLAYERNAME), base_version);
fix_flags(rpy);
if(base_version >= REPLAY_STRUCT_VERSION_TS102000_REV1) {
SDL_WriteLE32(vfile, rpy->flags);
}
SDL_WriteLE16(vfile, rpy->numstages);
for(i = 0; i < rpy->numstages; ++i) {
if(!replay_write_stage(rpy->stages + i, vfile, base_version)) {
if(compression) {
SDL_RWclose(vfile);
SDL_RWclose(abuf);
}
return false;
}
}
if(compression) {
SDL_RWclose(vfile);
SDL_WriteLE32(file, SDL_RWtell(file) + SDL_RWtell(abuf) + 4);
SDL_RWwrite(file, buf, SDL_RWtell(abuf), 1);
SDL_RWclose(abuf);
vfile = SDL_RWWrapZWriter(file, REPLAY_COMPRESSION_CHUNK_SIZE, false);
}
for(i = 0; i < rpy->numstages; ++i) {
ReplayStage *stg = rpy->stages + i;
for(j = 0; j < stg->numevents; ++j) {
if(!replay_write_stage_event(stg->events + j, vfile)) {
if(compression) {
SDL_RWclose(vfile);
}
return false;
}
}
}
if(compression) {
SDL_RWclose(vfile);
}
// useless byte to simplify the premature EOF check, can be anything
SDL_WriteU8(file, REPLAY_USELESS_BYTE);
return true;
}
void KrEncoder::EndTag()
{
U32 lenght = 0;
if(bSaveCompressed)
{
lenght = SDL_RWtell( stream );
unsigned int lenghtComp = 0;
//Get data
U8 *in = new U8[lenght];
U8 *out = new U8[lenght + lenght / 8 + 256];
SDL_RWclose(stream);
stream = SDL_RWFromFile( "gedTmp", "rb" );
SDL_RWread(stream, in, lenght, 1);
SDL_RWclose(stream);
#ifndef STAND_ALONE_GAME
remove("gedTmp");
#endif
//Restore real stream
stream = realStream;
//Compress
Compression comp;
if(bCompressThisResource)
{
lenghtComp = comp.DoCompression(in, lenght, out, lenght + lenght / 8 + 256);
}
else
{
lenghtComp = lenght;
}
if(lenghtComp < lenght)
SDL_RWwrite(stream, out, lenghtComp, 1);
else
{
SDL_RWwrite(stream, in, lenght, 1);
lenghtComp = lenght;
}
delete [] out;
delete [] in;
}
//End
U32 current = SDL_RWtell( stream );
// Write the jump.
GLASSERT( current > tagpos );
U32 jump = current - tagpos - 8; // Add the 8 to skip over the offset value itself
SDL_RWseek( stream, tagpos, SEEK_SET );
SDL_WriteLE32( stream, jump ); //Compressed size
if(bSaveCompressed) SDL_WriteLE32( stream, lenght ); //Real size
SDL_RWseek( stream, current, SEEK_SET );
tagpos = 0;
}
