1 /*
2 * reserved comment block
3 * DO NOT REMOVE OR ALTER!
4 */
5 /*
6 * jerror.c
7 *
8 * Copyright (C) 1991-1998, Thomas G. Lane.
9 * This file is part of the Independent JPEG Group's software.
10 * For conditions of distribution and use, see the accompanying README file.
11 *
12 * This file contains simple error-reporting and trace-message routines.
13 * These are suitable for Unix-like systems and others where writing to
14 * stderr is the right thing to do. Many applications will want to replace
15 * some or all of these routines.
16 *
17 * If you define USE_WINDOWS_MESSAGEBOX in jconfig.h or in the makefile,
18 * you get a Windows-specific hack to display error messages in a dialog box.
19 * It ain't much, but it beats dropping error messages into the bit bucket,
20 * which is what happens to output to stderr under most Windows C compilers.
21 *
22 * These routines are used by both the compression and decompression code.
23 */
24
25 /* this is not a core library module, so it doesn't define JPEG_INTERNALS */
26 #include "jinclude.h"
27 #include "jpeglib.h"
28 #include "jversion.h"
29 #include "jerror.h"
30
31 #ifdef USE_WINDOWS_MESSAGEBOX
32 #include <windows.h>
33 #endif
34
35 #ifndef EXIT_FAILURE /* define exit() codes if not provided */
36 #define EXIT_FAILURE 1
37 #endif
38
39
40 /*
41 * Create the message string table.
42 * We do this from the master message list in jerror.h by re-reading
43 * jerror.h with a suitable definition for macro JMESSAGE.
44 * The message table is made an external symbol just in case any applications
45 * want to refer to it directly.
46 */
47
48 #ifdef NEED_SHORT_EXTERNAL_NAMES
49 #define jpeg_std_message_table jMsgTable
50 #endif
51
52 #define JMESSAGE(code,string) string ,
53
54 const char * const jpeg_std_message_table[] = {
55 #include "jerror.h"
56 NULL
57 };
58
59
60 /*
61 * Error exit handler: must not return to caller.
62 *
63 * Applications may override this if they want to get control back after
64 * an error. Typically one would longjmp somewhere instead of exiting.
65 * The setjmp buffer can be made a private field within an expanded error
66 * handler object. Note that the info needed to generate an error message
67 * is stored in the error object, so you can generate the message now or
68 * later, at your convenience.
69 * You should make sure that the JPEG object is cleaned up (with jpeg_abort
70 * or jpeg_destroy) at some point.
71 */
72
73 METHODDEF(void)
error_exit(j_common_ptr cinfo)74 error_exit (j_common_ptr cinfo)
75 {
76 /* Always display the message */
77 (*cinfo->err->output_message) (cinfo);
78
79 /* Let the memory manager delete any temp files before we die */
80 jpeg_destroy(cinfo);
81
82 /*
83 * This should never happen since the Java library replaces the
84 * error_exit pointer in the error handler structs it uses.
85 *
86 * exit(EXIT_FAILURE);
87 */
88 }
89
90
91 /*
92 * Actual output of an error or trace message.
93 * Applications may override this method to send JPEG messages somewhere
94 * other than stderr.
95 *
96 * On Windows, printing to stderr is generally completely useless,
97 * so we provide optional code to produce an error-dialog popup.
98 * Most Windows applications will still prefer to override this routine,
99 * but if they don't, it'll do something at least marginally useful.
100 *
101 * NOTE: to use the library in an environment that doesn't support the
102 * C stdio library, you may have to delete the call to fprintf() entirely,
103 * not just not use this routine.
104 */
105
106 METHODDEF(void)
output_message(j_common_ptr cinfo)107 output_message (j_common_ptr cinfo)
108 {
109 char buffer[JMSG_LENGTH_MAX];
110
111 /* Create the message */
112 (*cinfo->err->format_message) (cinfo, buffer);
113
114 #ifdef USE_WINDOWS_MESSAGEBOX
115 /* Display it in a message dialog box */
116 MessageBox(GetActiveWindow(), buffer, "JPEG Library Error",
117 MB_OK | MB_ICONERROR);
118 #else
119 /* Send it to stderr, adding a newline */
120 fprintf(stderr, "%s\n", buffer);
121 #endif
122 }
123
124
125 /*
126 * Decide whether to emit a trace or warning message.
127 * msg_level is one of:
128 * -1: recoverable corrupt-data warning, may want to abort.
129 * 0: important advisory messages (always display to user).
130 * 1: first level of tracing detail.
131 * 2,3,...: successively more detailed tracing messages.
132 * An application might override this method if it wanted to abort on warnings
133 * or change the policy about which messages to display.
134 */
135
136 METHODDEF(void)
emit_message(j_common_ptr cinfo,int msg_level)137 emit_message (j_common_ptr cinfo, int msg_level)
138 {
139 struct jpeg_error_mgr * err = cinfo->err;
140
141 if (msg_level < 0) {
142 /* It's a warning message. Since corrupt files may generate many warnings,
143 * the policy implemented here is to show only the first warning,
144 * unless trace_level >= 3.
145 */
146 if (err->num_warnings == 0 || err->trace_level >= 3)
147 (*err->output_message) (cinfo);
148 /* Always count warnings in num_warnings. */
149 err->num_warnings++;
150 } else {
151 /* It's a trace message. Show it if trace_level >= msg_level. */
152 if (err->trace_level >= msg_level)
153 (*err->output_message) (cinfo);
154 }
155 }
156
157
158 /*
159 * Format a message string for the most recent JPEG error or message.
160 * The message is stored into buffer, which should be at least JMSG_LENGTH_MAX
161 * characters. Note that no '\n' character is added to the string.
162 * Few applications should need to override this method.
163 */
164
165 METHODDEF(void)
format_message(j_common_ptr cinfo,char * buffer)166 format_message (j_common_ptr cinfo, char * buffer)
167 {
168
169 /* Had to kill this function altogether
170 to avoid linking to VM when building the splash screen with static libjpeg */
171
172 #ifndef SPLASHSCREEN
173 int jio_snprintf(char *str, size_t count, const char *fmt, ...);
174 struct jpeg_error_mgr * err = cinfo->err;
175 int msg_code = err->msg_code;
176 const char * msgtext = NULL;
177 const char * msgptr;
178 char ch;
179 boolean isstring;
180
181 /* Look up message string in proper table */
182 if (msg_code > 0 && msg_code <= err->last_jpeg_message) {
183 msgtext = err->jpeg_message_table[msg_code];
184 } else if (err->addon_message_table != NULL &&
185 msg_code >= err->first_addon_message &&
186 msg_code <= err->last_addon_message) {
187 msgtext = err->addon_message_table[msg_code - err->first_addon_message];
188 }
189
190 /* Defend against bogus message number */
191 if (msgtext == NULL) {
192 err->msg_parm.i[0] = msg_code;
193 msgtext = err->jpeg_message_table[0];
194 }
195
196 /* Check for string parameter, as indicated by %s in the message text */
197 isstring = FALSE;
198 msgptr = msgtext;
199 while ((ch = *msgptr++) != '\0') {
200 if (ch == '%') {
201 if (*msgptr == 's') isstring = TRUE;
202 break;
203 }
204 }
205
206 /* Format the message into the passed buffer */
207 if (isstring)
208 /* Buffer size is JMSG_LENGTH_MAX, quietly truncate on overflow */
209 (void) jio_snprintf(buffer, JMSG_LENGTH_MAX, msgtext, err->msg_parm.s);
210 else
211 /* Buffer size is JMSG_LENGTH_MAX, quietly truncate on overflow */
212 (void) jio_snprintf(buffer, JMSG_LENGTH_MAX, msgtext,
213 err->msg_parm.i[0], err->msg_parm.i[1],
214 err->msg_parm.i[2], err->msg_parm.i[3],
215 err->msg_parm.i[4], err->msg_parm.i[5],
216 err->msg_parm.i[6], err->msg_parm.i[7]);
217 #else /* SPLASHSCREEN */
218 *buffer = '\0';
219 #endif /* SPLASHSCREEN */
220 }
221
222
223 /*
224 * Reset error state variables at start of a new image.
225 * This is called during compression startup to reset trace/error
226 * processing to default state, without losing any application-specific
227 * method pointers. An application might possibly want to override
228 * this method if it has additional error processing state.
229 */
230
231 METHODDEF(void)
reset_error_mgr(j_common_ptr cinfo)232 reset_error_mgr (j_common_ptr cinfo)
233 {
234 cinfo->err->num_warnings = 0;
235 /* trace_level is not reset since it is an application-supplied parameter */
236 cinfo->err->msg_code = 0; /* may be useful as a flag for "no error" */
237 }
238
239
240 /*
241 * Fill in the standard error-handling methods in a jpeg_error_mgr object.
242 * Typical call is:
243 * struct jpeg_compress_struct cinfo;
244 * struct jpeg_error_mgr err;
245 *
246 * cinfo.err = jpeg_std_error(&err);
247 * after which the application may override some of the methods.
248 */
249
250 GLOBAL(struct jpeg_error_mgr *)
jpeg_std_error(struct jpeg_error_mgr * err)251 jpeg_std_error (struct jpeg_error_mgr * err)
252 {
253 err->error_exit = error_exit;
254 err->emit_message = emit_message;
255 err->output_message = output_message;
256 err->format_message = format_message;
257 err->reset_error_mgr = reset_error_mgr;
258
259 err->trace_level = 0; /* default = no tracing */
260 err->num_warnings = 0; /* no warnings emitted yet */
261 err->msg_code = 0; /* may be useful as a flag for "no error" */
262
263 /* Initialize message table pointers */
264 err->jpeg_message_table = jpeg_std_message_table;
265 err->last_jpeg_message = (int) JMSG_LASTMSGCODE - 1;
266
267 err->addon_message_table = NULL;
268 err->first_addon_message = 0; /* for safety */
269 err->last_addon_message = 0;
270
271 return err;
272 }
273