fceux/video.cpp

/* FCE Ultra - NES/Famicom Emulator
 *
 * Copyright notice for this file:
 *  Copyright (C) 2002 Xodnizel
 *
 * This program 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 2 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, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */

#include <string.h>
#include <stdio.h>
#include <stdlib.h>
#include <stdarg.h>
#include <zlib.h>

#ifdef _USE_SHARED_MEMORY_
#include <windows.h>
#endif

#include "types.h"
#include "video.h"
#include "fceu.h"
#include "general.h"
#include "memory.h"
#include "crc32.h"
#include "state.h"
#include "movie.h"
#include "palette.h"
#include "nsf.h"
#include "input.h"
#include "vsuni.h"

uint8 *XBuf=NULL;
uint8 *XBackBuf=NULL;
static uint8 *xbsave=NULL;

//for input display
extern int input_display;
extern uint32 cur_input_display;

#ifdef _USE_SHARED_MEMORY_
HANDLE mapXBuf;
#endif

void FCEU_KillVirtualVideo(void)
{
	//mbg merge TODO 7/17/06 temporarily removed
 //if(xbsave)
 //{
 // free(xbsave);
 // xbsave=0;
 //}
 //if(XBuf)
 //{
	//UnmapViewOfFile(XBuf);
	//CloseHandle(mapXBuf);
	//mapXBuf=NULL;
 //}
 //if(XBackBuf)
 //{
 // free(XBackBuf);
 // XBackBuf=0;
 //}
}

int FCEU_InitVirtualVideo(void)
{
 if(!XBuf)		/* Some driver code may allocate XBuf externally. */
			/* 256 bytes per scanline, * 240 scanline maximum, +8 for alignment,
			*/
#ifdef _USE_SHARED_MEMORY_
	mapXBuf  = CreateFileMapping((HANDLE)0xFFFFFFFF,NULL,PAGE_READWRITE, 0, 256 * 256 + 8,"fceu.XBuf");
	if(mapXBuf == NULL || GetLastError() == ERROR_ALREADY_EXISTS)
	{
		CloseHandle(mapXBuf);
		mapXBuf = NULL;
		XBuf= (uint8*) (FCEU_malloc(256 * 256 + 8));
		XBackBuf= (uint8*) (FCEU_malloc(256 * 256 + 8));
	}
	else
	{
		XBuf     = (uint8 *)MapViewOfFile(mapXBuf, FILE_MAP_WRITE, 0, 0, 0);

		XBackBuf = (uint8*) (FCEU_malloc(256 * 256 + 8));
	}

	if (!XBuf || !XBackBuf)
		return 0;
#else
 if(!(XBuf= (uint8*) (FCEU_malloc(256 * 256 + 8))) ||
    !(XBackBuf= (uint8*) (FCEU_malloc(256 * 256 + 8))))
  return 0;
#endif //_USE_SHARED_MEMORY_
 xbsave=XBuf;

 if(sizeof(uint8*)==4)
 {
  uint32 m;
  m=(uint32)XBuf;
  m=(4-m)&3;
  XBuf+=m;
 } 
 memset(XBuf,128,256*256); //*240);
 memset(XBackBuf,128,256*256);
 return 1;
}

int howlong;
static char errmsg[65];

#include "drawing.h"
#ifdef FRAMESKIP

//#define SHOWFPS
void ShowFPS(void);
void FCEU_PutImageDummy(void)
{
 #ifdef SHOWFPS
 ShowFPS();
 #endif
 if(FCEUGameInfo->type!=GIT_NSF)
 {
  FCEU_DrawNTSCControlBars(XBuf);
  FCEU_DrawSaveStates(XBuf);
  FCEU_DrawMovies(XBuf);
 }
 if(howlong) howlong--; /* DrawMessage() */
}
#endif

static int dosnapsave=0;
void FCEUI_SaveSnapshot(void)
{
 dosnapsave=1;
}
 
static void FCEU_DrawRecordingStatus(uint8* XBuf)
{
	int n=0;
	if(FCEUD_ShowStatusIcon())
	{
		if(FCEUI_EmulationPaused())
			n=3;
		else if(FCEUI_IsMovieActive()>0)
			n=2;
		else if(FCEUI_IsMovieActive()<0)
			n=1;
	}

	if(n)
		FCEU_DrawRecordingStatusN(XBuf, n);
}

static void ReallySnap(void)
{
 int x=SaveSnapshot();
 if(!x)
  FCEU_DispMessage("Error saving screen snapshot.");
 else
  FCEU_DispMessage("Screen snapshot %d saved.",x-1);
}

