//

// Copyright (c) 2009, Wei Mingzhi <whistler_wmz@users.sf.net>.

// All rights reserved.

//

// Portions based on PalLibrary by Lou Yihua <louyihua@21cn.com>.

// Copyright (c) 2006-2007, Lou Yihua.

//

// This file is part of SDLPAL.

//

// SDLPAL is free software: you can redistribute it and/or modify

// it under the terms of the GNU General Public License as published by

// the Free Software Foundation, either version 3 of the License, or

// (at your option) any later version.

//

// This program is distributed in the hope that it will be useful,

// but WITHOUT ANY WARRANTY; without even the implied warranty of

// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

// GNU General Public License for more details.

//

// You should have received a copy of the GNU General Public License

// along with this program. If not, see <http://www.gnu.org/licenses/>.

//

#include "main.h"

static INT

PAL_RNGReadFrame(

)

/*++

Purpose:

Read a frame from a RNG animation.

Parameters:

[OUT] lpBuffer - pointer to the destination buffer.

[IN] uiBufferSize - size of the destination buffer.

[IN] uiRngNum - the number of the RNG animation in the MKF archive.

[IN] uiFrameNum - frame number in the RNG animation.

[IN] fpRngMKF - pointer to the fopen'ed MKF file.

Return value:

Integer value which indicates the size of the chunk.

-1 if there are error in parameters.

-2 if buffer size is not enough.

--*/

{

UINT uiOffset = 0;

UINT uiSubOffset = 0;

UINT uiNextOffset = 0;

UINT uiChunkCount = 0;

INT iChunkLen = 0;

if (lpBuffer == NULL || fpRngMKF == NULL || uiBufferSize == 0)

{

return -1;

}

//

// Get the total number of chunks.

//

uiChunkCount = PAL_MKFGetChunkCount(fpRngMKF);

if (uiRngNum >= uiChunkCount)

{

return -1;

}

//

// Get the offset of the chunk.

//

_fseek(fpRngMKF, 4 * uiRngNum, SEEK_SET);

_fread(&uiOffset, sizeof(UINT), 1, fpRngMKF);

_fread(&uiNextOffset, sizeof(UINT), 1, fpRngMKF);

uiOffset = SWAP32(uiOffset);

uiNextOffset = SWAP32(uiNextOffset);

//

// Get the length of the chunk.

//

iChunkLen = uiNextOffset - uiOffset;

if (iChunkLen != 0)

{

_fseek(fpRngMKF, uiOffset, SEEK_SET);

}

else

{

return -1;

}

//

// Get the number of sub chunks.

//

_fread(&uiChunkCount, sizeof(UINT), 1, fpRngMKF);

uiChunkCount = (SWAP32(uiChunkCount) - 4) / 4;

if (uiFrameNum >= uiChunkCount)

{

return -1;

}

//

// Get the offset of the sub chunk.

//

_fseek(fpRngMKF, uiOffset + 4 * uiFrameNum, SEEK_SET);

_fread(&uiSubOffset, sizeof(UINT), 1, fpRngMKF);

_fread(&uiNextOffset, sizeof(UINT), 1, fpRngMKF);

uiSubOffset = SWAP32(uiSubOffset);

uiNextOffset = SWAP32(uiNextOffset);

//

// Get the length of the sub chunk.

//

iChunkLen = uiNextOffset - uiSubOffset;

if ((UINT)iChunkLen > uiBufferSize)

{

return -2;

}

if (iChunkLen != 0)

{

_fseek(fpRngMKF, uiOffset + uiSubOffset, SEEK_SET);

_fread(lpBuffer, iChunkLen, 1, fpRngMKF);

}

else

{

return -1;

}

return iChunkLen;

}

static INT

PAL_RNGBlitToSurface(

)

