구차니의 잡동사니 모음

Usage...
Xming [:<display-number>] [option]
-a #                   mouse acceleration (pixels)
-ac                    disable access control restrictions
-audit int             set audit trail level
-auth file             select authorization file
-br                    create root window with black background
+bs                    enable any backing store support
-bs                    disable any backing store support
-c                     turns off key-click
c #                    key-click volume (0-100)
-cc int                default color visual class
-co file               color database file
-core                  generate core dump on fatal error
-dpi int               screen resolution in dots per inch
-deferglyphs [none|all|16] defer loading of [no|all|16-bit] glyphs
-f #                   bell base (0-100)
-fc string             cursor font
-fn string             default font name
-fp string             default font path
-help                  prints message with these options
-I                     ignore all remaining arguments
-logo                  enable logo in screen saver
nologo                 disable logo in screen saver
-nolisten string       don't listen on protocol
-noreset               don't reset after last client exists
-reset                 reset after last client exists
-p #                   screen-saver pattern duration (minutes)
-pn                    accept failure to listen on all ports
-nopn                  reject failure to listen on all ports
-r                     turns off auto-repeat
r                      turns on auto-repeat
-render [default|mono|gray|color] set render color alloc policy
-s #                   screen-saver timeout (minutes)
-sp file               security policy file
-su                    disable any save under support
-t #                   mouse threshold (pixels)
-terminate             terminate at server reset
-to #                  connection time out
-tst                   disable testing extensions
ttyxx                  server started from init on /dev/ttyxx
v                      video blanking for screen-saver
-v                     screen-saver without video blanking
-wm                    WhenMapped default backing-store
-wr                    create root window with white background
-x string              loads named extension at init time
-maxbigreqsize         set maximal bigrequest size
+extension name        Enable extension
-extension name        Disable extension
-query host-name       contact named host for XDMCP
-broadcast             broadcast for XDMCP
-indirect host-name    contact named host for indirect XDMCP
-port port-num         UDP port number to send messages to
-from local-address    specify the local address to connect from
-once                  Terminate server after one session
-class display-class   specify display class to send in manage
-cookie xdm-auth-bits  specify the magic cookie for XDMCP
-displayID display-id  manufacturer display ID for request
-kb                    disable the X Keyboard Extension
+kb                    enable the X Keyboard Extension
[+-]accessx [ timeout [ timeout_mask [ feedback [ options_mask] ] ] ]
                       enable/disable accessx key sequences
-ardelay               set XKB autorepeat delay
-arinterval            set XKB autorepeat interval

-clipboard
    Enables the integration between the Xming clipboard and
    Windows clipboard.
-clipupdates num_boxes
    Use a clipping region to constrain shadow update blits to
    the updated region when num_boxes, or more, are in the
    updated region.  Diminished effect on current Windows
    versions because they already group GDI operations together
    in a batch, which has a similar effect.
-depth bits_per_pixel
    Specify an optional bitdepth to use in fullscreen mode
    with a DirectDraw engine.
-emulate3buttons [timeout]
    Emulate a 3 button mouse with an optional timeout in
    milliseconds.  The default timeout is 50 milliseconds.
-engine engine_type_id
    Override the server's automatically selected engine type:
        1 - Shadow GDI
        2 - Shadow DirectDraw
        4 - Shadow DirectDraw4 Non-Locking
    Do not use this parameter unless instructed to do so.
-fullscreen
    Run the server in fullscreen mode with -depth and -refresh
    set as required.
-ignoreinput
    Ignore keyboard and mouse input.  This is usually only used for
    testing and debugging purposes.
-internalwm
    EXPERIMENTAL: Run the internal window manager.
-[no]keyhook
    Grab special windows key combinations like Alt-Tab or the Menu
    key.  These keys are discarded by default.
-lesspointer
    Hide the windows mouse pointer when it is over an inactive
    Xming window.  This prevents ghost cursors appearing where
    the Windows cursor is drawn over the X cursor.
-logfile filename
    Write logmessages to <filename> instead of Xming.n.log,
    where n is the display-number of the X Server.
-logverbose verbosity
    Set the verbosity of logmessages. [NOTE: Only a few messages
    respect the settings, so not much use yet]
        0 - only print fatal error.
        1 - print additional configuration information.
        2 - print additional runtime information [default].
        3 - print debugging and tracing information.