void FCEU_PutImage(void)
{
	#ifdef SHOWFPS
	ShowFPS();
	#endif
/*
		 // HACK to record input and/or frame counter into AVI
		 extern int frame_display, input_display, movcounter;
		 int movieDrawInAVI = FCEUI_AviIsRecording() && (frame_display || input_display) && movcounter;
		 if(movieDrawInAVI)
		 {
			FCEU_DrawMovies(XBuf);
			DrawMessage();
		 }
*/
        if(FCEUGameInfo->type==GIT_NSF)
        {
         DrawNSF(XBuf);
         /* Save snapshot after NSF screen is drawn.  Why would we want to
            do it before?
         */
         if(dosnapsave)
         {
          ReallySnap();
          dosnapsave=0;
         }
        } 
        else
        {
         /* Update AVI before overlay stuff is written */
         if(!FCEUI_EmulationPaused())
          FCEUI_AviVideoUpdate(XBuf);
         /* Save backbuffer before overlay stuff is written. */
         if(!FCEUI_EmulationPaused())
          memcpy(XBackBuf, XBuf, 256*256);
         /* Save snapshot before overlay stuff is written. */
         if(dosnapsave)
         {
          ReallySnap();
          dosnapsave=0;
         }
         if(FCEUGameInfo->type==GIT_VSUNI)
          FCEU_VSUniDraw(XBuf);
		 FCEU_DrawSaveStates(XBuf);
		 FCEU_DrawMovies(XBuf);
         FCEU_DrawNTSCControlBars(XBuf);
		 FCEU_DrawRecordingStatus(XBuf);
        }
//		if(!movieDrawInAVI)
	        DrawMessage();
        FCEU_DrawInput(XBuf);

		//Fancy input display code
		if(input_display)
		{
			int controller, c, color;
			int i, j;
			uint8 *t = XBuf+(FSettings.LastSLine-9)*256 + 20; //mbg merge 7/17/06 changed t to uint8*
			if(input_display > 4) input_display = 4;
			for(controller = 0; controller < input_display; controller++, t += 56)
			{
				for(i = 0; i < 34;i++)
					for(j = 0; j <9 ; j++)
						t[i+j*256] = (t[i+j*256] & 15) | 0xC0;
				for(i = 3; i < 6; i++)
					for(j = 3; j< 6; j++)
						t[i+j*256] = 3;
				c = cur_input_display >> (controller * 8);
				c &= 255;
				//A
				color = c&1?4:3;
				for(i=0; i < 4; i++)
				{
					for(j = 0; j < 4; j++)
					{
						if(i%3==0 && j %3 == 0)
							continue;
						t[30+4*256+i+j*256] = color;
					}
				}
				//B
				color = c&2?4:3;
				for(i=0; i < 4; i++)
				{
					for(j = 0; j < 4; j++)
					{
						if(i%3==0 && j %3 == 0)
							continue;
						t[24+4*256+i+j*256] = color;
					}
				}
				//Select
				color = c&4?4:3;
				for(i = 0; i < 4; i++)
				{
					t[11+5*256+i] = color;
					t[11+6*256+i] = color;
				}
				//Start
				color = c&8?4:3;
				for(i = 0; i < 4; i++)
				{
					t[17+5*256+i] = color;
					t[17+6*256+i] = color;
				}
				//Up
				color = c&16?4:3;
				for(i = 0; i < 3; i++)
				{
					for(j = 0; j < 3; j++)
					{
						t[3+i+256*j] = color;
					}
				}
				//Down
				color = c&32?4:3;
				for(i = 0; i < 3; i++)
				{
					for(j = 0; j < 3; j++)
					{
						t[3+i+256*j+6*256] = color;
					}
				}
				//Left
				color = c&64?4:3;
				for(i = 0; i < 3; i++)
				{
					for(j = 0; j < 3; j++)
					{
						t[3*256+i+256*j] = color;
					}
				}
				//Right
				color = c&128?4:3;
				for(i = 0; i < 3; i++)
				{
					for(j = 0; j < 3; j++)
					{
						t[6+3*256+i+256*j] = color;
					}
				}
			}
		}
}

void FCEU_DispMessage(char *format, ...)
{
 va_list ap;

 va_start(ap,format);
 vsprintf(errmsg,format,ap);
 va_end(ap);

 howlong=180;

 extern int movcounter;
 movcounter=0;
}

void FCEU_ResetMessages(void)
{
 howlong=0;
}


