[JK2SP] save files have screenshots again

Breaks save compatibility with earlier OpenJO versions.

Author: redsaurus

code/client/cl_scrn.cpp

@@ -584,9 +584,10 @@ void SCR_SetScreenshot(const byte *pbData, int w, int h)
 }
 
 
+#ifdef JK2_MODE
 // This is just a client-side wrapper for the function RE_TempRawImage_ReadFromFile() in the renderer code...
 //
-/*
+
 byte* SCR_TempRawImage_ReadFromFile(const char *psLocalFilename, int *piWidth, int *piHeight, byte *pbReSampleBuffer, qboolean qbVertFlip)
 {
 	return re.TempRawImage_ReadFromFile(psLocalFilename, piWidth, piHeight, pbReSampleBuffer, qbVertFlip);
@@ -598,5 +599,6 @@ void  SCR_TempRawImage_CleanUp()
 {
 	re.TempRawImage_CleanUp();
 }
-*/
+#endif
+
 

code/client/cl_ui.cpp

@@ -31,6 +31,9 @@ int PC_ReadTokenHandle(int handle, struct pc_token_s *pc_token);
 intptr_t CL_UISystemCalls( intptr_t *args );
 
 //prototypes
+#ifdef JK2_MODE
+extern qboolean SG_GetSaveImage( const char *psPathlessBaseName, void *pvAddress );
+#endif
 extern int SG_GetSaveGameComment(const char *psPathlessBaseName, char *sComment, char *sMapName);
 extern qboolean SG_GameAllowedToSaveHere(qboolean inCamera);
 extern void SG_StoreSaveGameComment(const char *sComment);