-[no]multimonitors (or -[no]multiplemonitors)
    Use the entire virtual screen if multiple monitors are
    present.
-multiwindow
    Run the server in multiwindow mode.  Not to be used
    together with -rootless or -fullscreen.
-mwextwm
    EXPERIMENTAL: Run the server in multiwindow external
    window manager mode. Use with xwinwm.
-nodecoration
    Do not draw a window border, title bar, etc.  Windowed
    mode only i.e. ignored when -fullscreen specified.
-noicons
    Disable the conversion of X icons in multiwindow mode.
    Use to prevent an infrequent crash in miGetImage().
    This is a work-around that most people won't need.
-nounicodeclipboard
    Disable Unicode in the clipboard.
-refresh rate_in_Hz
    Specify an optional refresh rate to use in fullscreen mode
    with a DirectDraw engine.
-rootless
    Use a transparent root window with an external window
    manager (such as openbox).  Not to be used with
    -multiwindow or with -fullscreen.
-screen scr_num [width height [x y] | [[WxH[+X+Y]][@m]] ]
    Enable screen scr_num and optionally specify a width and
    height and initial position for that screen. Additionally
    a monitor number can be specified to start the server on,
    at which point, all coordinates become relative to that
    monitor. Examples:
    -screen 0 800x600+100+100@2 ;2nd monitor offset 100,100 size 800x600
    -screen 0 1024x768@3        ;3rd monitor size 1024x768
    -screen 0 @1 ;on 1st monitor using its full resolution (the default)
-scrollbars
    In windowed mode, allow screens bigger than the Windows desktop.
    Moreover, if the window has decorations, one can now resize
    it.  Do not use in conjunction with -multiwindow or with -rootless.
-silent-dup-error
    If another instance of Xming is found running, exit silently
    and don't display the error message.
-swcursor
    Disable the usage of the windows cursor and use the X11 software
    cursor instead.
-[no]trayicon
    Do not create a tray icon.  Default is to create one
    icon per screen.  You can globally disable tray icons with
    -notrayicon, then enable it for specific screens with
    -trayicon for those screens.
-[no]unixkill
    Ctrl-Alt-Backspace exits the X Server. The Ctrl-Alt-Backspace
    key combo is disabled by default.
-version
    Write version and help text to the console (unless built
    console-less) and to the log file.
-[no]winkill
    Alt-F4 exits the X Server.  The Alt-F4 key combo is enabled
    by default.
-xkblayout XKBLayout
    Set the layout to use for XKB.  This defaults to a layout
    matching your current layout from windows or us (i.e. USA)
    if no matching layout was found.
    For example: -xkblayout de
-xkbmodel XKBModel
    Set the model to use for XKB.  This defaults to pc105.
-xkboptions XKBOptions
    Set the options to use for XKB.  This defaults to not set.
-xkbrules XKBRules
    Set the rules to use for XKB.  This defaults to xorg.
-xkbvariant XKBVariant
    Set the variant to use for XKB.  This defaults to not set.
    For example: -xkbvariant nodeadkeys

unsigned int scale_num, scale_denom
    Scale the image by the fraction scale_num/scale_denom.  Default is
    1/1, or no scaling.  Currently, the only supported scaling ratios
    are 1/1, 1/2, 1/4, and 1/8.  (The library design allows for arbitrary
    scaling ratios but this is not likely to be implemented any time soon.)
    Smaller scaling ratios permit significantly faster decoding since
    fewer pixels need be processed and a simpler IDCT method can be used.   

6. while (scan lines remain to be read)
    jpeg_read_scanlines(...);

Now you can read the decompressed image data by calling jpeg_read_scanlines()
one or more times.  At each call, you pass in the maximum number of scanlines
to be read (ie, the height of your working buffer); jpeg_read_scanlines()
will return up to that many lines.  The return value is the number of lines
actually read.  The format of the returned data is discussed under "Data
formats", above.  Don't forget that grayscale and color JPEGs will return
different data formats!

Image data is returned in top-to-bottom scanline order.  If you must write
out the image in bottom-to-top order, you can use the JPEG library's virtual
array mechanism to invert the data efficiently.  Examples of this can be
found in the sample application djpeg.