static int WritePNGChunk(FILE *fp, uint32 size, char *type, uint8 *data)
{
 uint32 crc;

 uint8 tempo[4];

 tempo[0]=size>>24;
 tempo[1]=size>>16;
 tempo[2]=size>>8;
 tempo[3]=size;

 if(fwrite(tempo,4,1,fp)!=1)
  return 0;
 if(fwrite(type,4,1,fp)!=1)
  return 0;

 if(size)
  if(fwrite(data,1,size,fp)!=size)
   return 0;

 crc=CalcCRC32(0,(uint8 *)type,4);
 if(size)
  crc=CalcCRC32(crc,data,size);

 tempo[0]=crc>>24;
 tempo[1]=crc>>16;
 tempo[2]=crc>>8;
 tempo[3]=crc;

 if(fwrite(tempo,4,1,fp)!=1)
  return 0;
 return 1;
}

int SaveSnapshot(void)
{
 static unsigned int lastu=0;

 char *fn=0;
 int totallines=FSettings.LastSLine-FSettings.FirstSLine+1;
 int x,u,y;
 FILE *pp=NULL;
 uint8 *compmem=NULL;
 uLongf compmemsize=totallines*263+12;

 if(!(compmem=(uint8 *)FCEU_malloc(compmemsize)))
  return 0;

 for(u=lastu;u<99999;u++)
 {
  pp=FCEUD_UTF8fopen((fn=FCEU_MakeFName(FCEUMKF_SNAP,u,"png")),"rb");
  if(pp==NULL) break;
  fclose(pp);
 }

 lastu=u;

 if(!(pp=FCEUD_UTF8fopen(fn,"wb")))
 {
  free(fn);
  return 0;
 }
 free(fn);
 {
  static uint8 header[8]={137,80,78,71,13,10,26,10};
  if(fwrite(header,8,1,pp)!=1)
   goto PNGerr;
 }

 {
  uint8 chunko[13];

  chunko[0]=chunko[1]=chunko[3]=0;
  chunko[2]=0x1;			// Width of 256

  chunko[4]=chunko[5]=chunko[6]=0;
  chunko[7]=totallines;			// Height

  chunko[8]=8;				// bit depth
  chunko[9]=3;				// Color type; indexed 8-bit
  chunko[10]=0;				// compression: deflate
  chunko[11]=0;				// Basic adapative filter set(though none are used).
  chunko[12]=0;				// No interlace.

  if(!WritePNGChunk(pp,13,"IHDR",chunko))
   goto PNGerr;
 }

 {
  uint8 pdata[256*3];
  for(x=0;x<256;x++)
   FCEUD_GetPalette(x,pdata+x*3,pdata+x*3+1,pdata+x*3+2);
  if(!WritePNGChunk(pp,256*3,"PLTE",pdata))
   goto PNGerr;
 }

 {
  uint8 *tmp=XBuf+FSettings.FirstSLine*256;
  uint8 *dest,*mal,*mork;

  if(!(mal=mork=dest=(uint8 *)malloc((totallines<<8)+totallines)))
   goto PNGerr;
 //   mork=dest=XBuf;

  for(y=0;y<totallines;y++)
  {
   *dest=0;			// No filter.
   dest++;
   for(x=256;x;x--,tmp++,dest++)
    *dest=*tmp; 	
  }

  if(compress(compmem,&compmemsize,mork,(totallines<<8)+totallines)!=Z_OK)
  {
   if(mal) free(mal);
   goto PNGerr;
  }
  if(mal) free(mal);
  if(!WritePNGChunk(pp,compmemsize,"IDAT",compmem))
   goto PNGerr;
 }
 if(!WritePNGChunk(pp,0,"IEND",0))
  goto PNGerr;

 free(compmem);
 fclose(pp);

 return u+1;


 PNGerr:
 if(compmem)
  free(compmem);
 if(pp)
  fclose(pp);
 return(0);
}
#ifdef SHOWFPS
uint64 FCEUD_GetTime(void);
uint64 FCEUD_GetTimeFreq(void);

static uint64 boop[60];
static int boopcount = 0;

void ShowFPS(void)
{ 
 uint64 da = FCEUD_GetTime() - boop[boopcount];
 char fpsmsg[16];
 int booplimit = PAL?50:60;
 boop[boopcount] = FCEUD_GetTime();

 sprintf(fpsmsg, "%8.1f",(double)booplimit / ((double)da / FCEUD_GetTimeFreq()));
 DrawTextTrans(XBuf + (256-8-8*8) + (FSettings.FirstSLine+4)*256,256,fpsmsg,4);
 // It's not averaging FPS over exactly 1 second, but it's close enough.
 boopcount = (boopcount + 1) % booplimit;
}
#endif