@@ -241,14 +244,18 @@ void CL_InitUI( void ) {
 	uii.Language_UsesSpaces		= re.Language_UsesSpaces;
 	uii.AnyLanguage_ReadCharFromString = re.AnyLanguage_ReadCharFromString;
 
-	//uii.SG_GetSaveImage			= SG_GetSaveImage;
+#ifdef JK2_MODE
+	uii.SG_GetSaveImage			= SG_GetSaveImage;
+#endif
 	uii.SG_GetSaveGameComment	= SG_GetSaveGameComment;
 	uii.SG_StoreSaveGameComment = SG_StoreSaveGameComment;
 	uii.SG_GameAllowedToSaveHere= SG_GameAllowedToSaveHere;
 
 	//uii.SCR_GetScreenshot		= SCR_GetScreenshot;
 
-	//uii.DrawStretchRaw			= re.DrawStretchRaw;
+#ifdef JK2_MODE
+	uii.DrawStretchRaw			= re.DrawStretchRaw;
+#endif
 	uii.R_ClearScene			= re.ClearScene;
 	uii.R_AddRefEntityToScene	= re.AddRefEntityToScene;
 	uii.R_AddPolyToScene		=  re.AddPolyToScene;
@@ -261,6 +268,10 @@ void CL_InitUI( void ) {
 	uii.R_DrawStretchPic		= re.DrawStretchPic;
 	uii.UpdateScreen			= SCR_UpdateScreen;
 
+#ifdef JK2_MODE
+	uii.PrecacheScreenshot		= SCR_PrecacheScreenshot;
+#endif
+
 	uii.R_LerpTag				= re.LerpTag;
 
 	uii.S_StartLocalLoopingSound= S_StartLocalLoopingSound;

code/client/client.h

@@ -371,6 +371,10 @@ void	SCR_DrawSmallStringExt( int x, int y, const char *string, float *setColor,
 void	SCR_DrawBigChar( int x, int y, int ch );
 void	SCR_DrawSmallChar( int x, int y, int ch );
 
+#ifdef JK2_MODE
+void	SCR_PrecacheScreenshot();
+#endif
+
 //
 // cl_cin.c
 //

code/qcommon/common.cpp

@@ -239,6 +239,9 @@ do the apropriate things.
 =============
 */
 void SG_Shutdown();
+#ifdef JK2_MODE
+extern void SCR_UnprecacheScreenshot();
+#endif
 void QDECL Com_Error( int code, const char *fmt, ... ) {
 	va_list		argptr;
 	static int	lastErrorTime;
@@ -267,6 +270,10 @@ void QDECL Com_Error( int code, const char *fmt, ... ) {
 	}
 	lastErrorTime = currentTime;
 
+#ifdef JK2_MODE
+	SCR_UnprecacheScreenshot();
+#endif
+	
 	va_start (argptr,fmt);
 	Q_vsnprintf (com_errorMessage, sizeof(com_errorMessage), fmt, argptr);
 	va_end (argptr);	

code/qcommon/qcommon.h

@@ -850,6 +850,11 @@ qboolean Sys_CopyFile(const char *lpExistingFileName, const char *lpNewFileName,
 
 
 byte*	SCR_GetScreenshot(qboolean *qValid);
+#ifdef JK2_MODE
+void	SCR_SetScreenshot(const byte *pbData, int w, int h);
+byte*	SCR_TempRawImage_ReadFromFile(const char *psLocalFilename, int *piWidth, int *piHeight, byte *pbReSampleBuffer, qboolean qbVertFlip);
+void	SCR_TempRawImage_CleanUp();
+#endif
 
 inline int Round(float value)
 {

code/rd-common/tr_common.h

@@ -45,6 +45,10 @@ void LoadJPG( const char *filename, byte **pic, int *width, int *height );
 // Load raw image data from PNG image.
 void LoadPNG( const char *filename, byte **data, int *width, int *height );
 
+#ifdef JK2_MODE
+//Load raw image data from JPEG input.
+void LoadJPGFromBuffer( byte *inputBuffer, size_t len, byte **pic, int *width, int *height );
+#endif
 
 /*
 ================================================================================

code/rd-common/tr_image_jpg.cpp

@@ -204,6 +204,157 @@ void LoadJPG( const char *filename, unsigned char **pic, int *width, int *height
 	/* And we're done! */
 }
 
+#ifdef JK2_MODE
+void LoadJPGFromBuffer( byte *inputBuffer, size_t len, unsigned char **pic, int *width, int *height ) {
+	/* This struct contains the JPEG decompression parameters and pointers to
+	 * working space (which is allocated as needed by the JPEG library).
+	 */
+	struct jpeg_decompress_struct cinfo = { NULL };
+	/* We use our private extension JPEG error handler.
+	 * Note that this struct must live as long as the main JPEG parameter
+	 * struct, to avoid dangling-pointer problems.
+	 */
+	/* This struct represents a JPEG error handler.  It is declared separately
+	 * because applications often want to supply a specialized error handler
+	 * (see the second half of this file for an example).  But here we just
+	 * take the easy way out and use the standard error handler, which will
+	 * print a message on stderr and call exit() if compression fails.
+	 * Note that this struct must live as long as the main JPEG parameter
+	 * struct, to avoid dangling-pointer problems.
+	 */
+	struct jpeg_error_mgr jerr;
+	/* More stuff */
+	JSAMPARRAY buffer;		/* Output row buffer */
+	unsigned int row_stride;  /* physical row width in output buffer */
+	unsigned int pixelcount, memcount;
+	unsigned int sindex, dindex;
+	byte *out;
+	byte  *buf;
+	
+	if (!inputBuffer) {
+		return;
+	}
+	
+	/* Step 1: allocate and initialize JPEG decompression object */
+	
+	/* We have to set up the error handler first, in case the initialization
+	 * step fails.  (Unlikely, but it could happen if you are out of memory.)
+	 * This routine fills in the contents of struct jerr, and returns jerr's
+	 * address which we place into the link field in cinfo.
+	 */
+	cinfo.err = jpeg_std_error(&jerr);
+	cinfo.err->error_exit = R_JPGErrorExit;
+	cinfo.err->output_message = R_JPGOutputMessage;
+	
+	/* Now we can initialize the JPEG decompression object. */
+	jpeg_create_decompress(&cinfo);
+	
+	/* Step 2: specify data source (eg, a file) */
+	
+	jpeg_mem_src(&cinfo, inputBuffer, len);
+	
+	/* Step 3: read file parameters with jpeg_read_header() */
+	
+	(void) jpeg_read_header(&cinfo, TRUE);
+	/* We can ignore the return value from jpeg_read_header since
+	 *   (a) suspension is not possible with the stdio data source, and
+	 *   (b) we passed TRUE to reject a tables-only JPEG file as an error.
+	 * See libjpeg.doc for more info.
+	 */
+	
+	/* Step 4: set parameters for decompression */
+	
+	
+	/* Make sure it always converts images to RGB color space. This will
+	 * automatically convert 8-bit greyscale images to RGB as well.	*/
+	cinfo.out_color_space = JCS_RGB;
+	
+	/* Step 5: Start decompressor */
+	
+	(void) jpeg_start_decompress(&cinfo);
+	/* We can ignore the return value since suspension is not possible
+	 * with the stdio data source.
+	 */
+	
+	/* We may need to do some setup of our own at this point before reading
+	 * the data.  After jpeg_start_decompress() we have the correct scaled
+	 * output image dimensions available, as well as the output colormap
+	 * if we asked for color quantization.
+	 * In this example, we need to make an output work buffer of the right size.
+	 */
+	/* JSAMPLEs per row in output buffer */
+	pixelcount = cinfo.output_width * cinfo.output_height;
+	
+	if(!cinfo.output_width || !cinfo.output_height
+	   || ((pixelcount * 4) / cinfo.output_width) / 4 != cinfo.output_height
+	   || pixelcount > 0x1FFFFFFF || cinfo.output_components != 3
+	   )
+	{
+		// Free the memory to make sure we don't leak memory
+		jpeg_destroy_decompress(&cinfo);
+		
+		ri.Printf( PRINT_ALL, "LoadJPG: invalid image format: %dx%d*4=%d, components: %d",
+				  cinfo.output_width, cinfo.output_height, pixelcount * 4, cinfo.output_components);
+		return;
+	}
+	
+	memcount = pixelcount * 4;
+	row_stride = cinfo.output_width * cinfo.output_components;
+	
+	out = (byte *)Z_Malloc(memcount, TAG_TEMP_WORKSPACE, qfalse);
+	
+	*width = cinfo.output_width;
+	*height = cinfo.output_height;
+	
+	/* Step 6: while (scan lines remain to be read) */
+	/*           jpeg_read_scanlines(...); */
+	
+	/* Here we use the library's state variable cinfo.output_scanline as the
+	 * loop counter, so that we don't have to keep track ourselves.
+	 */
+	while (cinfo.output_scanline < cinfo.output_height) {
+		/* jpeg_read_scanlines expects an array of pointers to scanlines.
+		 * Here the array is only one element long, but you could ask for
+		 * more than one scanline at a time if that's more convenient.
+		 */
+		buf = ((out+(row_stride*cinfo.output_scanline)));
+		buffer = &buf;
+		(void) jpeg_read_scanlines(&cinfo, buffer, 1);
+	}
+	
+	buf = out;
+	// Expand from RGB to RGBA
+	sindex = pixelcount * cinfo.output_components;
+	dindex = memcount;
+	
+	do {
+		buf[--dindex] = 255;
+		buf[--dindex] = buf[--sindex];
+		buf[--dindex] = buf[--sindex];
+		buf[--dindex] = buf[--sindex];
+	} while(sindex);
+	
+	*pic = out;
+	
+	/* Step 7: Finish decompression */
+	
+	(void) jpeg_finish_decompress(&cinfo);
+	/* We can ignore the return value since suspension is not possible
+	 * with the stdio data source.
+	 */
+	
+	/* Step 8: Release JPEG decompression object */
+	
+	/* This is an important step since it will release a good deal of memory. */
+	jpeg_destroy_decompress(&cinfo);
+	
+	/* At this point you may want to check to see whether any corrupt-data
+	 * warnings occurred (test whether jerr.pub.num_warnings is nonzero).
+	 */
+	
+	/* And we're done! */
+}
+#endif
 
 /* Expanded data destination object for stdio output */
 

code/rd-common/tr_public.h

@@ -206,6 +206,11 @@ typedef struct {
 
 	// for use with save-games mainly...
 	void	(*GetScreenShot)(byte *data, int w, int h);
+	
+#ifdef JK2_MODE
+	size_t	(*SaveJPGToBuffer)(byte *buffer, size_t bufSize, int quality, int image_width, int image_height, byte *image_buffer, int padding );
+	void	(*LoadJPGFromBuffer)( byte *inputBuffer, size_t len, byte **pic, int *width, int *height );
+#endif
 
 	// this is so you can get access to raw pixels from a graphics format (TGA/JPG/BMP etc), 
 	//	currently only the save game uses it (to make raw shots for the autosaves)