The library maintains a count of the number of scanlines returned so far
in the output_scanline field of the JPEG object.  Usually you can just use
this variable as the loop counter, so that the loop test looks like
"while (cinfo.output_scanline < cinfo.output_height)".  (Note that the test
should NOT be against image_height, unless you never use scaling.  The
image_height field is the height of the original unscaled image.)
The return value always equals the change in the value of output_scanline.

If you don't use a suspending data source, it is safe to assume that
jpeg_read_scanlines() reads at least one scanline per call, until the
bottom of the image has been reached.

If you use a buffer larger than one scanline, it is NOT safe to assume that
jpeg_read_scanlines() fills it.  (The current implementation returns only a
few scanlines per call, no matter how large a buffer you pass.)  So you must
always provide a loop that calls jpeg_read_scanlines() repeatedly until the
whole image has been read.

Data formats
------------

Before diving into procedural details, it is helpful to understand the
image data format that the JPEG library expects or returns.

The standard input image format is a rectangular array of pixels, with each
pixel having the same number of "component" or "sample" values (color
channels).  You must specify how many components there are and the colorspace
interpretation of the components.  Most applications will use RGB data
(three components per pixel) or grayscale data (one component per pixel).
PLEASE NOTE THAT RGB DATA IS THREE SAMPLES PER PIXEL, GRAYSCALE ONLY ONE.
A remarkable number of people manage to miss this, only to find that their
programs don't work with grayscale JPEG files.

There is no provision for colormapped input.  JPEG files are always full-color
or full grayscale (or sometimes another colorspace such as CMYK).  You can
feed in a colormapped image by expanding it to full-color format.  However
JPEG often doesn't work very well with source data that has been colormapped,
because of dithering noise.  This is discussed in more detail in the JPEG FAQ
and the other references mentioned in the README file.

Pixels are stored by scanlines, with each scanline running from left to
right.  The component values for each pixel are adjacent in the row; for
example, R,G,B,R,G,B,R,G,B,... for 24-bit RGB color.  Each scanline is an
array of data type JSAMPLE --- which is typically "unsigned char", unless
you've changed jmorecfg.h.  (You can also change the RGB pixel layout, say
to B,G,R order, by modifying jmorecfg.h.  But see the restrictions listed in
that file before doing so.)

struct jpeg_decompress_struct {
  jpeg_common_fields;        /* Fields shared with jpeg_compress_struct */

  /* Source of compressed data */
  struct jpeg_source_mgr * src;

  /* Basic description of image --- filled in by jpeg_read_header(). */
  /* Application may inspect these values to decide how to process image. */

  JDIMENSION image_width;    /* nominal image width (from SOF marker) */
  JDIMENSION image_height;    /* nominal image height */
  int num_components;        /* # of color components in JPEG image */
  J_COLOR_SPACE jpeg_color_space; /* colorspace of JPEG image */


/* image_width는 폭 image_height는 높이 그리고 num_components는 몇개의 색상이 있는지를 알려준다.
 * jpeg는 각 element당 8bit씩을 사용하고, RGB는 각 8bit * 3 = 24bits
 * Grayscale은 8bit * 1(단일색상) = 8bits 이런식으로 color depth를 계산하면 된다.
*/

  /* Decompression processing parameters --- these fields must be set before
   * calling jpeg_start_decompress().  Note that jpeg_read_header() initializes
   * them to default values.
   */

  J_COLOR_SPACE out_color_space; /* colorspace for output */
 /* 윈도우에서 색대표라고 나오는 것이다. 출력시의 색상계를 의미함 */
  unsigned int scale_num, scale_denom; /* fraction by which to scale image */

  double output_gamma;        /* image gamma wanted in output */

  boolean buffered_image;    /* TRUE=multiple output passes */
  boolean raw_data_out;        /* TRUE=downsampled data wanted */

  J_DCT_METHOD dct_method;    /* IDCT algorithm selector */
  boolean do_fancy_upsampling;    /* TRUE=apply fancy upsampling */
  boolean do_block_smoothing;    /* TRUE=apply interblock smoothing */

