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