|
|
unit imjcapistd;
{ Original : jcapistd.c ; Copyright (C) 1994-1996, Thomas G. Lane. }
{ This file is part of the Independent JPEG Group's software. For conditions of distribution and use, see the accompanying README file.
This file contains application interface code for the compression half of the JPEG library. These are the "standard" API routines that are used in the normal full-compression case. They are not used by a transcoding-only application. Note that if an application links in jpeg_start_compress, it will end up linking in the entire compressor. We thus must separate this file from jcapimin.c to avoid linking the whole compression library into a transcoder. }
interface
{$I imjconfig.inc}
uses imjmorecfg, imjinclude, imjdeferr, imjerror, imjpeglib, imjcapimin, imjcinit;
{ Compression initialization. Before calling this, all parameters and a data destination must be set up.
We require a write_all_tables parameter as a failsafe check when writing multiple datastreams from the same compression object. Since prior runs will have left all the tables marked sent_table=TRUE, a subsequent run would emit an abbreviated stream (no tables) by default. This may be what is wanted, but for safety's sake it should not be the default behavior: programmers should have to make a deliberate choice to emit abbreviated images. Therefore the documentation and examples should encourage people to pass write_all_tables=TRUE; then it will take active thought to do the wrong thing. }
{GLOBAL}procedure jpeg_start_compress (cinfo : j_compress_ptr; write_all_tables : boolean);
{ Write some scanlines of data to the JPEG compressor.
The return value will be the number of lines actually written. This should be less than the supplied num_lines only in case that the data destination module has requested suspension of the compressor, or if more than image_height scanlines are passed in.
Note: we warn about excess calls to jpeg_write_scanlines() since this likely signals an application programmer error. However, excess scanlines passed in the last valid call are *silently* ignored, so that the application need not adjust num_lines for end-of-image when using a multiple-scanline buffer. }
{GLOBAL}function jpeg_write_scanlines (cinfo : j_compress_ptr; scanlines : JSAMPARRAY; num_lines : JDIMENSION) : JDIMENSION;
{ Alternate entry point to write raw data. Processes exactly one iMCU row per call, unless suspended. }
{GLOBAL}function jpeg_write_raw_data (cinfo : j_compress_ptr; data : JSAMPIMAGE; num_lines : JDIMENSION) : JDIMENSION;
implementation
{ Compression initialization. Before calling this, all parameters and a data destination must be set up.
We require a write_all_tables parameter as a failsafe check when writing multiple datastreams from the same compression object. Since prior runs will have left all the tables marked sent_table=TRUE, a subsequent run would emit an abbreviated stream (no tables) by default. This may be what is wanted, but for safety's sake it should not be the default behavior: programmers should have to make a deliberate choice to emit abbreviated images. Therefore the documentation and examples should encourage people to pass write_all_tables=TRUE; then it will take active thought to do the wrong thing. }
{GLOBAL}procedure jpeg_start_compress (cinfo : j_compress_ptr; write_all_tables : boolean);begin if (cinfo^.global_state <> CSTATE_START) then ERREXIT1(j_common_ptr(cinfo), JERR_BAD_STATE, cinfo^.global_state);
if (write_all_tables) then jpeg_suppress_tables(cinfo, FALSE); { mark all tables to be written }
{ (Re)initialize error mgr and destination modules } cinfo^.err^.reset_error_mgr (j_common_ptr(cinfo)); cinfo^.dest^.init_destination (cinfo); { Perform master selection of active modules } jinit_compress_master(cinfo); { Set up for the first pass } cinfo^.master^.prepare_for_pass (cinfo); { Ready for application to drive first pass through jpeg_write_scanlines or jpeg_write_raw_data. }
cinfo^.next_scanline := 0; if cinfo^.raw_data_in then cinfo^.global_state := CSTATE_RAW_OK else cinfo^.global_state := CSTATE_SCANNING;end;
{ Write some scanlines of data to the JPEG compressor.
The return value will be the number of lines actually written. This should be less than the supplied num_lines only in case that the data destination module has requested suspension of the compressor, or if more than image_height scanlines are passed in.
Note: we warn about excess calls to jpeg_write_scanlines() since this likely signals an application programmer error. However, excess scanlines passed in the last valid call are *silently* ignored, so that the application need not adjust num_lines for end-of-image when using a multiple-scanline buffer. }
{GLOBAL}function jpeg_write_scanlines (cinfo : j_compress_ptr; scanlines : JSAMPARRAY; num_lines : JDIMENSION) : JDIMENSION;var row_ctr, rows_left : JDIMENSION;begin if (cinfo^.global_state <> CSTATE_SCANNING) then ERREXIT1(j_common_ptr(cinfo), JERR_BAD_STATE, cinfo^.global_state); if (cinfo^.next_scanline >= cinfo^.image_height) then WARNMS(j_common_ptr(cinfo), JWRN_TOO_MUCH_DATA);
{ Call progress monitor hook if present } if (cinfo^.progress <> NIL) then begin cinfo^.progress^.pass_counter := long (cinfo^.next_scanline); cinfo^.progress^.pass_limit := long (cinfo^.image_height); cinfo^.progress^.progress_monitor (j_common_ptr(cinfo)); end;
{ Give master control module another chance if this is first call to jpeg_write_scanlines. This lets output of the frame/scan headers be delayed so that application can write COM, etc, markers between jpeg_start_compress and jpeg_write_scanlines. } if (cinfo^.master^.call_pass_startup) then cinfo^.master^.pass_startup (cinfo);
{ Ignore any extra scanlines at bottom of image. } rows_left := cinfo^.image_height - cinfo^.next_scanline; if (num_lines > rows_left) then num_lines := rows_left;
row_ctr := 0; cinfo^.main^.process_data (cinfo, scanlines, {var}row_ctr, num_lines); Inc(cinfo^.next_scanline, row_ctr); jpeg_write_scanlines := row_ctr;end;
{ Alternate entry point to write raw data. Processes exactly one iMCU row per call, unless suspended. }
{GLOBAL}function jpeg_write_raw_data (cinfo : j_compress_ptr; data : JSAMPIMAGE; num_lines : JDIMENSION) : JDIMENSION;var lines_per_iMCU_row : JDIMENSION;begin if (cinfo^.global_state <> CSTATE_RAW_OK) then ERREXIT1(j_common_ptr(cinfo), JERR_BAD_STATE, cinfo^.global_state); if (cinfo^.next_scanline >= cinfo^.image_height) then begin WARNMS(j_common_ptr(cinfo), JWRN_TOO_MUCH_DATA); jpeg_write_raw_data := 0; exit; end;
{ Call progress monitor hook if present } if (cinfo^.progress <> NIL) then begin cinfo^.progress^.pass_counter := long(cinfo^.next_scanline); cinfo^.progress^.pass_limit := long(cinfo^.image_height); cinfo^.progress^.progress_monitor (j_common_ptr(cinfo)); end;
{ Give master control module another chance if this is first call to jpeg_write_raw_data. This lets output of the frame/scan headers be delayed so that application can write COM, etc, markers between jpeg_start_compress and jpeg_write_raw_data. }
if (cinfo^.master^.call_pass_startup) then cinfo^.master^.pass_startup (cinfo);
{ Verify that at least one iMCU row has been passed. } lines_per_iMCU_row := cinfo^.max_v_samp_factor * DCTSIZE; if (num_lines < lines_per_iMCU_row) then ERREXIT(j_common_ptr(cinfo), JERR_BUFFER_SIZE);
{ Directly compress the row. } if (not cinfo^.coef^.compress_data (cinfo, data)) then begin { If compressor did not consume the whole row, suspend processing. } jpeg_write_raw_data := 0; exit; end;
{ OK, we processed one iMCU row. } Inc(cinfo^.next_scanline, lines_per_iMCU_row); jpeg_write_raw_data := lines_per_iMCU_row;end;
end.
|
