home *** CD-ROM | disk | FTP | other *** search
/ Windows Graphics Programming / Feng_Yuan_Win32_GDI_DirectX.iso / Samples / include / jlib / jerror.cpp < prev    next >
C/C++ Source or Header  |  2000-05-16  |  9KB  |  326 lines
  1. //-------------------------------------------------------------------------//
  2. //          Windows Graphics Programming: Win32 GDI and DirectDraw         //
  3. //                        ISBN  0-13-086985-6                              //
  4. //                                                                         //
  5. //  Modified by: Yuan, Feng                             www.fengyuan.com   //
  6. //  Changes    : C++, exception, in-memory source, BGR byte order          //
  7. //  Version    : 1.00.000, May 31, 2000                                    //
  8. //-------------------------------------------------------------------------//
  9.  
  10. /*
  11.  * jerror.c
  12.  *
  13.  * Copyright (C) 1991-1998, Thomas G. Lane.
  14.  * This file is part of the Independent JPEG Group's software.
  15.  * For conditions of distribution and use, see the accompanying README file.
  16.  *
  17.  * This file contains simple error-reporting and trace-message routines.
  18.  * These are suitable for Unix-like systems and others where writing to
  19.  * stderr is the right thing to do.  Many applications will want to replace
  20.  * some or all of these routines.
  21.  *
  22.  * If you define USE_WINDOWS_MESSAGEBOX in jconfig.h or in the makefile,
  23.  * you get a Windows-specific hack to display error messages in a dialog box.
  24.  * It ain't much, but it beats dropping error messages into the bit bucket,
  25.  * which is what happens to output to stderr under most Windows C compilers.
  26.  *
  27.  * These routines are used by both the compression and decompression code.
  28.  */
  29.  
  30. /* this is not a core library module, so it doesn't define JPEG_INTERNALS */
  31. #include "jinclude.h"
  32. #include "jpeglib.h"
  33. #include "jversion.h"
  34. #include "jerror.h"
  35.  
  36. #ifdef USE_WINDOWS_MESSAGEBOX
  37. #include <windows.h>
  38. #endif
  39.  
  40. #ifndef EXIT_FAILURE        /* define exit() codes if not provided */
  41. #define EXIT_FAILURE  1
  42. #endif
  43.  
  44.  
  45. /*
  46.  * Create the message string table.
  47.  * We do this from the master message list in jerror.h by re-reading
  48.  * jerror.h with a suitable definition for macro JMESSAGE.
  49.  * The message table is made an external symbol just in case any applications
  50.  * want to refer to it directly.
  51.  */
  52.  
  53. #ifdef NEED_SHORT_EXTERNAL_NAMES
  54. #define jpeg_std_message_table    jMsgTable
  55. #endif
  56.  
  57. #define JMESSAGE(code,string)    string ,
  58.  
  59. const char * const jpeg_std_message_table[] = {
  60. #include "jerror.h"
  61.   NULL
  62. };
  63.  
  64.  
  65. /*
  66.  * Error exit handler: must not return to caller.
  67.  *
  68.  * Applications may override this if they want to get control back after
  69.  * an error.  Typically one would longjmp somewhere instead of exiting.
  70.  * The setjmp buffer can be made a private field within an expanded error
  71.  * handler object.  Note that the info needed to generate an error message
  72.  * is stored in the error object, so you can generate the message now or
  73.  * later, at your convenience.
  74.  * You should make sure that the JPEG object is cleaned up (with jpeg_abort
  75.  * or jpeg_destroy) at some point.
  76.  */
  77.  
  78. jpeg_error_mgr::~jpeg_error_mgr()
  79. {
  80. }
  81.  
  82. void jpeg_error_mgr::error_exit(j_common_ptr cinfo)
  83. {
  84.     /* Always display the message */
  85.     output_message();
  86.  
  87.     /* Let the memory manager delete any temp files before we die */
  88.     // cinfo->jpeg_destroy();
  89.  
  90.     throw msg_code; // C++ exception
  91. }
  92.  
  93.  
  94. /*
  95.  * Actual output of an error or trace message.
  96.  * Applications may override this method to send JPEG messages somewhere
  97.  * other than stderr.
  98.  *
  99.  * On Windows, printing to stderr is generally completely useless,
  100.  * so we provide optional code to produce an error-dialog popup.
  101.  * Most Windows applications will still prefer to override this routine,
  102.  * but if they don't, it'll do something at least marginally useful.
  103.  *
  104.  * NOTE: to use the library in an environment that doesn't support the
  105.  * C stdio library, you may have to delete the call to fprintf() entirely,
  106.  * not just not use this routine.
  107.  */
  108.  
  109. void jpeg_error_mgr::output_message(void)
  110. {
  111.     char buffer[JMSG_LENGTH_MAX];
  112.  
  113.     // Create the message
  114.     format_message(buffer);
  115.  
  116. #ifdef USE_WINDOWS_MESSAGEBOX
  117.     // Display it in a message dialog box
  118.     MessageBox(GetActiveWindow(), buffer, "JPEG Library Error", MB_OK | MB_ICONERROR);
  119. #else
  120.     /* Send it to stderr, adding a newline */
  121.     fprintf(stderr, "%s\n", buffer);
  122. #endif
  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. void jpeg_error_mgr::emit_message(int msg_level)
  137. {
  138.     if (msg_level < 0) 
  139.     {
  140.         /* It's a warning message.  Since corrupt files may generate many warnings,
  141.         * the policy implemented here is to show only the first warning,
  142.         * unless trace_level >= 3.
  143.         */
  144.         if (num_warnings == 0 || trace_level >= 3)
  145.             output_message();
  146.         /* Always count warnings in num_warnings. */
  147.         num_warnings++;
  148.     } 
  149.     else 
  150.     {
  151.         /* It's a trace message.  Show it if trace_level >= msg_level. */
  152.         if (trace_level >= msg_level)
  153.             output_message();
  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. void jpeg_error_mgr::format_message (char * buffer)
  166. {
  167.     const char * msgtext = NULL;
  168.     const char * msgptr;
  169.     char ch;
  170.     boolean isstring;
  171.  
  172.     /* Look up message string in proper table */
  173.     if (msg_code > 0 && msg_code <= last_jpeg_message) {
  174.         msgtext = jpeg_message_table[msg_code];
  175.     } 
  176.     else if (addon_message_table != NULL &&
  177.          msg_code >= first_addon_message &&
  178.          msg_code <= last_addon_message) 
  179.     {
  180.         msgtext = addon_message_table[msg_code - first_addon_message];
  181.     }
  182.  
  183.     /* Defend against bogus message number */
  184.     if (msgtext == NULL) 
  185.     {
  186.         msg_parm.i[0] = msg_code;
  187.         msgtext = jpeg_message_table[0];
  188.     }
  189.  
  190.     /* Check for string parameter, as indicated by %s in the message text */
  191.     isstring = FALSE;
  192.     msgptr = msgtext;
  193.     while ((ch = *msgptr++) != '\0') 
  194.     {
  195.         if (ch == '%') 
  196.         {
  197.             if (*msgptr == 's') isstring = TRUE;
  198.             break;
  199.         }
  200.     }
  201.  
  202.     /* Format the message into the passed buffer */
  203.     if (isstring)
  204.         sprintf(buffer, msgtext, msg_parm.s);
  205.     else
  206.         sprintf(buffer, msgtext,
  207.             msg_parm.i[0], msg_parm.i[1],
  208.             msg_parm.i[2], msg_parm.i[3],
  209.             msg_parm.i[4], msg_parm.i[5],
  210.             msg_parm.i[6], msg_parm.i[7]);
  211. }
  212.  
  213.  
  214. /*
  215.  * Reset error state variables at start of a new image.
  216.  * This is called during compression startup to reset trace/error
  217.  * processing to default state, without losing any application-specific
  218.  * method pointers.  An application might possibly want to override
  219.  * this method if it has additional error processing state.
  220.  */
  221.  
  222. void jpeg_error_mgr::reset_error_mgr(void)
  223. {
  224.     num_warnings = 0;
  225.                     /* trace_level is not reset since it is an application-supplied parameter */
  226.     msg_code = 0;    /* may be useful as a flag for "no error" */
  227. }
  228.  
  229.  
  230. /*
  231.  * Fill in the standard error-handling methods in a jpeg_error_mgr object.
  232.  * Typical call is:
  233.  *    struct jpeg_compress_struct cinfo;
  234.  *    struct jpeg_error_mgr err;
  235.  *
  236.  *    cinfo.err = jpeg_std_error(&err);
  237.  * after which the application may override some of the methods.
  238.  */
  239.  
  240. // constructor
  241. jpeg_error_mgr::jpeg_error_mgr(void)
  242. {
  243.     trace_level  = 0;    /* default = no tracing */
  244.     num_warnings = 0;    /* no warnings emitted yet */
  245.     msg_code     = 0;    /* may be useful as a flag for "no error" */
  246.  
  247.     /* Initialize message table pointers */
  248.     jpeg_message_table = jpeg_std_message_table;
  249.     last_jpeg_message = (int) JMSG_LASTMSGCODE - 1;
  250.  
  251.     addon_message_table = NULL;
  252.     first_addon_message = 0;    /* for safety */
  253.     last_addon_message = 0;
  254. }
  255.  
  256. void jpeg_common_struct::ERREXIT(int code)
  257. {
  258.     err->msg_code = code;
  259.     err->error_exit(this);
  260. }
  261.  
  262. void jpeg_common_struct::ERREXIT1(int code, int p1)
  263. {
  264.     err->msg_code      = code;
  265.     err->msg_parm.i[0] = p1;
  266.     err->error_exit(this);
  267. }
  268.  
  269. void jpeg_common_struct::ERREXIT2(int code, int p1, int p2)
  270. {
  271.     err->msg_code      = code;
  272.     err->msg_parm.i[0] = p1;
  273.     err->msg_parm.i[1] = p2;
  274.     err->error_exit(this);
  275. }
  276.  
  277. void jpeg_common_struct::ERREXIT3(int code, int p1, int p2, int p3)
  278. {
  279.     err->msg_code      = code;
  280.     err->msg_parm.i[0] = p1;
  281.     err->msg_parm.i[1] = p2;
  282.     err->msg_parm.i[2] = p3;
  283.     err->error_exit(this);
  284. }
  285.  
  286. void jpeg_common_struct::ERREXIT4(int code, int p1, int p2, int p3, int p4)
  287. {
  288.     err->msg_code      = code;
  289.     err->msg_parm.i[0] = p1;
  290.     err->msg_parm.i[1] = p2;
  291.     err->msg_parm.i[2] = p3;
  292.     err->msg_parm.i[3] = p4;
  293.     err->error_exit(this);
  294. }
  295.  
  296. void jpeg_common_struct::ERREXITS(int code, const char * msg)
  297. {
  298.     err->msg_code = code;
  299.     strncpy(err->msg_parm.s, msg, JMSG_STR_PARM_MAX);
  300.     err->error_exit(this);
  301. }
  302.  
  303. void jpeg_common_struct::WARNMS(int code)
  304. {
  305.     err->msg_code = code;
  306.     
  307.     err->emit_message(-1);
  308. }
  309.  
  310. void jpeg_common_struct::WARNMS1(int code, int p1)
  311. {
  312.     err->msg_code      = code;
  313.     err->msg_parm.i[0] = p1;
  314.     
  315.     err->emit_message(-1);
  316. }
  317.  
  318. void jpeg_common_struct::WARNMS2(int code, int p1, int p2)
  319. {
  320.     err->msg_code      = code;
  321.     err->msg_parm.i[0] = p1;
  322.     err->msg_parm.i[1] = p2;
  323.     
  324.     err->emit_message(-1);
  325. }
  326.