/*++

Purpose:

Blit one frame in an RNG animation to an SDL surface.

The surface should contain the last frame of the RNG, or blank if it's the first

frame.

NOTE: Assume the surface is already locked, and the surface is a 320x200 8-bit one.

Parameters:

[IN] iNumRNG - The number of the animation in the MKF archive.

[IN] iNumFrame - The number of the frame in the animation.

[OUT] lpDstSurface - pointer to the destination SDL surface.

[IN] fpRngMKF - Pointer to the fopen'ed rng.mkf file.

Return value:

0 = success, -1 = error.

--*/

{

INT ptr = 0;

INT dst_ptr = 0;

BYTE data = 0;

WORD wdata = 0;

INT x, y, i, n;

LPBYTE rng = NULL;

LPBYTE buf = NULL;

//

// Check for invalid parameters.

//

if (lpDstSurface == NULL || iNumRNG < 0 || iNumFrame < 0)

{

return -1;

}

buf = (LPBYTE)calloc(1, 65000);

if (buf == NULL)

{

return -1;

}

//

// Read the frame.

//

if (PAL_RNGReadFrame(buf, 65000, iNumRNG, iNumFrame, fpRngMKF) < 0)

{

free(buf);

return -1;

}

//

// Decompress the frame.

//

rng = (LPBYTE)calloc(1, 65000);

if (rng == NULL)

{

free(buf);

return -1;

}

Decompress(buf, rng, 65000);

free(buf);

//

// Draw the frame to the surface.

// FIXME: Dirty and ineffective code, needs to be cleaned up

//

while (TRUE)

{

data = rng[ptr++];

switch (data)

{

case 0x00:

case 0x13:

//

// End

//

goto end;

case 0x02:

dst_ptr += 2;

break;

case 0x03:

data = rng[ptr++];

dst_ptr += (data + 1) * 2;

break;

case 0x04:

wdata = rng[ptr] | (rng[ptr + 1] << 8);

ptr += 2;

dst_ptr += ((unsigned int)wdata + 1) * 2;

break;

case 0x0a:

x = dst_ptr % 320;

y = dst_ptr / 320;

((LPBYTE)(lpDstSurface->pixels))[y * lpDstSurface->pitch + x] = rng[ptr++];

if (++x >= 320)

{

x = 0;

++y;

}

((LPBYTE)(lpDstSurface->pixels))[y * lpDstSurface->pitch + x] = rng[ptr++];

dst_ptr += 2;

case 0x09:

x = dst_ptr % 320;

y = dst_ptr / 320;

((LPBYTE)(lpDstSurface->pixels))[y * lpDstSurface->pitch + x] = rng[ptr++];

if (++x >= 320)

{

x = 0;

++y;

}

((LPBYTE)(lpDstSurface->pixels))[y * lpDstSurface->pitch + x] = rng[ptr++];

dst_ptr += 2;

case 0x08:

x = dst_ptr % 320;

y = dst_ptr / 320;

((LPBYTE)(lpDstSurface->pixels))[y * lpDstSurface->pitch + x] = rng[ptr++];

if (++x >= 320)

{

x = 0;

++y;

}

((LPBYTE)(lpDstSurface->pixels))[y * lpDstSurface->pitch + x] = rng[ptr++];

dst_ptr += 2;

case 0x07:

x = dst_ptr % 320;

y = dst_ptr / 320;

((LPBYTE)(lpDstSurface->pixels))[y * lpDstSurface->pitch + x] = rng[ptr++];

if (++x >= 320)

{

x = 0;

++y;

}

((LPBYTE)(lpDstSurface->pixels))[y * lpDstSurface->pitch + x] = rng[ptr++];

dst_ptr += 2;

case 0x06:

x = dst_ptr % 320;

y = dst_ptr / 320;

((LPBYTE)(lpDstSurface->pixels))[y * lpDstSurface->pitch + x] = rng[ptr++];

if (++x >= 320)

{

x = 0;

++y;

}

((LPBYTE)(lpDstSurface->pixels))[y * lpDstSurface->pitch + x] = rng[ptr++];

dst_ptr += 2;

break;

case 0x0b:

data = *(rng + ptr++);

for (i = 0; i <= data; i++)

{

x = dst_ptr % 320;

y = dst_ptr / 320;

((LPBYTE)(lpDstSurface->pixels))[y * lpDstSurface->pitch + x] = rng[ptr++];

if (++x >= 320)

{

x = 0;

++y;

}

((LPBYTE)(lpDstSurface->pixels))[y * lpDstSurface->pitch + x] = rng[ptr++];

dst_ptr += 2;

}

break;

case 0x0c:

wdata = rng[ptr] | (rng[ptr + 1] << 8);

ptr += 2;

for (i = 0; i <= wdata; i++)

{

x = dst_ptr % 320;

y = dst_ptr / 320;

((LPBYTE)(lpDstSurface->pixels))[y * lpDstSurface->pitch + x] = rng[ptr++];

if (++x >= 320)

{

x = 0;

++y;

}

((LPBYTE)(lpDstSurface->pixels))[y * lpDstSurface->pitch + x] = rng[ptr++];

dst_ptr += 2;

}

break;

case 0x0d:

case 0x0e:

case 0x0f:

case 0x10:

for (i = 0; i < data - (0x0d - 2); i++)

{

x = dst_ptr % 320;

y = dst_ptr / 320;

((LPBYTE)(lpDstSurface->pixels))[y * lpDstSurface->pitch + x] = rng[ptr];

if (++x >= 320)

{

x = 0;

++y;

}

((LPBYTE)(lpDstSurface->pixels))[y * lpDstSurface->pitch + x] = rng[ptr + 1];

dst_ptr += 2;

}

ptr += 2;

break;

case 0x11:

data = *(rng + ptr++);

for (i = 0; i <= data; i++)

{

x = dst_ptr % 320;

y = dst_ptr / 320;

((LPBYTE)(lpDstSurface->pixels))[y * lpDstSurface->pitch + x] = rng[ptr];

if (++x >= 320)

{

x = 0;

++y;

}

((LPBYTE)(lpDstSurface->pixels))[y * lpDstSurface->pitch + x] = rng[ptr + 1];

dst_ptr += 2;

}

ptr += 2;

break;

case 0x12:

n = (rng[ptr] | (rng[ptr + 1] << 8)) + 1;

ptr += 2;

for (i = 0; i < n; i++)

{

x = dst_ptr % 320;

y = dst_ptr / 320;

((LPBYTE)(lpDstSurface->pixels))[y * lpDstSurface->pitch + x] = rng[ptr];

if (++x >= 320)

{

x = 0;

++y;

}

((LPBYTE)(lpDstSurface->pixels))[y * lpDstSurface->pitch + x] = rng[ptr + 1];

dst_ptr += 2;

}

ptr += 2;

break;

}

}

end:

free(rng);

return 0;

}

