mirror of
https://github.com/ZDoom/Raze.git
synced 2024-12-11 05:11:07 +00:00
718112a8fe
Currently none of these is being used, but eventually they will, once more code gets ported over. So it's better to have them right away and avoid editing the project file too much, only to revert that later.
253 lines
7.7 KiB
C
253 lines
7.7 KiB
C
/*
|
|
* jerror.c
|
|
*
|
|
* Copyright (C) 1991-1998, Thomas G. Lane.
|
|
* Modified 2012-2015 by Guido Vollbeding.
|
|
* This file is part of the Independent JPEG Group's software.
|
|
* For conditions of distribution and use, see the accompanying README file.
|
|
*
|
|
* This file contains simple error-reporting and trace-message routines.
|
|
* These are suitable for Unix-like systems and others where writing to
|
|
* stderr is the right thing to do. Many applications will want to replace
|
|
* some or all of these routines.
|
|
*
|
|
* If you define USE_WINDOWS_MESSAGEBOX in jconfig.h or in the makefile,
|
|
* you get a Windows-specific hack to display error messages in a dialog box.
|
|
* It ain't much, but it beats dropping error messages into the bit bucket,
|
|
* which is what happens to output to stderr under most Windows C compilers.
|
|
*
|
|
* These routines are used by both the compression and decompression code.
|
|
*/
|
|
|
|
#ifdef USE_WINDOWS_MESSAGEBOX
|
|
#include <windows.h>
|
|
#endif
|
|
|
|
/* this is not a core library module, so it doesn't define JPEG_INTERNALS */
|
|
#include "jinclude.h"
|
|
#include "jpeglib.h"
|
|
#include "jversion.h"
|
|
#include "jerror.h"
|
|
|
|
#ifndef EXIT_FAILURE /* define exit() codes if not provided */
|
|
#define EXIT_FAILURE 1
|
|
#endif
|
|
|
|
|
|
/*
|
|
* Create the message string table.
|
|
* We do this from the master message list in jerror.h by re-reading
|
|
* jerror.h with a suitable definition for macro JMESSAGE.
|
|
* The message table is made an external symbol just in case any applications
|
|
* want to refer to it directly.
|
|
*/
|
|
|
|
#ifdef NEED_SHORT_EXTERNAL_NAMES
|
|
#define jpeg_std_message_table jMsgTable
|
|
#endif
|
|
|
|
#define JMESSAGE(code,string) string ,
|
|
|
|
const char * const jpeg_std_message_table[] = {
|
|
#include "jerror.h"
|
|
NULL
|
|
};
|
|
|
|
|
|
/*
|
|
* Error exit handler: must not return to caller.
|
|
*
|
|
* Applications may override this if they want to get control back after
|
|
* an error. Typically one would longjmp somewhere instead of exiting.
|
|
* The setjmp buffer can be made a private field within an expanded error
|
|
* handler object. Note that the info needed to generate an error message
|
|
* is stored in the error object, so you can generate the message now or
|
|
* later, at your convenience.
|
|
* You should make sure that the JPEG object is cleaned up (with jpeg_abort
|
|
* or jpeg_destroy) at some point.
|
|
*/
|
|
|
|
METHODDEF(noreturn_t)
|
|
error_exit (j_common_ptr cinfo)
|
|
{
|
|
/* Always display the message */
|
|
(*cinfo->err->output_message) (cinfo);
|
|
|
|
/* Let the memory manager delete any temp files before we die */
|
|
jpeg_destroy(cinfo);
|
|
|
|
exit(EXIT_FAILURE);
|
|
}
|
|
|
|
|
|
/*
|
|
* Actual output of an error or trace message.
|
|
* Applications may override this method to send JPEG messages somewhere
|
|
* other than stderr.
|
|
*
|
|
* On Windows, printing to stderr is generally completely useless,
|
|
* so we provide optional code to produce an error-dialog popup.
|
|
* Most Windows applications will still prefer to override this routine,
|
|
* but if they don't, it'll do something at least marginally useful.
|
|
*
|
|
* NOTE: to use the library in an environment that doesn't support the
|
|
* C stdio library, you may have to delete the call to fprintf() entirely,
|
|
* not just not use this routine.
|
|
*/
|
|
|
|
METHODDEF(void)
|
|
output_message (j_common_ptr cinfo)
|
|
{
|
|
char buffer[JMSG_LENGTH_MAX];
|
|
|
|
/* Create the message */
|
|
(*cinfo->err->format_message) (cinfo, buffer);
|
|
|
|
#ifdef USE_WINDOWS_MESSAGEBOX
|
|
/* Display it in a message dialog box */
|
|
MessageBox(GetActiveWindow(), buffer, "JPEG Library Error",
|
|
MB_OK | MB_ICONERROR);
|
|
#else
|
|
/* Send it to stderr, adding a newline */
|
|
fprintf(stderr, "%s\n", buffer);
|
|
#endif
|
|
}
|
|
|
|
|
|
/*
|
|
* Decide whether to emit a trace or warning message.
|
|
* msg_level is one of:
|
|
* -1: recoverable corrupt-data warning, may want to abort.
|
|
* 0: important advisory messages (always display to user).
|
|
* 1: first level of tracing detail.
|
|
* 2,3,...: successively more detailed tracing messages.
|
|
* An application might override this method if it wanted to abort on warnings
|
|
* or change the policy about which messages to display.
|
|
*/
|
|
|
|
METHODDEF(void)
|
|
emit_message (j_common_ptr cinfo, int msg_level)
|
|
{
|
|
struct jpeg_error_mgr * err = cinfo->err;
|
|
|
|
if (msg_level < 0) {
|
|
/* It's a warning message. Since corrupt files may generate many warnings,
|
|
* the policy implemented here is to show only the first warning,
|
|
* unless trace_level >= 3.
|
|
*/
|
|
if (err->num_warnings == 0 || err->trace_level >= 3)
|
|
(*err->output_message) (cinfo);
|
|
/* Always count warnings in num_warnings. */
|
|
err->num_warnings++;
|
|
} else {
|
|
/* It's a trace message. Show it if trace_level >= msg_level. */
|
|
if (err->trace_level >= msg_level)
|
|
(*err->output_message) (cinfo);
|
|
}
|
|
}
|
|
|
|
|
|
/*
|
|
* Format a message string for the most recent JPEG error or message.
|
|
* The message is stored into buffer, which should be at least JMSG_LENGTH_MAX
|
|
* characters. Note that no '\n' character is added to the string.
|
|
* Few applications should need to override this method.
|
|
*/
|
|
|
|
METHODDEF(void)
|
|
format_message (j_common_ptr cinfo, char * buffer)
|
|
{
|
|
struct jpeg_error_mgr * err = cinfo->err;
|
|
int msg_code = err->msg_code;
|
|
const char * msgtext = NULL;
|
|
const char * msgptr;
|
|
char ch;
|
|
boolean isstring;
|
|
|
|
/* Look up message string in proper table */
|
|
if (msg_code > 0 && msg_code <= err->last_jpeg_message) {
|
|
msgtext = err->jpeg_message_table[msg_code];
|
|
} else if (err->addon_message_table != NULL &&
|
|
msg_code >= err->first_addon_message &&
|
|
msg_code <= err->last_addon_message) {
|
|
msgtext = err->addon_message_table[msg_code - err->first_addon_message];
|
|
}
|
|
|
|
/* Defend against bogus message number */
|
|
if (msgtext == NULL) {
|
|
err->msg_parm.i[0] = msg_code;
|
|
msgtext = err->jpeg_message_table[0];
|
|
}
|
|
|
|
/* Check for string parameter, as indicated by %s in the message text */
|
|
isstring = FALSE;
|
|
msgptr = msgtext;
|
|
while ((ch = *msgptr++) != '\0') {
|
|
if (ch == '%') {
|
|
if (*msgptr == 's') isstring = TRUE;
|
|
break;
|
|
}
|
|
}
|
|
|
|
/* Format the message into the passed buffer */
|
|
if (isstring)
|
|
sprintf(buffer, msgtext, err->msg_parm.s);
|
|
else
|
|
sprintf(buffer, msgtext,
|
|
err->msg_parm.i[0], err->msg_parm.i[1],
|
|
err->msg_parm.i[2], err->msg_parm.i[3],
|
|
err->msg_parm.i[4], err->msg_parm.i[5],
|
|
err->msg_parm.i[6], err->msg_parm.i[7]);
|
|
}
|
|
|
|
|
|
/*
|
|
* Reset error state variables at start of a new image.
|
|
* This is called during compression startup to reset trace/error
|
|
* processing to default state, without losing any application-specific
|
|
* method pointers. An application might possibly want to override
|
|
* this method if it has additional error processing state.
|
|
*/
|
|
|
|
METHODDEF(void)
|
|
reset_error_mgr (j_common_ptr cinfo)
|
|
{
|
|
cinfo->err->num_warnings = 0;
|
|
/* trace_level is not reset since it is an application-supplied parameter */
|
|
cinfo->err->msg_code = 0; /* may be useful as a flag for "no error" */
|
|
}
|
|
|
|
|
|
/*
|
|
* Fill in the standard error-handling methods in a jpeg_error_mgr object.
|
|
* Typical call is:
|
|
* struct jpeg_compress_struct cinfo;
|
|
* struct jpeg_error_mgr err;
|
|
*
|
|
* cinfo.err = jpeg_std_error(&err);
|
|
* after which the application may override some of the methods.
|
|
*/
|
|
|
|
GLOBAL(struct jpeg_error_mgr *)
|
|
jpeg_std_error (struct jpeg_error_mgr * err)
|
|
{
|
|
err->error_exit = error_exit;
|
|
err->emit_message = emit_message;
|
|
err->output_message = output_message;
|
|
err->format_message = format_message;
|
|
err->reset_error_mgr = reset_error_mgr;
|
|
|
|
err->trace_level = 0; /* default = no tracing */
|
|
err->num_warnings = 0; /* no warnings emitted yet */
|
|
err->msg_code = 0; /* may be useful as a flag for "no error" */
|
|
|
|
/* Initialize message table pointers */
|
|
err->jpeg_message_table = jpeg_std_message_table;
|
|
err->last_jpeg_message = (int) JMSG_LASTMSGCODE - 1;
|
|
|
|
err->addon_message_table = NULL;
|
|
err->first_addon_message = 0; /* for safety */
|
|
err->last_addon_message = 0;
|
|
|
|
return err;
|
|
}
|