  boolean quantize_colors;    /* TRUE=colormapped output wanted */
  /* the following are ignored if not quantize_colors: */
  J_DITHER_MODE dither_mode;    /* type of color dithering to use */
  boolean two_pass_quantize;    /* TRUE=use two-pass color quantization */
  int desired_number_of_colors;    /* max # colors to use in created colormap */
  /* these are significant only in buffered-image mode: */
  boolean enable_1pass_quant;    /* enable future use of 1-pass quantizer */
  boolean enable_external_quant;/* enable future use of external colormap */
  boolean enable_2pass_quant;    /* enable future use of 2-pass quantizer */

  /* Description of actual output image that will be returned to application.
   * These fields are computed by jpeg_start_decompress().
   * You can also use jpeg_calc_output_dimensions() to determine these values
   * in advance of calling jpeg_start_decompress().
   */

  JDIMENSION output_width;    /* scaled image width */
  JDIMENSION output_height;    /* scaled image height */
  int out_color_components;    /* # of color components in out_color_space */
  int output_components;    /* # of color components returned */
  /* output_components is 1 (a colormap index) when quantizing colors;
   * otherwise it equals out_color_components.
   */
  int rec_outbuf_height;    /* min recommended height of scanline buffer */
  /* If the buffer passed to jpeg_read_scanlines() is less than this many rows
   * high, space and time will be wasted due to unnecessary data copying.
   * Usually rec_outbuf_height will be 1 or 2, at most 4.
   */

  /* When quantizing colors, the output colormap is described by these fields.
   * The application can supply a colormap by setting colormap non-NULL before
   * calling jpeg_start_decompress; otherwise a colormap is created during
   * jpeg_start_decompress or jpeg_start_output.
   * The map has out_color_components rows and actual_number_of_colors columns.
   */
  int actual_number_of_colors;    /* number of entries in use */
  JSAMPARRAY colormap;        /* The color map as a 2-D pixel array */

  /* State variables: these variables indicate the progress of decompression.
   * The application may examine these but must not modify them.
   */

  /* Row index of next scanline to be read from jpeg_read_scanlines().
   * Application may use this to control its processing loop, e.g.,
   * "while (output_scanline < output_height)".
   */
  JDIMENSION output_scanline;    /* 0 .. output_height-1  */

  /* Current input scan number and number of iMCU rows completed in scan.
   * These indicate the progress of the decompressor input side.
   */
  int input_scan_number;    /* Number of SOS markers seen so far */
  JDIMENSION input_iMCU_row;    /* Number of iMCU rows completed */

  /* The "output scan number" is the notional scan being displayed by the
   * output side.  The decompressor will not allow output scan/row number
   * to get ahead of input scan/row, but it can fall arbitrarily far behind.
   */
  int output_scan_number;    /* Nominal scan number being displayed */
  JDIMENSION output_iMCU_row;    /* Number of iMCU rows read */

  /* Current progression status.  coef_bits[c][i] indicates the precision
   * with which component c's DCT coefficient i (in zigzag order) is known.
   * It is -1 when no data has yet been received, otherwise it is the point
   * transform (shift) value for the most recent scan of the coefficient
   * (thus, 0 at completion of the progression).
   * This pointer is NULL when reading a non-progressive file.
   */
  int (*coef_bits)[DCTSIZE2];    /* -1 or current Al value for each coef */

  /* Internal JPEG parameters --- the application usually need not look at
   * these fields.  Note that the decompressor output side may not use
   * any parameters that can change between scans.
   */

  /* Quantization and Huffman tables are carried forward across input
   * datastreams when processing abbreviated JPEG datastreams.
   */

  JQUANT_TBL * quant_tbl_ptrs[NUM_QUANT_TBLS];
  /* ptrs to coefficient quantization tables, or NULL if not defined */

  JHUFF_TBL * dc_huff_tbl_ptrs[NUM_HUFF_TBLS];
  JHUFF_TBL * ac_huff_tbl_ptrs[NUM_HUFF_TBLS];
  /* ptrs to Huffman coding tables, or NULL if not defined */

  /* These parameters are never carried across datastreams, since they
   * are given in SOF/SOS markers or defined to be reset by SOI.
   */

  int data_precision;        /* bits of precision in image data */

  jpeg_component_info * comp_info;
  /* comp_info[i] describes component that appears i'th in SOF */

  boolean progressive_mode;    /* TRUE if SOFn specifies progressive mode */
  boolean arith_code;        /* TRUE=arithmetic coding, FALSE=Huffman */

