home *** CD-ROM | disk | FTP | other *** search
/ Delphi 5 for Professionals / DELPHI5.iso / Info / Extras / Jpeg / jpeg.pas < prev    next >
Encoding:
Pascal/Delphi Source File  |  1999-08-11  |  53.6 KB  |  1,579 lines
  1.  
  2. {*******************************************************}
  3. {                                                       }
  4. {       Borland Delphi Runtime Library                  }
  5. {       JPEG Image Compression/Decompression Unit       }
  6. {                                                       }
  7. {       Copyright (c) 1997,99 Inprise Corporation       }
  8. {                                                       }
  9. {*******************************************************}
  10. {$HPPEMIT '#pragma link "jpeg.obj"'}
  11.  
  12. unit jpeg;
  13.  
  14. interface
  15.  
  16. uses Windows, SysUtils, Classes, Graphics;
  17.  
  18. type
  19.   TJPEGData = class(TSharedImage)
  20.   private
  21.     FData: TCustomMemoryStream;
  22.     FHeight: Integer;
  23.     FWidth: Integer;
  24.     FGrayscale: Boolean;
  25.   protected
  26.     procedure FreeHandle; override;
  27.   public
  28.     destructor Destroy; override;
  29.   end;
  30.  
  31.   TJPEGQualityRange = 1..100;   // 100 = best quality, 25 = pretty awful
  32.   TJPEGPerformance = (jpBestQuality, jpBestSpeed);
  33.   TJPEGScale = (jsFullSize, jsHalf, jsQuarter, jsEighth);
  34.   TJPEGPixelFormat = (jf24Bit, jf8Bit);
  35.  
  36.   TJPEGImage = class(TGraphic)
  37.   private
  38.     FImage: TJPEGData;
  39.     FBitmap: TBitmap;
  40.     FScaledWidth: Integer;
  41.     FScaledHeight: Integer;
  42.     FTempPal: HPalette;
  43.     FSmoothing: Boolean;
  44.     FGrayScale: Boolean;
  45.     FPixelFormat: TJPEGPixelFormat;
  46.     FQuality: TJPEGQualityRange;
  47.     FProgressiveDisplay: Boolean;
  48.     FProgressiveEncoding: Boolean;
  49.     FPerformance: TJPEGPerformance;
  50.     FScale: TJPEGScale;
  51.     FNeedRecalc: Boolean;
  52.     procedure CalcOutputDimensions;
  53.     function GetBitmap: TBitmap;
  54.     function GetGrayscale: Boolean;
  55.     procedure SetGrayscale(Value: Boolean);
  56.     procedure SetPerformance(Value: TJPEGPerformance);
  57.     procedure SetPixelFormat(Value: TJPEGPixelFormat);
  58.     procedure SetScale(Value: TJPEGScale);
  59.     procedure SetSmoothing(Value: Boolean);
  60.   protected
  61.     procedure AssignTo(Dest: TPersistent); override;
  62.     procedure Changed(Sender: TObject); override;
  63.     procedure Draw(ACanvas: TCanvas; const Rect: TRect); override;
  64.     function Equals(Graphic: TGraphic): Boolean; override;
  65.     procedure FreeBitmap;
  66.     function GetEmpty: Boolean; override;
  67.     function GetHeight: Integer; override;
  68.     function GetPalette: HPALETTE; override;
  69.     function GetWidth: Integer; override;
  70.     procedure NewBitmap;
  71.     procedure NewImage;
  72.     procedure ReadData(Stream: TStream); override;
  73.     procedure ReadStream(Size: Longint; Stream: TStream);
  74.     procedure SetHeight(Value: Integer); override;
  75.     procedure SetPalette(Value: HPalette); override;
  76.     procedure SetWidth(Value: Integer); override;
  77.     procedure WriteData(Stream: TStream); override;
  78.     property Bitmap: TBitmap read GetBitmap;  // volatile
  79.   public
  80.     constructor Create; override;
  81.     destructor Destroy; override;
  82.     procedure Compress;
  83.     procedure DIBNeeded;
  84.     procedure JPEGNeeded;
  85.     procedure Assign(Source: TPersistent); override;
  86.     procedure LoadFromStream(Stream: TStream); override;
  87.     procedure SaveToStream(Stream: TStream); override;
  88.     procedure LoadFromClipboardFormat(AFormat: Word; AData: THandle;
  89.       APalette: HPALETTE); override;
  90.     procedure SaveToClipboardFormat(var AFormat: Word; var AData: THandle;
  91.       var APalette: HPALETTE); override;
  92.  
  93.     // Options affecting / reflecting compression and decompression behavior
  94.     property Grayscale: Boolean read GetGrayscale write SetGrayscale;
  95.     property ProgressiveEncoding: Boolean read FProgressiveEncoding write FProgressiveEncoding;
  96.  
  97.     // Compression options
  98.     property CompressionQuality: TJPEGQualityRange read FQuality write FQuality;
  99.  
  100.     // Decompression options
  101.     property PixelFormat: TJPEGPixelFormat read FPixelFormat write SetPixelFormat;
  102.     property ProgressiveDisplay: Boolean read FProgressiveDisplay write FProgressiveDisplay;
  103.     property Performance: TJPEGPerformance read FPerformance write SetPerformance;
  104.     property Scale: TJPEGScale read FScale write SetScale;
  105.     property Smoothing: Boolean read FSmoothing write SetSmoothing;
  106.   end;
  107.  
  108.   TJPEGDefaults = record
  109.     CompressionQuality: TJPEGQualityRange;
  110.     Grayscale: Boolean;
  111.     Performance: TJPEGPerformance;
  112.     PixelFormat: TJPEGPixelFormat;
  113.     ProgressiveDisplay: Boolean;
  114.     ProgressiveEncoding: Boolean;
  115.     Scale: TJPEGScale;
  116.     Smoothing: Boolean;
  117.   end;
  118.  
  119. var   // Default settings for all new TJPEGImage instances
  120.   JPEGDefaults: TJPEGDefaults = (
  121.     CompressionQuality: 90;
  122.     Grayscale: False;
  123.     Performance: jpBestQuality;
  124.     PixelFormat: jf24Bit;         // initialized to match video mode
  125.     ProgressiveDisplay: False;
  126.     ProgressiveEncoding: False;
  127.     Scale: jsFullSize;
  128.     Smoothing: True;
  129.   );
  130.  
  131. implementation
  132.  
  133. uses jconsts;
  134.  
  135. { The following types and external function declarations are used to
  136.   call into functions of the Independent JPEG Group's (IJG) implementation
  137.   of the JPEG image compression/decompression public standard.  The IJG
  138.   library's C source code is compiled into OBJ files and linked into
  139.   the Delphi application. Only types and functions needed by this unit
  140.   are declared; all IJG internal structures are stubbed out with
  141.   generic pointers to reduce internal source code congestion.
  142.  
  143.   IJG source code copyright (C) 1991-1996, Thomas G. Lane. }
  144.  
  145. {$Z4}  // Minimum enum size = dword
  146.  
  147. const
  148.   JPEG_LIB_VERSION = 61;        { Version 6a }
  149.  
  150.   JPEG_RST0     = $D0;  { RST0 marker code }
  151.   JPEG_EOI      = $D9;  { EOI marker code }
  152.   JPEG_APP0     = $E0;  { APP0 marker code }
  153.   JPEG_COM      = $FE;  { COM marker code }
  154.  
  155.   DCTSIZE             = 8;      { The basic DCT block is 8x8 samples }
  156.   DCTSIZE2            = 64;     { DCTSIZE squared; # of elements in a block }
  157.   NUM_QUANT_TBLS      = 4;      { Quantization tables are numbered 0..3 }
  158.   NUM_HUFF_TBLS       = 4;      { Huffman tables are numbered 0..3 }
  159.   NUM_ARITH_TBLS      = 16;     { Arith-coding tables are numbered 0..15 }
  160.   MAX_COMPS_IN_SCAN   = 4;      { JPEG limit on # of components in one scan }
  161.   MAX_SAMP_FACTOR     = 4;      { JPEG limit on sampling factors }
  162.   C_MAX_BLOCKS_IN_MCU = 10;     { compressor's limit on blocks per MCU }
  163.   D_MAX_BLOCKS_IN_MCU = 10;     { decompressor's limit on blocks per MCU }
  164.   MAX_COMPONENTS = 10;          { maximum number of image components (color channels) }
  165.  
  166.   MAXJSAMPLE = 255;
  167.   CENTERJSAMPLE = 128;
  168.  
  169. type
  170.   JSAMPLE = byte;
  171.   GETJSAMPLE = integer;
  172.   JCOEF = integer;
  173.   JCOEF_PTR = ^JCOEF;
  174.   UINT8 = byte;
  175.   UINT16 = Word;
  176.   UINT = Cardinal;
  177.   INT16 = SmallInt;
  178.   INT32 = Integer;
  179.   INT32PTR = ^INT32;
  180.   JDIMENSION = Cardinal;
  181.  
  182.   JOCTET = Byte;
  183.   jTOctet = 0..(MaxInt div SizeOf(JOCTET))-1;
  184.   JOCTET_FIELD = array[jTOctet] of JOCTET;
  185.   JOCTET_FIELD_PTR = ^JOCTET_FIELD;
  186.   JOCTETPTR = ^JOCTET;
  187.  
  188.   JSAMPLE_PTR = ^JSAMPLE;
  189.   JSAMPROW_PTR = ^JSAMPROW;
  190.  
  191.   jTSample = 0..(MaxInt div SIZEOF(JSAMPLE))-1;
  192.   JSAMPLE_ARRAY = Array[jTSample] of JSAMPLE;  {far}
  193.   JSAMPROW = ^JSAMPLE_ARRAY;  { ptr to one image row of pixel samples. }
  194.  
  195.   jTRow = 0..(MaxInt div SIZEOF(JSAMPROW))-1;
  196.   JSAMPROW_ARRAY = Array[jTRow] of JSAMPROW;
  197.   JSAMPARRAY = ^JSAMPROW_ARRAY;  { ptr to some rows (a 2-D sample array) }
  198.  
  199.   jTArray = 0..(MaxInt div SIZEOF(JSAMPARRAY))-1;
  200.   JSAMP_ARRAY = Array[jTArray] of JSAMPARRAY;
  201.   JSAMPIMAGE = ^JSAMP_ARRAY;  { a 3-D sample array: top index is color }
  202.  
  203. const
  204.   CSTATE_START        = 100;    { after create_compress }
  205.   CSTATE_SCANNING     = 101;    { start_compress done, write_scanlines OK }
  206.   CSTATE_RAW_OK       = 102;    { start_compress done, write_raw_data OK }
  207.   CSTATE_WRCOEFS      = 103;    { jpeg_write_coefficients done }
  208.   DSTATE_START        = 200;    { after create_decompress }
  209.   DSTATE_INHEADER     = 201;    { reading header markers, no SOS yet }
  210.   DSTATE_READY        = 202;    { found SOS, ready for start_decompress }
  211.   DSTATE_PRELOAD      = 203;    { reading multiscan file in start_decompress}
  212.   DSTATE_PRESCAN      = 204;    { performing dummy pass for 2-pass quant }
  213.   DSTATE_SCANNING     = 205;    { start_decompress done, read_scanlines OK }
  214.   DSTATE_RAW_OK       = 206;    { start_decompress done, read_raw_data OK }
  215.   DSTATE_BUFIMAGE     = 207;    { expecting jpeg_start_output }
  216.   DSTATE_BUFPOST      = 208;    { looking for SOS/EOI in jpeg_finish_output }
  217.   DSTATE_RDCOEFS      = 209;    { reading file in jpeg_read_coefficients }
  218.   DSTATE_STOPPING     = 210;    { looking for EOI in jpeg_finish_decompress }
  219.  
  220. { Known color spaces. }
  221.  
  222. type
  223.   J_COLOR_SPACE = (
  224.     JCS_UNKNOWN,            { error/unspecified }
  225.     JCS_GRAYSCALE,          { monochrome }
  226.     JCS_RGB,                { red/green/blue }
  227.     JCS_YCbCr,              { Y/Cb/Cr (also known as YUV) }
  228.     JCS_CMYK,               { C/M/Y/K }
  229.     JCS_YCCK                { Y/Cb/Cr/K }
  230.                   );
  231.  
  232. { DCT/IDCT algorithm options. }
  233.  
  234. type
  235.   J_DCT_METHOD = (
  236.     JDCT_ISLOW,        { slow but accurate integer algorithm }
  237.     JDCT_IFAST,        { faster, less accurate integer method }
  238.     JDCT_FLOAT        { floating-point: accurate, fast on fast HW (Pentium)}
  239.                  );
  240.  
  241. { Dithering options for decompression. }
  242.  
  243. type
  244.   J_DITHER_MODE = (
  245.     JDITHER_NONE,               { no dithering }
  246.     JDITHER_ORDERED,            { simple ordered dither }
  247.     JDITHER_FS                  { Floyd-Steinberg error diffusion dither }
  248.                   );
  249.  
  250. { Error handler }
  251.  
  252. const
  253.   JMSG_LENGTH_MAX  = 200;  { recommended size of format_message buffer }
  254.   JMSG_STR_PARM_MAX = 80;
  255.  
  256.   JPOOL_PERMANENT = 0;  // lasts until master record is destroyed
  257.   JPOOL_IMAGE        = 1;     // lasts until done with image/datastream
  258.  
  259. type
  260.   jpeg_error_mgr_ptr = ^jpeg_error_mgr;
  261.   jpeg_progress_mgr_ptr = ^jpeg_progress_mgr;
  262.  
  263.   j_common_ptr = ^jpeg_common_struct;
  264.   j_compress_ptr = ^jpeg_compress_struct;
  265.   j_decompress_ptr = ^jpeg_decompress_struct;
  266.  
  267. { Routine signature for application-supplied marker processing methods.
  268.   Need not pass marker code since it is stored in cinfo^.unread_marker. }
  269.  
  270.   jpeg_marker_parser_method = function(cinfo : j_decompress_ptr) : LongBool;
  271.  
  272. { Marker reading & parsing }
  273.   jpeg_marker_reader_ptr = ^jpeg_marker_reader;
  274.   jpeg_marker_reader = record
  275.     reset_marker_reader : procedure(cinfo : j_decompress_ptr);
  276.     { Read markers until SOS or EOI.
  277.       Returns same codes as are defined for jpeg_consume_input:
  278.       JPEG_SUSPENDED, JPEG_REACHED_SOS, or JPEG_REACHED_EOI. }
  279.  
  280.     read_markers : function (cinfo : j_decompress_ptr) : Integer;
  281.     { Read a restart marker --- exported for use by entropy decoder only }
  282.     read_restart_marker : jpeg_marker_parser_method;
  283.     { Application-overridable marker processing methods }
  284.     process_COM : jpeg_marker_parser_method;
  285.     process_APPn : Array[0..16-1] of jpeg_marker_parser_method;
  286.  
  287.     { State of marker reader --- nominally internal, but applications
  288.       supplying COM or APPn handlers might like to know the state. }
  289.  
  290.     saw_SOI : LongBool;            { found SOI? }
  291.     saw_SOF : LongBool;            { found SOF? }
  292.     next_restart_num : Integer;    { next restart number expected (0-7) }
  293.     discarded_bytes : UINT;        { # of bytes skipped looking for a marker }
  294.   end;
  295.  
  296.   {int8array = Array[0..8-1] of int;}
  297.   int8array = Array[0..8-1] of Integer;
  298.  
  299.   jpeg_error_mgr = record
  300.     { Error exit handler: does not return to caller }
  301.     error_exit : procedure  (cinfo : j_common_ptr);
  302.     { Conditionally emit a trace or warning message }
  303.     emit_message : procedure (cinfo : j_common_ptr; msg_level : Integer);
  304.     { Routine that actually outputs a trace or error message }
  305.     output_message : procedure (cinfo : j_common_ptr);
  306.     { Format a message string for the most recent JPEG error or message }
  307.     format_message : procedure  (cinfo : j_common_ptr; buffer: PChar);
  308.     { Reset error state variables at start of a new image }
  309.     reset_error_mgr : procedure (cinfo : j_common_ptr);
  310.  
  311.     { The message ID code and any parameters are saved here.
  312.       A message can have one string parameter or up to 8 int parameters. }
  313.  
  314.     msg_code : Integer;
  315.  
  316.     msg_parm : record
  317.       case byte of
  318.       0:(i : int8array);
  319.       1:(s : string[JMSG_STR_PARM_MAX]);
  320.     end;
  321.     trace_level : Integer;     { max msg_level that will be displayed }
  322.     num_warnings : Integer;    { number of corrupt-data warnings }
  323.   end;
  324.  
  325.  
  326. { Data destination object for compression }
  327.   jpeg_destination_mgr_ptr = ^jpeg_destination_mgr;
  328.   jpeg_destination_mgr = record
  329.     next_output_byte : JOCTETptr;  { => next byte to write in buffer }
  330.     free_in_buffer : Longint;    { # of byte spaces remaining in buffer }
  331.  
  332.     init_destination : procedure (cinfo : j_compress_ptr);
  333.     empty_output_buffer : function (cinfo : j_compress_ptr) : LongBool;
  334.     term_destination : procedure (cinfo : j_compress_ptr);
  335.   end;
  336.  
  337.  
  338. { Data source object for decompression }
  339.  
  340.   jpeg_source_mgr_ptr = ^jpeg_source_mgr;
  341.   jpeg_source_mgr = record
  342.     next_input_byte : JOCTETptr;      { => next byte to read from buffer }
  343.     bytes_in_buffer : Longint;       { # of bytes remaining in buffer }
  344.  
  345.     init_source : procedure  (cinfo : j_decompress_ptr);
  346.     fill_input_buffer : function (cinfo : j_decompress_ptr) : LongBool;
  347.     skip_input_data : procedure (cinfo : j_decompress_ptr; num_bytes : Longint);
  348.     resync_to_restart : function (cinfo : j_decompress_ptr;
  349.                                   desired : Integer) : LongBool;
  350.     term_source : procedure (cinfo : j_decompress_ptr);
  351.   end;
  352.  
  353. { JPEG library memory manger routines }
  354.   jpeg_memory_mgr_ptr = ^jpeg_memory_mgr;
  355.   jpeg_memory_mgr = record
  356.     { Method pointers }
  357.     alloc_small : function (cinfo : j_common_ptr;
  358.                             pool_id, sizeofobject: Integer): pointer;
  359.     alloc_large : function (cinfo : j_common_ptr;
  360.                             pool_id, sizeofobject: Integer): pointer;
  361.     alloc_sarray : function (cinfo : j_common_ptr; pool_id : Integer;
  362.                              samplesperrow : JDIMENSION;
  363.                              numrows : JDIMENSION) : JSAMPARRAY;
  364.     alloc_barray : pointer;
  365.     request_virt_sarray : pointer;
  366.     request_virt_barray : pointer;
  367.     realize_virt_arrays : pointer;
  368.     access_virt_sarray : pointer;
  369.     access_virt_barray : pointer;
  370.     free_pool : pointer;
  371.     self_destruct : pointer;
  372.     max_memory_to_use : Longint;
  373.   end;
  374.  
  375.     { Fields shared with jpeg_decompress_struct }
  376.   jpeg_common_struct = packed record
  377.     err : jpeg_error_mgr_ptr;        { Error handler module }
  378.     mem : jpeg_memory_mgr_ptr;          { Memory manager module }
  379.     progress : jpeg_progress_mgr_ptr;   { Progress monitor, or NIL if none }
  380.     is_decompressor : LongBool;      { so common code can tell which is which }
  381.     global_state : Integer;          { for checking call sequence validity }
  382.   end;
  383.  
  384. { Progress monitor object }
  385.  
  386.   jpeg_progress_mgr = record
  387.     progress_monitor : procedure(const cinfo : jpeg_common_struct);
  388.     pass_counter : Integer;     { work units completed in this pass }
  389.     pass_limit : Integer;       { total number of work units in this pass }
  390.     completed_passes : Integer;    { passes completed so far }
  391.     total_passes : Integer;     { total number of passes expected }
  392.     // extra Delphi info
  393.     instance: TJPEGImage;       // ptr to current TJPEGImage object
  394.     last_pass: Integer;
  395.     last_pct: Integer;
  396.     last_time: Integer;
  397.     last_scanline: Integer;
  398.   end;
  399.  
  400.  
  401. { Master record for a compression instance }
  402.  
  403.   jpeg_compress_struct = packed record
  404.     common: jpeg_common_struct;
  405.  
  406.     dest : jpeg_destination_mgr_ptr; { Destination for compressed data }
  407.  
  408.   { Description of source image --- these fields must be filled in by
  409.     outer application before starting compression.  in_color_space must
  410.     be correct before you can even call jpeg_set_defaults(). }
  411.  
  412.     image_width : JDIMENSION;         { input image width }
  413.     image_height : JDIMENSION;        { input image height }
  414.     input_components : Integer;       { # of color components in input image }
  415.     in_color_space : J_COLOR_SPACE;   { colorspace of input image }
  416.     input_gamma : double;             { image gamma of input image }
  417.  
  418.     // Compression parameters
  419.     data_precision : Integer;             { bits of precision in image data }
  420.     num_components : Integer;             { # of color components in JPEG image }
  421.     jpeg_color_space : J_COLOR_SPACE;     { colorspace of JPEG image }
  422.     comp_info : Pointer;
  423.     quant_tbl_ptrs: Array[0..NUM_QUANT_TBLS-1] of Pointer;
  424.     dc_huff_tbl_ptrs : Array[0..NUM_HUFF_TBLS-1] of Pointer;
  425.     ac_huff_tbl_ptrs : Array[0..NUM_HUFF_TBLS-1] of Pointer;
  426.     arith_dc_L : Array[0..NUM_ARITH_TBLS-1] of UINT8; { L values for DC arith-coding tables }
  427.     arith_dc_U : Array[0..NUM_ARITH_TBLS-1] of UINT8; { U values for DC arith-coding tables }
  428.     arith_ac_K : Array[0..NUM_ARITH_TBLS-1] of UINT8; { Kx values for AC arith-coding tables }
  429.     num_scans : Integer;         { # of entries in scan_info array }
  430.     scan_info : Pointer;     { script for multi-scan file, or NIL }
  431.     raw_data_in : LongBool;        { TRUE=caller supplies downsampled data }
  432.     arith_code : LongBool;         { TRUE=arithmetic coding, FALSE=Huffman }
  433.     optimize_coding : LongBool;    { TRUE=optimize entropy encoding parms }
  434.     CCIR601_sampling : LongBool;   { TRUE=first samples are cosited }
  435.     smoothing_factor : Integer;       { 1..100, or 0 for no input smoothing }
  436.     dct_method : J_DCT_METHOD;    { DCT algorithm selector }
  437.     restart_interval : UINT;      { MCUs per restart, or 0 for no restart }
  438.     restart_in_rows : Integer;        { if > 0, MCU rows per restart interval }
  439.  
  440.     { Parameters controlling emission of special markers. }
  441.     write_JFIF_header : LongBool;  { should a JFIF marker be written? }
  442.     { These three values are not used by the JPEG code, merely copied }
  443.     { into the JFIF APP0 marker.  density_unit can be 0 for unknown, }
  444.     { 1 for dots/inch, or 2 for dots/cm.  Note that the pixel aspect }
  445.     { ratio is defined by X_density/Y_density even when density_unit=0. }
  446.     density_unit : UINT8;         { JFIF code for pixel size units }
  447.     X_density : UINT16;           { Horizontal pixel density }
  448.     Y_density : UINT16;           { Vertical pixel density }
  449.     write_Adobe_marker : LongBool; { should an Adobe marker be written? }
  450.  
  451.     { State variable: index of next scanline to be written to
  452.       jpeg_write_scanlines().  Application may use this to control its
  453.       processing loop, e.g., "while (next_scanline < image_height)". }
  454.  
  455.     next_scanline : JDIMENSION;   { 0 .. image_height-1  }
  456.  
  457.     { Remaining fields are known throughout compressor, but generally
  458.       should not be touched by a surrounding application. }
  459.     progressive_mode : LongBool;   { TRUE if scan script uses progressive mode }
  460.     max_h_samp_factor : Integer;      { largest h_samp_factor }
  461.     max_v_samp_factor : Integer;      { largest v_samp_factor }
  462.     total_iMCU_rows : JDIMENSION; { # of iMCU rows to be input to coef ctlr }
  463.     comps_in_scan : Integer;          { # of JPEG components in this scan }
  464.     cur_comp_info : Array[0..MAX_COMPS_IN_SCAN-1] of Pointer;
  465.     MCUs_per_row : JDIMENSION;    { # of MCUs across the image }
  466.     MCU_rows_in_scan : JDIMENSION;{ # of MCU rows in the image }
  467.     blocks_in_MCU : Integer;          { # of DCT blocks per MCU }
  468.     MCU_membership : Array[0..C_MAX_BLOCKS_IN_MCU-1] of Integer;
  469.     Ss, Se, Ah, Al : Integer;         { progressive JPEG parameters for scan }
  470.  
  471.     { Links to compression subobjects (methods and private variables of modules) }
  472.     master : Pointer;
  473.     main : Pointer;
  474.     prep : Pointer;
  475.     coef : Pointer;
  476.     marker : Pointer;
  477.     cconvert : Pointer;
  478.     downsample : Pointer;
  479.     fdct : Pointer;
  480.     entropy : Pointer;
  481.   end;
  482.  
  483.  
  484. { Master record for a decompression instance }
  485.  
  486.   jpeg_decompress_struct = packed record
  487.     common: jpeg_common_struct;
  488.  
  489.     { Source of compressed data }
  490.     src : jpeg_source_mgr_ptr;
  491.  
  492.     { Basic description of image --- filled in by jpeg_read_header(). }
  493.     { Application may inspect these values to decide how to process image. }
  494.  
  495.     image_width : JDIMENSION;      { nominal image width (from SOF marker) }
  496.     image_height : JDIMENSION;     { nominal image height }
  497.     num_components : Integer;          { # of color components in JPEG image }
  498.     jpeg_color_space : J_COLOR_SPACE; { colorspace of JPEG image }
  499.  
  500.     { Decompression processing parameters }
  501.     out_color_space : J_COLOR_SPACE; { colorspace for output }
  502.     scale_num, scale_denom : uint ;  { fraction by which to scale image }
  503.     output_gamma : double;           { image gamma wanted in output }
  504.     buffered_image : LongBool;        { TRUE=multiple output passes }
  505.     raw_data_out : LongBool;          { TRUE=downsampled data wanted }
  506.     dct_method : J_DCT_METHOD;       { IDCT algorithm selector }
  507.     do_fancy_upsampling : LongBool;   { TRUE=apply fancy upsampling }
  508.     do_block_smoothing : LongBool;    { TRUE=apply interblock smoothing }
  509.     quantize_colors : LongBool;       { TRUE=colormapped output wanted }
  510.     { the following are ignored if not quantize_colors: }
  511.     dither_mode : J_DITHER_MODE;     { type of color dithering to use }
  512.     two_pass_quantize : LongBool;     { TRUE=use two-pass color quantization }
  513.     desired_number_of_colors : Integer;  { max # colors to use in created colormap }
  514.     { these are significant only in buffered-image mode: }
  515.     enable_1pass_quant : LongBool;    { enable future use of 1-pass quantizer }
  516.     enable_external_quant : LongBool; { enable future use of external colormap }
  517.     enable_2pass_quant : LongBool;    { enable future use of 2-pass quantizer }
  518.  
  519.     { Description of actual output image that will be returned to application.
  520.       These fields are computed by jpeg_start_decompress().
  521.       You can also use jpeg_calc_output_dimensions() to determine these values
  522.       in advance of calling jpeg_start_decompress(). }
  523.  
  524.     output_width : JDIMENSION;       { scaled image width }
  525.     output_height: JDIMENSION;       { scaled image height }
  526.     out_color_components : Integer;  { # of color components in out_color_space }
  527.     output_components : Integer;     { # of color components returned }
  528.     { output_components is 1 (a colormap index) when quantizing colors;
  529.       otherwise it equals out_color_components. }
  530.  
  531.     rec_outbuf_height : Integer;     { min recommended height of scanline buffer }
  532.     { If the buffer passed to jpeg_read_scanlines() is less than this many
  533.       rows high, space and time will be wasted due to unnecessary data
  534.       copying. Usually rec_outbuf_height will be 1 or 2, at most 4. }
  535.  
  536.     { When quantizing colors, the output colormap is described by these
  537.       fields. The application can supply a colormap by setting colormap
  538.       non-NIL before calling jpeg_start_decompress; otherwise a colormap
  539.       is created during jpeg_start_decompress or jpeg_start_output. The map
  540.       has out_color_components rows and actual_number_of_colors columns. }
  541.  
  542.     actual_number_of_colors : Integer;      { number of entries in use }
  543.     colormap : JSAMPARRAY;              { The color map as a 2-D pixel array }
  544.  
  545.     { State variables: these variables indicate the progress of decompression.
  546.       The application may examine these but must not modify them. }
  547.  
  548.     { Row index of next scanline to be read from jpeg_read_scanlines().
  549.       Application may use this to control its processing loop, e.g.,
  550.       "while (output_scanline < output_height)". }
  551.  
  552.     output_scanline : JDIMENSION; { 0 .. output_height-1  }
  553.  
  554.     { Current input scan number and number of iMCU rows completed in scan.
  555.       These indicate the progress of the decompressor input side. }
  556.  
  557.     input_scan_number : Integer;      { Number of SOS markers seen so far }
  558.     input_iMCU_row : JDIMENSION;  { Number of iMCU rows completed }
  559.  
  560.     { The "output scan number" is the notional scan being displayed by the
  561.       output side.  The decompressor will not allow output scan/row number
  562.       to get ahead of input scan/row, but it can fall arbitrarily far behind.}
  563.  
  564.     output_scan_number : Integer;     { Nominal scan number being displayed }
  565.     output_iMCU_row : Integer;        { Number of iMCU rows read }
  566.  
  567.     coef_bits : Pointer;
  568.  
  569.     { Internal JPEG parameters --- the application usually need not look at
  570.       these fields.  Note that the decompressor output side may not use
  571.       any parameters that can change between scans. }
  572.  
  573.     { Quantization and Huffman tables are carried forward across input
  574.       datastreams when processing abbreviated JPEG datastreams. }
  575.  
  576.     quant_tbl_ptrs : Array[0..NUM_QUANT_TBLS-1] of Pointer;
  577.     dc_huff_tbl_ptrs : Array[0..NUM_HUFF_TBLS-1] of Pointer;
  578.     ac_huff_tbl_ptrs : Array[0..NUM_HUFF_TBLS-1] of Pointer;
  579.  
  580.     { These parameters are never carried across datastreams, since they
  581.       are given in SOF/SOS markers or defined to be reset by SOI. }
  582.     data_precision : Integer;          { bits of precision in image data }
  583.     comp_info : Pointer;
  584.     progressive_mode : LongBool;    { TRUE if SOFn specifies progressive mode }
  585.     arith_code : LongBool;          { TRUE=arithmetic coding, FALSE=Huffman }
  586.     arith_dc_L : Array[0..NUM_ARITH_TBLS-1] of UINT8; { L values for DC arith-coding tables }
  587.     arith_dc_U : Array[0..NUM_ARITH_TBLS-1] of UINT8; { U values for DC arith-coding tables }
  588.     arith_ac_K : Array[0..NUM_ARITH_TBLS-1] of UINT8; { Kx values for AC arith-coding tables }
  589.  
  590.     restart_interval : UINT; { MCUs per restart interval, or 0 for no restart }
  591.  
  592.     { These fields record data obtained from optional markers recognized by
  593.       the JPEG library. }
  594.     saw_JFIF_marker : LongBool;  { TRUE iff a JFIF APP0 marker was found }
  595.     { Data copied from JFIF marker: }
  596.     density_unit : UINT8;       { JFIF code for pixel size units }
  597.     X_density : UINT16;         { Horizontal pixel density }
  598.     Y_density : UINT16;         { Vertical pixel density }
  599.     saw_Adobe_marker : LongBool; { TRUE iff an Adobe APP14 marker was found }
  600.     Adobe_transform : UINT8;    { Color transform code from Adobe marker }
  601.  
  602.     CCIR601_sampling : LongBool; { TRUE=first samples are cosited }
  603.  
  604.     { Remaining fields are known throughout decompressor, but generally
  605.       should not be touched by a surrounding application. }
  606.     max_h_samp_factor : Integer;    { largest h_samp_factor }
  607.     max_v_samp_factor : Integer;    { largest v_samp_factor }
  608.     min_DCT_scaled_size : Integer;  { smallest DCT_scaled_size of any component }
  609.     total_iMCU_rows : JDIMENSION; { # of iMCU rows in image }
  610.     sample_range_limit : Pointer;   { table for fast range-limiting }
  611.  
  612.     { These fields are valid during any one scan.
  613.       They describe the components and MCUs actually appearing in the scan.
  614.       Note that the decompressor output side must not use these fields. }
  615.     comps_in_scan : Integer;           { # of JPEG components in this scan }
  616.     cur_comp_info : Array[0..MAX_COMPS_IN_SCAN-1] of Pointer;
  617.     MCUs_per_row : JDIMENSION;     { # of MCUs across the image }
  618.     MCU_rows_in_scan : JDIMENSION; { # of MCU rows in the image }
  619.     blocks_in_MCU : JDIMENSION;    { # of DCT blocks per MCU }
  620.     MCU_membership : Array[0..D_MAX_BLOCKS_IN_MCU-1] of Integer;
  621.     Ss, Se, Ah, Al : Integer;          { progressive JPEG parameters for scan }
  622.  
  623.     { This field is shared between entropy decoder and marker parser.
  624.       It is either zero or the code of a JPEG marker that has been
  625.       read from the data source, but has not yet been processed. }
  626.     unread_marker : Integer;
  627.  
  628.     { Links to decompression subobjects
  629.       (methods, private variables of modules) }
  630.     master : Pointer;
  631.     main : Pointer;
  632.     coef : Pointer;
  633.     post : Pointer;
  634.     inputctl : Pointer;
  635.     marker : Pointer;
  636.     entropy : Pointer;
  637.     idct : Pointer;
  638.     upsample : Pointer;
  639.     cconvert : Pointer;
  640.     cquantize : Pointer;
  641.   end;
  642.  
  643.   TJPEGContext = record
  644.     err: jpeg_error_mgr;
  645.     progress: jpeg_progress_mgr;
  646.     FinalDCT: J_DCT_METHOD;
  647.     FinalTwoPassQuant: Boolean;
  648.     FinalDitherMode: J_DITHER_MODE;
  649.     case byte of
  650.       0: (common: jpeg_common_struct);
  651.       1: (d: jpeg_decompress_struct);
  652.       2: (c: jpeg_compress_struct);
  653.   end;
  654.  
  655. { Decompression startup: read start of JPEG datastream to see what's there
  656.    function jpeg_read_header (cinfo : j_decompress_ptr;
  657.                               require_image : LongBool) : Integer;
  658.   Return value is one of: }
  659. const
  660.   JPEG_SUSPENDED              = 0; { Suspended due to lack of input data }
  661.   JPEG_HEADER_OK              = 1; { Found valid image datastream }
  662.   JPEG_HEADER_TABLES_ONLY     = 2; { Found valid table-specs-only datastream }
  663. { If you pass require_image = TRUE (normal case), you need not check for
  664.   a TABLES_ONLY return code; an abbreviated file will cause an error exit.
  665.   JPEG_SUSPENDED is only possible if you use a data source module that can
  666.   give a suspension return (the stdio source module doesn't). }
  667.  
  668.  
  669. { function jpeg_consume_input (cinfo : j_decompress_ptr) : Integer;
  670.   Return value is one of: }
  671.  
  672.   JPEG_REACHED_SOS            = 1; { Reached start of new scan }
  673.   JPEG_REACHED_EOI            = 2; { Reached end of image }
  674.   JPEG_ROW_COMPLETED          = 3; { Completed one iMCU row }
  675.   JPEG_SCAN_COMPLETED         = 4; { Completed last iMCU row of a scan }
  676.  
  677.  
  678. // Stubs for external C RTL functions referenced by JPEG OBJ files.
  679.  
  680. function _malloc(size: Integer): Pointer; cdecl;
  681. begin
  682.   GetMem(Result, size);
  683. end;
  684.  
  685. procedure _free(P: Pointer); cdecl;
  686. begin
  687.   FreeMem(P);
  688. end;
  689.  
  690. procedure _memset(P: Pointer; B: Byte; count: Integer);cdecl;
  691. begin
  692.   FillChar(P^, count, B);
  693. end;
  694.  
  695. procedure _memcpy(dest, source: Pointer; count: Integer);cdecl;
  696. begin
  697.   Move(source^, dest^, count);
  698. end;
  699.  
  700. function _fread(var buf; recsize, reccount: Integer; S: TStream): Integer; cdecl;
  701. begin
  702.   Result := S.Read(buf, recsize * reccount);
  703. end;
  704.  
  705. function _fwrite(const buf; recsize, reccount: Integer; S: TStream): Integer; cdecl;
  706. begin
  707.   Result := S.Write(buf, recsize * reccount);
  708. end;
  709.  
  710. function _fflush(S: TStream): Integer; cdecl;
  711. begin
  712.   Result := 0;
  713. end;
  714.  
  715. function __ftol: Integer;
  716. var
  717.   f: double;
  718. begin
  719.   asm
  720.     lea    eax, f             //  BC++ passes floats on the FPU stack
  721.     fstp  qword ptr [eax]     //  Delphi passes floats on the CPU stack
  722.   end;
  723.   Result := Integer(Trunc(f));
  724. end;
  725.  
  726. var
  727.   __turboFloat: LongBool = False;
  728.  
  729. {$L jdapimin.obj}
  730. {$L jmemmgr.obj}
  731. {$L jmemnobs.obj}
  732. {$L jdinput.obj}
  733. {$L jdatasrc.obj}
  734. {$L jdapistd.obj}
  735. {$L jdmaster.obj}
  736. {$L jdphuff.obj}
  737. {$L jdhuff.obj}
  738. {$L jdmerge.obj}
  739. {$L jdcolor.obj}
  740. {$L jquant1.obj}
  741. {$L jquant2.obj}
  742. {$L jdmainct.obj}
  743. {$L jdcoefct.obj}
  744. {$L jdpostct.obj}
  745. {$L jddctmgr.obj}
  746. {$L jdsample.obj}
  747. {$L jidctflt.obj}
  748. {$L jidctfst.obj}
  749. {$L jidctint.obj}
  750. {$L jidctred.obj}
  751. {$L jdmarker.obj}
  752. {$L jutils.obj}
  753. {$L jcomapi.obj}
  754.  
  755. procedure jpeg_CreateDecompress (var cinfo : jpeg_decompress_struct;
  756.   version : integer; structsize : integer); external;
  757. procedure jpeg_stdio_src(var cinfo: jpeg_decompress_struct;
  758.   input_file: TStream); external;
  759. procedure jpeg_read_header(var cinfo: jpeg_decompress_struct;
  760.   RequireImage: LongBool); external;
  761. procedure jpeg_calc_output_dimensions(var cinfo: jpeg_decompress_struct); external;
  762. function jpeg_start_decompress(var cinfo: jpeg_decompress_struct): Longbool; external;
  763. function jpeg_read_scanlines(var cinfo: jpeg_decompress_struct;
  764.     scanlines: JSAMPARRAY; max_lines: JDIMENSION): JDIMENSION; external;
  765. function jpeg_finish_decompress(var cinfo: jpeg_decompress_struct): Longbool; external;
  766. procedure jpeg_destroy_decompress (var cinfo : jpeg_decompress_struct); external;
  767. function jpeg_has_multiple_scans(var cinfo: jpeg_decompress_struct): Longbool; external;
  768. function jpeg_consume_input(var cinfo: jpeg_decompress_struct): Integer; external;
  769. function jpeg_start_output(var cinfo: jpeg_decompress_struct; scan_number: Integer): Longbool; external;
  770. function jpeg_finish_output(var cinfo: jpeg_decompress_struct): LongBool; external;
  771. procedure jpeg_destroy(var cinfo: jpeg_common_struct); external;
  772.  
  773. {$L jdatadst.obj}
  774. {$L jcparam.obj}
  775. {$L jcapistd.obj}
  776. {$L jcapimin.obj}
  777. {$L jcinit.obj}
  778. {$L jcmarker.obj}
  779. {$L jcmaster.obj}
  780. {$L jcmainct.obj}
  781. {$L jcprepct.obj}
  782. {$L jccoefct.obj}
  783. {$L jccolor.obj}
  784. {$L jcsample.obj}
  785. {$L jcdctmgr.obj}
  786. {$L jcphuff.obj}
  787. {$L jfdctint.obj}
  788. {$L jfdctfst.obj}
  789. {$L jfdctflt.obj}
  790. {$L jchuff.obj}
  791.  
  792. procedure jpeg_CreateCompress (var cinfo : jpeg_compress_struct;
  793.   version : integer; structsize : integer); external;
  794. procedure jpeg_stdio_dest(var cinfo: jpeg_compress_struct;
  795.   output_file: TStream); external;
  796. procedure jpeg_set_defaults(var cinfo: jpeg_compress_struct); external;
  797. procedure jpeg_set_quality(var cinfo: jpeg_compress_struct; Quality: Integer;
  798.   Baseline: Longbool); external;
  799. procedure jpeg_set_colorspace(var cinfo: jpeg_compress_struct;
  800.   colorspace: J_COLOR_SPACE); external;
  801. procedure jpeg_simple_progression(var cinfo: jpeg_compress_struct); external;
  802. procedure jpeg_start_compress(var cinfo: jpeg_compress_struct;
  803.   WriteAllTables: LongBool); external;
  804. function jpeg_write_scanlines(var cinfo: jpeg_compress_struct;
  805.   scanlines: JSAMPARRAY; max_lines: JDIMENSION): JDIMENSION; external;
  806. procedure jpeg_finish_compress(var cinfo: jpeg_compress_struct); external;
  807.  
  808.  
  809. type
  810.   EJPEG = class(EInvalidGraphic);
  811.  
  812. procedure InvalidOperation(const Msg: string); near;
  813. begin
  814.   raise EInvalidGraphicOperation.Create(Msg);
  815. end;
  816.  
  817. procedure JpegError(cinfo: j_common_ptr);
  818. begin
  819.   raise EJPEG.CreateFmt(sJPEGError,[cinfo^.err^.msg_code]);
  820. end;
  821.  
  822. procedure EmitMessage(cinfo: j_common_ptr; msg_level: Integer);
  823. begin
  824.   //!!
  825. end;
  826.  
  827. procedure OutputMessage(cinfo: j_common_ptr);
  828. begin
  829.   //!!
  830. end;
  831.  
  832. procedure FormatMessage(cinfo: j_common_ptr; buffer: PChar);
  833. begin
  834.   //!!
  835. end;
  836.  
  837. procedure ResetErrorMgr(cinfo: j_common_ptr);
  838. begin
  839.   cinfo^.err^.num_warnings := 0;
  840.   cinfo^.err^.msg_code := 0;
  841. end;
  842.  
  843.  
  844. const
  845.   jpeg_std_error: jpeg_error_mgr = (
  846.     error_exit: JpegError;
  847.     emit_message: EmitMessage;
  848.     output_message: OutputMessage;
  849.     format_message: FormatMessage;
  850.     reset_error_mgr: ResetErrorMgr);
  851.  
  852.  
  853. { TJPEGData }
  854.  
  855. destructor TJPEGData.Destroy;
  856. begin
  857.   FData.Free;
  858.   inherited Destroy;
  859. end;
  860.  
  861. procedure TJPEGData.FreeHandle;
  862. begin
  863. end;
  864.  
  865. { TJPEGImage }
  866.  
  867. constructor TJPEGImage.Create;
  868. begin
  869.   inherited Create;
  870.   NewImage;
  871.   FQuality := JPEGDefaults.CompressionQuality;
  872.   FGrayscale := JPEGDefaults.Grayscale;
  873.   FPerformance := JPEGDefaults.Performance;
  874.   FPixelFormat := JPEGDefaults.PixelFormat;
  875.   FProgressiveDisplay := JPEGDefaults.ProgressiveDisplay;
  876.   FProgressiveEncoding := JPEGDefaults.ProgressiveEncoding;
  877.   FScale := JPEGDefaults.Scale;
  878.   FSmoothing := JPEGDefaults.Smoothing;
  879. end;
  880.  
  881. destructor TJPEGImage.Destroy;
  882. begin
  883.   if FTempPal <> 0 then DeleteObject(FTempPal);
  884.   FBitmap.Free;
  885.   FImage.Release;
  886.   inherited Destroy;
  887. end;
  888.  
  889. procedure TJPEGImage.Assign(Source: TPersistent);
  890. begin
  891.   if Source is TJPEGImage then
  892.   begin
  893.     FImage.Release;
  894.     FImage := TJPEGImage(Source).FImage;
  895.     FImage.Reference;
  896.     if TJPEGImage(Source).FBitmap <> nil then
  897.     begin
  898.       NewBitmap;
  899.       FBitmap.Assign(TJPEGImage(Source).FBitmap);
  900.     end;
  901.   end
  902.   else if Source is TBitmap then
  903.   begin
  904.     NewImage;
  905.     NewBitmap;
  906.     FBitmap.Assign(Source);
  907.   end
  908.   else
  909.     inherited Assign(Source);
  910. end;
  911.  
  912. procedure TJPEGImage.AssignTo(Dest: TPersistent);
  913. begin
  914.   if Dest is TBitmap then
  915.     Dest.Assign(Bitmap)
  916.   else
  917.     inherited AssignTo(Dest);
  918. end;
  919.  
  920. procedure ProgressCallback(const cinfo: jpeg_common_struct);
  921. var
  922.   Ticks: Integer;
  923.   R: TRect;
  924.   temp: Integer;
  925. begin
  926.   if (cinfo.progress = nil) or (cinfo.progress^.instance = nil) then Exit;
  927.   with cinfo.progress^ do
  928.   begin
  929.     Ticks := GetTickCount;
  930.     if (Ticks - last_time) < 500 then Exit;
  931.     temp := last_time;
  932.     last_time := Ticks;
  933.     if temp = 0 then Exit;
  934.     if cinfo.is_decompressor then
  935.       with j_decompress_ptr(@cinfo)^ do
  936.       begin
  937.         R := Rect(0, last_scanline, output_width, output_scanline);
  938.         if R.Bottom < last_scanline then
  939.           R.Bottom := output_height;
  940.       end
  941.     else
  942.       R := Rect(0,0,0,0);
  943.     temp := Integer(Trunc(100.0*(completed_passes + (pass_counter/pass_limit))/total_passes));
  944.     if temp = last_pct then Exit;
  945.     last_pct := temp;
  946.     if cinfo.is_decompressor then
  947.       last_scanline := j_decompress_ptr(@cinfo)^.output_scanline;
  948.     instance.Progress(instance, psRunning, temp, (R.Bottom - R.Top) >= 4, R, '');
  949.   end;
  950. end;
  951.  
  952. procedure ReleaseContext(var jc: TJPEGContext);
  953. begin
  954.   if jc.common.err = nil then Exit;
  955.   jpeg_destroy(jc.common);
  956.   jc.common.err := nil;
  957. end;
  958.  
  959. procedure InitDecompressor(Obj: TJPEGImage; var jc: TJPEGContext);
  960. begin
  961.   FillChar(jc, sizeof(jc), 0);
  962.   jc.err := jpeg_std_error;
  963.   jc.common.err := @jc.err;
  964.  
  965.   jpeg_CreateDecompress(jc.d, JPEG_LIB_VERSION, sizeof(jc.d));
  966.   with Obj do
  967.   try
  968.     jc.progress.progress_monitor := @ProgressCallback;
  969.     jc.progress.instance := Obj;
  970.     jc.common.progress := @jc.progress;
  971.  
  972.     Obj.FImage.FData.Position := 0;
  973.     jpeg_stdio_src(jc.d, FImage.FData);
  974.     jpeg_read_header(jc.d, TRUE);
  975.  
  976.     jc.d.scale_num := 1;
  977.     jc.d.scale_denom := 1 shl Byte(FScale);
  978.     jc.d.do_block_smoothing := FSmoothing;
  979.  
  980.     if FGrayscale then jc.d.out_color_space := JCS_GRAYSCALE;
  981.     if (PixelFormat = jf8Bit) or (jc.d.out_color_space = JCS_GRAYSCALE) then
  982.     begin
  983.       jc.d.quantize_colors := True;
  984.       jc.d.desired_number_of_colors := 236;
  985.     end;
  986.  
  987.     if FPerformance = jpBestSpeed then
  988.     begin
  989.       jc.d.dct_method := JDCT_IFAST;
  990.       jc.d.two_pass_quantize := False;
  991. //      jc.d.do_fancy_upsampling := False;    !! AV inside jpeglib
  992.       jc.d.dither_mode := JDITHER_ORDERED;
  993.     end;
  994.  
  995.     jc.FinalDCT := jc.d.dct_method;
  996.     jc.FinalTwoPassQuant := jc.d.two_pass_quantize;
  997.     jc.FinalDitherMode := jc.d.dither_mode;
  998.     if FProgressiveDisplay and jpeg_has_multiple_scans(jc.d) then
  999.     begin  // save requested settings, reset for fastest on all but last scan
  1000.       jc.d.enable_2pass_quant := jc.d.two_pass_quantize;
  1001.       jc.d.dct_method := JDCT_IFAST;
  1002.       jc.d.two_pass_quantize := False;
  1003.       jc.d.dither_mode := JDITHER_ORDERED;
  1004.       jc.d.buffered_image := True;
  1005.     end;
  1006.   except
  1007.     ReleaseContext(jc);
  1008.     raise;
  1009.   end;
  1010. end;
  1011.  
  1012. procedure TJPEGImage.CalcOutputDimensions;
  1013. var
  1014.   jc: TJPEGContext;
  1015. begin
  1016.   if not FNeedRecalc then Exit;
  1017.   InitDecompressor(Self, jc);
  1018.   try
  1019.     jc.common.progress := nil;
  1020.     jpeg_calc_output_dimensions(jc.d);
  1021.     // read output dimensions
  1022.     FScaledWidth := jc.d.output_width;
  1023.     FScaledHeight := jc.d.output_height;
  1024.     FProgressiveEncoding := jpeg_has_multiple_scans(jc.d);
  1025.   finally
  1026.     ReleaseContext(jc);
  1027.   end;
  1028. end;
  1029.  
  1030. procedure TJPEGImage.Changed(Sender: TObject);
  1031. begin
  1032.   inherited Changed(Sender);
  1033. end;
  1034.  
  1035. procedure TJPEGImage.Compress;
  1036. var
  1037.   LinesWritten, LinesPerCall: Integer;
  1038.   SrcScanLine: Pointer;
  1039.   PtrInc: Integer;
  1040.   jc: TJPEGContext;
  1041.   Src: TBitmap;
  1042. begin
  1043.   FillChar(jc, sizeof(jc), 0);
  1044.   jc.err := jpeg_std_error;
  1045.   jc.common.err := @jc.err;
  1046.  
  1047.   jpeg_CreateCompress(jc.c, JPEG_LIB_VERSION, sizeof(jc.c));
  1048.   try
  1049.     try
  1050.       jc.progress.progress_monitor := @ProgressCallback;
  1051.       jc.progress.instance := Self;
  1052.       jc.common.progress := @jc.progress;
  1053.  
  1054.       if FImage.FData <> nil then NewImage;
  1055.       FImage.FData := TMemoryStream.Create;
  1056.       FImage.FData.Position := 0;
  1057.       jpeg_stdio_dest(jc.c, FImage.FData);
  1058.  
  1059.       if (FBitmap = nil) or (FBitmap.Width = 0) or (FBitmap.Height = 0) then Exit;
  1060.       jc.c.image_width := FBitmap.Width;
  1061.       FImage.FWidth := FBitmap.Width;
  1062.       jc.c.image_height := FBitmap.Height;
  1063.       FImage.FHeight := FBitmap.Height;
  1064.       jc.c.input_components := 3;           // JPEG requires 24bit RGB input
  1065.       jc.c.in_color_space := JCS_RGB;
  1066.  
  1067.       Src := TBitmap.Create;
  1068.       try
  1069.         Src.Assign(FBitmap);
  1070.         Src.PixelFormat := pf24bit;
  1071.  
  1072.         jpeg_set_defaults(jc.c);
  1073.         jpeg_set_quality(jc.c, FQuality, True);
  1074.  
  1075.         if FGrayscale then
  1076.         begin
  1077.           FImage.FGrayscale := True;
  1078.           jpeg_set_colorspace(jc.c, JCS_GRAYSCALE);
  1079.         end;
  1080.  
  1081.         if ProgressiveEncoding then
  1082.           jpeg_simple_progression(jc.c);
  1083.  
  1084.         SrcScanline := Src.ScanLine[0];
  1085.         PtrInc := Integer(Src.ScanLine[1]) - Integer(SrcScanline);
  1086.  
  1087.           // if no dword padding required and source bitmap is top-down
  1088.         if (PtrInc > 0) and ((PtrInc and 3) = 0) then
  1089.           LinesPerCall := jc.c.image_height  // do whole bitmap in one call
  1090.         else
  1091.           LinesPerCall := 1;      // otherwise spoonfeed one row at a time
  1092.  
  1093.         Progress(Self, psStarting, 0, False, Rect(0,0,0,0), '');
  1094.         try
  1095.           jpeg_start_compress(jc.c, True);
  1096.  
  1097.           while (jc.c.next_scanline < jc.c.image_height) do
  1098.           begin
  1099.             LinesWritten := jpeg_write_scanlines(jc.c, @SrcScanline, LinesPerCall);
  1100.             Inc(Integer(SrcScanline), PtrInc * LinesWritten);
  1101.           end;
  1102.  
  1103.           jpeg_finish_compress(jc.c);
  1104.         finally
  1105.           if ExceptObject = nil then
  1106.             PtrInc := 100
  1107.           else
  1108.             PtrInc := 0;
  1109.           Progress(Self, psEnding, PtrInc, False, Rect(0,0,0,0), '');
  1110.         end;
  1111.       finally
  1112.         Src.Free;
  1113.       end;
  1114.     except
  1115.       on EAbort do    // OnProgress can raise EAbort to cancel image save
  1116.         NewImage;     // Throw away any partial jpg data
  1117.     end;
  1118.   finally
  1119.     ReleaseContext(jc);
  1120.   end;
  1121. end;
  1122.  
  1123. procedure TJPEGImage.DIBNeeded;
  1124. begin
  1125.   GetBitmap;
  1126. end;
  1127.  
  1128. procedure TJPEGImage.Draw(ACanvas: TCanvas; const Rect: TRect);
  1129. begin
  1130.   ACanvas.StretchDraw(Rect, Bitmap);
  1131. end;
  1132.  
  1133. function TJPEGImage.Equals(Graphic: TGraphic): Boolean;
  1134. begin
  1135.   Result := False;
  1136.   if not (Graphic is TJPEGImage) then Exit;
  1137.   // Only call the inherited if both ends have compressed data.
  1138.   // We don't want to set off a compression cycle to create the FData stream
  1139.   if (FImage.FData <> nil) and (TJPEGImage(Graphic).FImage.FData <> nil) then
  1140.     Result := inherited Equals(Graphic)
  1141.   else  // FImage is shared if Assign is used to copy between TJPEGImage instances
  1142.     Result := (FImage = TJPEGImage(Graphic).FImage);
  1143. end;
  1144.  
  1145. procedure TJPEGImage.FreeBitmap;
  1146. begin
  1147.   FBitmap.Free;
  1148.   FBitmap := nil;
  1149. end;
  1150.  
  1151. function BuildPalette(const cinfo: jpeg_decompress_struct): HPalette;
  1152. var
  1153.   Pal: TMaxLogPalette;
  1154.   I: Integer;
  1155.   C: Byte;
  1156. begin
  1157.   Pal.palVersion := $300;
  1158.   Pal.palNumEntries := cinfo.actual_number_of_colors;
  1159.   if cinfo.out_color_space = JCS_GRAYSCALE then
  1160.     for I := 0 to Pal.palNumEntries-1 do
  1161.     begin
  1162.       C := cinfo.colormap^[0]^[I];
  1163.       Pal.palPalEntry[I].peRed := C;
  1164.       Pal.palPalEntry[I].peGreen := C;
  1165.       Pal.palPalEntry[I].peBlue := C;
  1166.       Pal.palPalEntry[I].peFlags := 0;
  1167.     end
  1168.   else
  1169.     for I := 0 to Pal.palNumEntries-1 do
  1170.     begin
  1171.       Pal.palPalEntry[I].peRed := cinfo.colormap^[2]^[I];
  1172.       Pal.palPalEntry[I].peGreen := cinfo.colormap^[1]^[I];
  1173.       Pal.palPalEntry[I].peBlue := cinfo.colormap^[0]^[I];
  1174.       Pal.palPalEntry[I].peFlags := 0;
  1175.     end;
  1176.   Result := CreatePalette(PLogPalette(@Pal)^);
  1177. end;
  1178.  
  1179. procedure BuildColorMap(var cinfo: jpeg_decompress_struct; P: HPalette);
  1180. var
  1181.   Pal: TMaxLogPalette;
  1182.   Count, I: Integer;
  1183. begin
  1184.   Count := GetPaletteEntries(P, 0, 256, Pal.palPalEntry);
  1185.   if Count = 0 then Exit;       // jpeg_destroy will free colormap
  1186.   cinfo.colormap := cinfo.common.mem.alloc_sarray(@cinfo.common, JPOOL_IMAGE, Count, 3);
  1187.   cinfo.actual_number_of_colors := Count;
  1188.   for I := 0 to Count-1 do
  1189.   begin
  1190.     Byte(cinfo.colormap^[2]^[I]) := Pal.palPalEntry[I].peRed;
  1191.     Byte(cinfo.colormap^[1]^[I]) := Pal.palPalEntry[I].peGreen;
  1192.     Byte(cinfo.colormap^[0]^[I]) := Pal.palPalEntry[I].peBlue;
  1193.   end;
  1194. end;
  1195.  
  1196. function TJPEGImage.GetBitmap: TBitmap;
  1197. var
  1198.   LinesPerCall, LinesRead: Integer;
  1199.   DestScanLine: Pointer;
  1200.   PtrInc: Integer;
  1201.   jc: TJPEGContext;
  1202.   GeneratePalette: Boolean;
  1203. begin
  1204.   Result := FBitmap;
  1205.   if Result <> nil then Exit;
  1206.   if (FBitmap = nil) then FBitmap := TBitmap.Create;
  1207.   Result := FBitmap;
  1208.   GeneratePalette := True;
  1209.  
  1210.   InitDecompressor(Self, jc);
  1211.   try
  1212.     try
  1213.       // Set the bitmap pixel format
  1214.       FBitmap.Handle := 0;
  1215.       if (PixelFormat = jf8Bit) or (jc.d.out_color_space = JCS_GRAYSCALE) then
  1216.         FBitmap.PixelFormat := pf8bit
  1217.       else
  1218.         FBitmap.PixelFormat := pf24bit;
  1219.  
  1220.       Progress(Self, psStarting, 0, False, Rect(0,0,0,0), '');
  1221.       try
  1222.         if (FTempPal <> 0) then
  1223.         begin
  1224.           if (FPixelFormat = jf8Bit) then
  1225.           begin                        // Generate DIB using assigned palette
  1226.             BuildColorMap(jc.d, FTempPal);
  1227.             FBitmap.Palette := CopyPalette(FTempPal);  // Keep FTempPal around
  1228.             GeneratePalette := False;
  1229.           end
  1230.           else
  1231.           begin
  1232.             DeleteObject(FTempPal);
  1233.             FTempPal := 0;
  1234.           end;
  1235.         end;
  1236.  
  1237.         jpeg_start_decompress(jc.d);
  1238.  
  1239.         // Set bitmap width and height
  1240.         with FBitmap do
  1241.         begin
  1242.           Handle := 0;
  1243.           Width := jc.d.output_width;
  1244.           Height := jc.d.output_height;
  1245.           DestScanline := ScanLine[0];
  1246.           PtrInc := Integer(ScanLine[1]) - Integer(DestScanline);
  1247.           if (PtrInc > 0) and ((PtrInc and 3) = 0) then
  1248.              // if no dword padding is required and output bitmap is top-down
  1249.             LinesPerCall := jc.d.rec_outbuf_height // read multiple rows per call
  1250.           else
  1251.             LinesPerCall := 1;            // otherwise read one row at a time
  1252.         end;
  1253.  
  1254.         if jc.d.buffered_image then
  1255.         begin  // decode progressive scans at low quality, high speed
  1256.           while jpeg_consume_input(jc.d) <> JPEG_REACHED_EOI do
  1257.           begin
  1258.             jpeg_start_output(jc.d, jc.d.input_scan_number);
  1259.             // extract color palette
  1260.             if (jc.common.progress^.completed_passes = 0) and (jc.d.colormap <> nil)
  1261.               and (FBitmap.PixelFormat = pf8bit) and GeneratePalette then
  1262.             begin
  1263.               FBitmap.Palette := BuildPalette(jc.d);
  1264.               PaletteModified := True;
  1265.             end;
  1266.             DestScanLine := FBitmap.ScanLine[0];
  1267.             while (jc.d.output_scanline < jc.d.output_height) do
  1268.             begin
  1269.               LinesRead := jpeg_read_scanlines(jc.d, @DestScanline, LinesPerCall);
  1270.               Inc(Integer(DestScanline), PtrInc * LinesRead);
  1271.             end;
  1272.             jpeg_finish_output(jc.d);
  1273.           end;
  1274.           // reset options for final pass at requested quality
  1275.           jc.d.dct_method := jc.FinalDCT;
  1276.           jc.d.dither_mode := jc.FinalDitherMode;
  1277.           if jc.FinalTwoPassQuant then
  1278.           begin
  1279.             jc.d.two_pass_quantize := True;
  1280.             jc.d.colormap := nil;
  1281.           end;
  1282.           jpeg_start_output(jc.d, jc.d.input_scan_number);
  1283.           DestScanLine := FBitmap.ScanLine[0];
  1284.         end;
  1285.  
  1286.         // build final color palette
  1287.         if (not jc.d.buffered_image or jc.FinalTwoPassQuant) and
  1288.           (jc.d.colormap <> nil) and GeneratePalette then
  1289.         begin
  1290.           FBitmap.Palette := BuildPalette(jc.d);
  1291.           PaletteModified := True;
  1292.           DestScanLine := FBitmap.ScanLine[0];
  1293.         end;
  1294.         // final image pass for progressive, first and only pass for baseline
  1295.         while (jc.d.output_scanline < jc.d.output_height) do
  1296.         begin
  1297.           LinesRead := jpeg_read_scanlines(jc.d, @DestScanline, LinesPerCall);
  1298.           Inc(Integer(DestScanline), PtrInc * LinesRead);
  1299.         end;
  1300.  
  1301.         if jc.d.buffered_image then jpeg_finish_output(jc.d);
  1302.         jpeg_finish_decompress(jc.d);
  1303.       finally
  1304.         if ExceptObject = nil then
  1305.           PtrInc := 100
  1306.         else
  1307.           PtrInc := 0;
  1308.         Progress(Self, psEnding, PtrInc, PaletteModified, Rect(0,0,0,0), '');
  1309.         // Make sure new palette gets realized, in case OnProgress event didn't.
  1310.         if PaletteModified then
  1311.           Changed(Self);
  1312.       end;
  1313.     except
  1314.       on EAbort do ;   // OnProgress can raise EAbort to cancel image load
  1315.     end;
  1316.   finally
  1317.     ReleaseContext(jc);
  1318.   end;
  1319. end;
  1320.  
  1321. function TJPEGImage.GetEmpty: Boolean;
  1322. begin
  1323.   Result := (FImage.FData = nil) and ((FBitmap = nil) or FBitmap.Empty);
  1324. end;
  1325.  
  1326. function TJPEGImage.GetGrayscale: Boolean;
  1327. begin
  1328.   Result := FGrayscale or FImage.FGrayscale;
  1329. end;
  1330.  
  1331. function TJPEGImage.GetPalette: HPalette;
  1332. var
  1333.   DC: HDC;
  1334. begin
  1335.   Result := 0;
  1336.   if FBitmap <> nil then
  1337.     Result := FBitmap.Palette
  1338.   else if FTempPal <> 0 then
  1339.     Result := FTempPal
  1340.   else if FPixelFormat = jf24Bit then   // check for 8 bit screen
  1341.   begin
  1342.     DC := GetDC(0);
  1343.     if (GetDeviceCaps(DC, BITSPIXEL) * GetDeviceCaps(DC, PLANES)) <= 8 then
  1344.     begin
  1345.       FTempPal := CreateHalftonePalette(DC);
  1346.       Result := FTempPal;
  1347.     end;
  1348.     ReleaseDC(0, DC);
  1349.   end;
  1350. end;
  1351.  
  1352. function TJPEGImage.GetHeight: Integer;
  1353. begin
  1354.   if FBitmap <> nil then
  1355.     Result := FBitmap.Height
  1356.   else if FScale = jsFullSize then
  1357.     Result := FImage.FHeight
  1358.   else
  1359.   begin
  1360.     CalcOutputDimensions;
  1361.     Result := FScaledHeight;
  1362.   end;
  1363. end;
  1364.  
  1365. function TJPEGImage.GetWidth: Integer;
  1366. begin
  1367.   if FBitmap <> nil then
  1368.     Result := FBitmap.Width
  1369.   else if FScale = jsFullSize then
  1370.     Result := FImage.FWidth
  1371.   else
  1372.   begin
  1373.     CalcOutputDimensions;
  1374.     Result := FScaledWidth;
  1375.   end;
  1376. end;
  1377.  
  1378. procedure TJPEGImage.JPEGNeeded;
  1379. begin
  1380.   if FImage.FData = nil then
  1381.     Compress;
  1382. end;
  1383.  
  1384. procedure TJPEGImage.LoadFromClipboardFormat(AFormat: Word; AData: THandle;
  1385.   APalette: HPALETTE);
  1386. begin
  1387.   //!! check for jpeg clipboard data, mime type image/jpeg
  1388.   FBitmap.LoadFromClipboardFormat(AFormat, AData, APalette);
  1389. end;
  1390.  
  1391. procedure TJPEGImage.LoadFromStream(Stream: TStream);
  1392. begin
  1393.   ReadStream(Stream.Size - Stream.Position, Stream);
  1394. end;
  1395.  
  1396. procedure TJPEGImage.NewBitmap;
  1397. begin
  1398.   FBitmap.Free;
  1399.   FBitmap := TBitmap.Create;
  1400. end;
  1401.  
  1402. procedure TJPEGImage.NewImage;
  1403. begin
  1404.   if FImage <> nil then FImage.Release;
  1405.   FImage := TJPEGData.Create;
  1406.   FImage.Reference;
  1407. end;
  1408.  
  1409. procedure TJPEGImage.ReadData(Stream: TStream);
  1410. var
  1411.   Size: Longint;
  1412. begin
  1413.   Stream.Read(Size, SizeOf(Size));
  1414.   ReadStream(Size, Stream);
  1415. end;
  1416.  
  1417. procedure TJPEGImage.ReadStream(Size: Longint; Stream: TStream);
  1418. var
  1419.   jerr: jpeg_error_mgr;
  1420.   cinfo: jpeg_decompress_struct;
  1421. begin
  1422.   NewImage;
  1423.   FBitmap.Free;
  1424.   FBitmap := nil;
  1425.   with FImage do
  1426.   begin
  1427.     FData := TMemoryStream.Create;
  1428.     FData.Size := Size;
  1429.     Stream.ReadBuffer(FData.Memory^, Size);
  1430.     if Size > 0 then
  1431.     begin
  1432.       jerr := jpeg_std_error;  // use local var for thread isolation
  1433.       cinfo.common.err := @jerr;
  1434.       jpeg_CreateDecompress(cinfo, JPEG_LIB_VERSION, sizeof(cinfo));
  1435.       try
  1436.         FData.Position := 0;
  1437.         jpeg_stdio_src(cinfo, FData);
  1438.         jpeg_read_header(cinfo, TRUE);
  1439.         FWidth := cinfo.image_width;
  1440.         FHeight := cinfo.image_height;
  1441.         FGrayscale := cinfo.jpeg_color_space = JCS_GRAYSCALE;
  1442.         FProgressiveEncoding := jpeg_has_multiple_scans(cinfo);
  1443.       finally
  1444.         jpeg_destroy_decompress(cinfo);
  1445.       end;
  1446.     end;
  1447.   end;
  1448.   PaletteModified := True;
  1449.   Changed(Self);
  1450. end;
  1451.  
  1452. procedure TJPEGImage.SaveToClipboardFormat(var AFormat: Word; var AData: THandle;
  1453.   var APalette: HPALETTE);
  1454. begin
  1455. //!!  check for jpeg clipboard format, mime type image/jpeg
  1456.   Bitmap.SaveToClipboardFormat(AFormat, AData, APalette);
  1457. end;
  1458.  
  1459. procedure TJPEGImage.SaveToStream(Stream: TStream);
  1460. begin
  1461.   JPEGNeeded;
  1462.   with FImage.FData do
  1463.     Stream.Write(Memory^, Size);
  1464. end;
  1465.  
  1466. procedure TJPEGImage.SetGrayscale(Value: Boolean);
  1467. begin
  1468.   if FGrayscale <> Value then
  1469.   begin
  1470.     FreeBitmap;
  1471.     FGrayscale := Value;
  1472.     PaletteModified := True;
  1473.     Changed(Self);
  1474.   end;
  1475. end;
  1476.  
  1477. procedure TJPEGImage.SetHeight(Value: Integer);
  1478. begin
  1479.   InvalidOperation(SChangeJPGSize);
  1480. end;
  1481.  
  1482. procedure TJPEGImage.SetPalette(Value: HPalette);
  1483. var
  1484.   SignalChange: Boolean;
  1485. begin
  1486.   if Value <> FTempPal then
  1487.   begin
  1488.     SignalChange := (FBitmap <> nil) and (Value <> FBitmap.Palette);
  1489.     if SignalChange then FreeBitmap;
  1490.     if FTempPal <> 0 then DeleteObject(FTempPal);
  1491.     FTempPal := Value;
  1492.     if SignalChange then
  1493.     begin
  1494.       PaletteModified := True;
  1495.       Changed(Self);
  1496.     end;
  1497.   end;
  1498. end;
  1499.  
  1500. procedure TJPEGImage.SetPerformance(Value: TJPEGPerformance);
  1501. begin
  1502.   if FPerformance <> Value then
  1503.   begin
  1504.     FreeBitmap;
  1505.     FPerformance := Value;
  1506.     PaletteModified := True;
  1507.     Changed(Self);
  1508.   end;
  1509. end;
  1510.  
  1511. procedure TJPEGImage.SetPixelFormat(Value: TJPEGPixelFormat);
  1512. begin
  1513.   if FPixelFormat <> Value then
  1514.   begin
  1515.     FreeBitmap;
  1516.     FPixelFormat := Value;
  1517.     PaletteModified := True;
  1518.     Changed(Self);
  1519.   end;
  1520. end;
  1521.  
  1522. procedure TJPEGImage.SetScale(Value: TJPEGScale);
  1523. begin
  1524.   if FScale <> Value then
  1525.   begin
  1526.     FreeBitmap;
  1527.     FScale := Value;
  1528.     FNeedRecalc := True;
  1529.     Changed(Self);
  1530.   end;
  1531. end;
  1532.  
  1533. procedure TJPEGImage.SetSmoothing(Value: Boolean);
  1534. begin
  1535.   if FSmoothing <> Value then
  1536.   begin
  1537.     FreeBitmap;
  1538.     FSmoothing := Value;
  1539.     Changed(Self);
  1540.   end;
  1541. end;
  1542.  
  1543. procedure TJPEGImage.SetWidth(Value: Integer);
  1544. begin
  1545.   InvalidOperation(SChangeJPGSize);
  1546. end;
  1547.  
  1548. procedure TJPEGImage.WriteData(Stream: TStream);
  1549. var
  1550.   Size: Longint;
  1551. begin
  1552.   Size := 0;
  1553.   if Assigned(FImage.FData) then Size := FImage.FData.Size;
  1554.   Stream.Write(Size, Sizeof(Size));
  1555.   if Size > 0 then Stream.Write(FImage.FData.Memory^, Size);
  1556. end;
  1557.  
  1558. procedure InitDefaults;
  1559. var
  1560.   DC: HDC;
  1561. begin
  1562.   DC := GetDC(0);
  1563.   if (GetDeviceCaps(DC, BITSPIXEL) * GetDeviceCaps(DC, PLANES)) <= 8 then
  1564.     JPEGDefaults.PixelFormat := jf8Bit
  1565.   else
  1566.     JPEGDefaults.PixelFormat := jf24Bit;
  1567.   ReleaseDC(0, DC);
  1568. end;
  1569.  
  1570. initialization
  1571.   InitDefaults;
  1572.   TPicture.RegisterFileFormat('jpeg', sJPEGImageFile, TJPEGImage);
  1573.   TPicture.RegisterFileFormat('jpg', sJPEGImageFile, TJPEGImage);
  1574. finalization
  1575.   TPicture.UnregisterGraphicClass(TJPEGImage);
  1576. end.
  1577.  
  1578.  
  1579.