VOID

PAL_RNGPlay(

)

/*++

Purpose:

Play a RNG movie.

Parameters:

[IN] iNumRNG - number of the RNG movie.

[IN] iStartFrame - start frame number.

[IN] iEndFrame - end frame number.

[IN] iSpeed - speed of playing.

Return value:

None.

--*/

{

UINT iTime;

int iDelay = 800 / (iSpeed == 0 ? 16 : iSpeed);

FILE *fp;

fp = UTIL_OpenRequiredFile("rng.mkf.tns");

for (; iStartFrame <= iEndFrame; iStartFrame++)

{

iTime = SDL_GetTicks() + iDelay;

if (PAL_RNGBlitToSurface(iNumRNG, iStartFrame, gpScreen, fp) == -1)

{

//

// Failed to get the frame, don't go further

//

UTIL_CloseFile(fp);

return;

}

//

// Update the screen

//

VIDEO_UpdateScreen(NULL);

//

// Fade in the screen if needed

//

if (gpGlobals->fNeedToFadeIn)

{

PAL_FadeIn(gpGlobals->wNumPalette, gpGlobals->fNightPalette, 1);

gpGlobals->fNeedToFadeIn = FALSE;

}

//

// Delay for a while

//

PAL_ProcessEvent();

while (SDL_GetTicks() <= iTime)

{

PAL_ProcessEvent();

SDL_Delay(1);

}

}

UTIL_CloseFile(fp);

}