  UINT8 arith_dc_L[NUM_ARITH_TBLS]; /* L values for DC arith-coding tables */
  UINT8 arith_dc_U[NUM_ARITH_TBLS]; /* U values for DC arith-coding tables */
  UINT8 arith_ac_K[NUM_ARITH_TBLS]; /* Kx values for AC arith-coding tables */

  unsigned int restart_interval; /* MCUs per restart interval, or 0 for no restart */

  /* These fields record data obtained from optional markers recognized by
   * the JPEG library.
   */
  boolean saw_JFIF_marker;    /* TRUE iff a JFIF APP0 marker was found */
  /* Data copied from JFIF marker; only valid if saw_JFIF_marker is TRUE: */
  UINT8 JFIF_major_version;    /* JFIF version number */
  UINT8 JFIF_minor_version;
  UINT8 density_unit;        /* JFIF code for pixel size units */
  UINT16 X_density;        /* Horizontal pixel density */
  UINT16 Y_density;        /* Vertical pixel density */
  boolean saw_Adobe_marker;    /* TRUE iff an Adobe APP14 marker was found */
  UINT8 Adobe_transform;    /* Color transform code from Adobe marker */
 /* X_density, Y_density는 DPI 단위의 수평,수직 해상도를 나타낸다. */

  boolean CCIR601_sampling;    /* TRUE=first samples are cosited */

  /* Aside from the specific data retained from APPn markers known to the
   * library, the uninterpreted contents of any or all APPn and COM markers
   * can be saved in a list for examination by the application.
   */
  jpeg_saved_marker_ptr marker_list; /* Head of list of saved markers */

  /* Remaining fields are known throughout decompressor, but generally
   * should not be touched by a surrounding application.
   */

  /*
   * These fields are computed during decompression startup
   */
  int max_h_samp_factor;    /* largest h_samp_factor */
  int max_v_samp_factor;    /* largest v_samp_factor */

  int min_DCT_scaled_size;    /* smallest DCT_scaled_size of any component */

  JDIMENSION total_iMCU_rows;    /* # of iMCU rows in image */
  /* The coefficient controller's input and output progress is measured in
   * units of "iMCU" (interleaved MCU) rows.  These are the same as MCU rows
   * in fully interleaved JPEG scans, but are used whether the scan is
   * interleaved or not.  We define an iMCU row as v_samp_factor DCT block
   * rows of each component.  Therefore, the IDCT output contains
   * v_samp_factor*DCT_scaled_size sample rows of a component per iMCU row.
   */

  JSAMPLE * sample_range_limit; /* table for fast range-limiting */

  /*
   * These fields are valid during any one scan.
   * They describe the components and MCUs actually appearing in the scan.
   * Note that the decompressor output side must not use these fields.
   */
  int comps_in_scan;        /* # of JPEG components in this scan */
  jpeg_component_info * cur_comp_info[MAX_COMPS_IN_SCAN];
  /* *cur_comp_info[i] describes component that appears i'th in SOS */

  JDIMENSION MCUs_per_row;    /* # of MCUs across the image */
  JDIMENSION MCU_rows_in_scan;    /* # of MCU rows in the image */

  int blocks_in_MCU;        /* # of DCT blocks per MCU */
  int MCU_membership[D_MAX_BLOCKS_IN_MCU];
  /* MCU_membership[i] is index in cur_comp_info of component owning */
  /* i'th block in an MCU */

  int Ss, Se, Ah, Al;        /* progressive JPEG parameters for scan */

  /* This field is shared between entropy decoder and marker parser.
   * It is either zero or the code of a JPEG marker that has been
   * read from the data source, but has not yet been processed.
   */
  int unread_marker;

  /*
   * Links to decompression subobjects (methods, private variables of modules)
   */
  struct jpeg_decomp_master * master;
  struct jpeg_d_main_controller * main;
  struct jpeg_d_coef_controller * coef;
  struct jpeg_d_post_controller * post;
  struct jpeg_input_controller * inputctl;
  struct jpeg_marker_reader * marker;
  struct jpeg_entropy_decoder * entropy;
  struct jpeg_inverse_dct * idct;
  struct jpeg_upsampler * upsample;
  struct jpeg_color_deconverter * cconvert;
  struct jpeg_color_quantizer * cquantize;
};