402 lines
13 KiB
Plaintext
402 lines
13 KiB
Plaintext
unit imjcapimin;
|
|
{$N+}
|
|
{ This file contains application interface code for the compression half
|
|
of the JPEG library. These are the "minimum" API routines that may be
|
|
needed in either the normal full-compression case or the transcoding-only
|
|
case.
|
|
|
|
Most of the routines intended to be called directly by an application
|
|
are in this file or in jcapistd.c. But also see jcparam.c for
|
|
parameter-setup helper routines, jcomapi.c for routines shared by
|
|
compression and decompression, and jctrans.c for the transcoding case. }
|
|
|
|
{ jcapimin.c ; Copyright (C) 1994-1998, Thomas G. Lane. }
|
|
|
|
|
|
interface
|
|
|
|
{$I imjconfig.inc}
|
|
|
|
uses
|
|
imjmorecfg,
|
|
imjinclude,
|
|
imjdeferr,
|
|
imjerror,
|
|
imjpeglib,
|
|
imjcomapi,
|
|
imjmemmgr,
|
|
imjcmarker;
|
|
|
|
{ Initialization of JPEG compression objects.
|
|
Nomssi: This is a macro in the original code.
|
|
|
|
jpeg_create_compress() and jpeg_create_decompress() are the exported
|
|
names that applications should call. These expand to calls on
|
|
jpeg_CreateCompress and jpeg_CreateDecompress with additional information
|
|
passed for version mismatch checking.
|
|
NB: you must set up the error-manager BEFORE calling jpeg_create_xxx. }
|
|
|
|
procedure jpeg_create_compress(cinfo : j_compress_ptr);
|
|
|
|
|
|
{ Initialization of a JPEG compression object.
|
|
The error manager must already be set up (in case memory manager fails). }
|
|
|
|
{GLOBAL}
|
|
procedure jpeg_CreateCompress (cinfo : j_compress_ptr;
|
|
version : int;
|
|
structsize : size_t);
|
|
|
|
{ Destruction of a JPEG compression object }
|
|
|
|
{GLOBAL}
|
|
procedure jpeg_destroy_compress (cinfo : j_compress_ptr);
|
|
|
|
|
|
{ Abort processing of a JPEG compression operation,
|
|
but don't destroy the object itself. }
|
|
|
|
{GLOBAL}
|
|
procedure jpeg_abort_compress (cinfo : j_compress_ptr);
|
|
|
|
|
|
{ Forcibly suppress or un-suppress all quantization and Huffman tables.
|
|
Marks all currently defined tables as already written (if suppress)
|
|
or not written (if !suppress). This will control whether they get emitted
|
|
by a subsequent jpeg_start_compress call.
|
|
|
|
This routine is exported for use by applications that want to produce
|
|
abbreviated JPEG datastreams. It logically belongs in jcparam.c, but
|
|
since it is called by jpeg_start_compress, we put it here --- otherwise
|
|
jcparam.o would be linked whether the application used it or not. }
|
|
|
|
{GLOBAL}
|
|
procedure jpeg_suppress_tables (cinfo : j_compress_ptr;
|
|
suppress : boolean);
|
|
|
|
|
|
{ Finish JPEG compression.
|
|
|
|
If a multipass operating mode was selected, this may do a great deal of
|
|
work including most of the actual output. }
|
|
|
|
{GLOBAL}
|
|
procedure jpeg_finish_compress (cinfo : j_compress_ptr);
|
|
|
|
{ Write a special marker.
|
|
This is only recommended for writing COM or APPn markers.
|
|
Must be called after jpeg_start_compress() and before
|
|
first call to jpeg_write_scanlines() or jpeg_write_raw_data(). }
|
|
|
|
{GLOBAL}
|
|
procedure jpeg_write_marker (cinfo : j_compress_ptr;
|
|
marker : int;
|
|
dataptr : JOCTETptr;
|
|
datalen : uInt);
|
|
|
|
{GLOBAL}
|
|
procedure jpeg_write_m_header (cinfo : j_compress_ptr;
|
|
marker : int;
|
|
datalen : uint);
|
|
{GLOBAL}
|
|
procedure jpeg_write_m_byte (cinfo : j_compress_ptr; val : int);
|
|
|
|
{ Alternate compression function: just write an abbreviated table file.
|
|
Before calling this, all parameters and a data destination must be set up.
|
|
|
|
To produce a pair of files containing abbreviated tables and abbreviated
|
|
image data, one would proceed as follows:
|
|
|
|
initialize JPEG object
|
|
set JPEG parameters
|
|
set destination to table file
|
|
jpeg_write_tables(cinfo);
|
|
set destination to image file
|
|
jpeg_start_compress(cinfo, FALSE);
|
|
write data...
|
|
jpeg_finish_compress(cinfo);
|
|
|
|
jpeg_write_tables has the side effect of marking all tables written
|
|
(same as jpeg_suppress_tables(..., TRUE)). Thus a subsequent start_compress
|
|
will not re-emit the tables unless it is passed write_all_tables=TRUE. }
|
|
|
|
|
|
|
|
{GLOBAL}
|
|
procedure jpeg_write_tables (cinfo : j_compress_ptr);
|
|
|
|
implementation
|
|
|
|
procedure jpeg_create_compress(cinfo : j_compress_ptr);
|
|
begin
|
|
jpeg_CreateCompress(cinfo, JPEG_LIB_VERSION,
|
|
size_t(sizeof(jpeg_compress_struct)));
|
|
end;
|
|
|
|
{ Initialization of a JPEG compression object.
|
|
The error manager must already be set up (in case memory manager fails). }
|
|
|
|
{GLOBAL}
|
|
procedure jpeg_CreateCompress (cinfo : j_compress_ptr;
|
|
version : int;
|
|
structsize : size_t);
|
|
var
|
|
i : int;
|
|
var
|
|
err : jpeg_error_mgr_ptr;
|
|
client_data : voidp;
|
|
begin
|
|
|
|
{ Guard against version mismatches between library and caller. }
|
|
cinfo^.mem := NIL; { so jpeg_destroy knows mem mgr not called }
|
|
if (version <> JPEG_LIB_VERSION) then
|
|
ERREXIT2(j_common_ptr(cinfo), JERR_BAD_LIB_VERSION, JPEG_LIB_VERSION, version);
|
|
if (structsize <> SIZEOF(jpeg_compress_struct)) then
|
|
ERREXIT2(j_common_ptr(cinfo), JERR_BAD_STRUCT_SIZE,
|
|
int(SIZEOF(jpeg_compress_struct)), int(structsize));
|
|
|
|
{ For debugging purposes, we zero the whole master structure.
|
|
But the application has already set the err pointer, and may have set
|
|
client_data, so we have to save and restore those fields.
|
|
Note: if application hasn't set client_data, tools like Purify may
|
|
complain here. }
|
|
|
|
err := cinfo^.err;
|
|
client_data := cinfo^.client_data; { ignore Purify complaint here }
|
|
MEMZERO(cinfo, SIZEOF(jpeg_compress_struct));
|
|
cinfo^.err := err;
|
|
cinfo^.is_decompressor := FALSE;
|
|
|
|
{ Initialize a memory manager instance for this object }
|
|
jinit_memory_mgr(j_common_ptr(cinfo));
|
|
|
|
{ Zero out pointers to permanent structures. }
|
|
cinfo^.progress := NIL;
|
|
cinfo^.dest := NIL;
|
|
|
|
cinfo^.comp_info := NIL;
|
|
|
|
for i := 0 to pred(NUM_QUANT_TBLS) do
|
|
cinfo^.quant_tbl_ptrs[i] := NIL;
|
|
|
|
for i := 0 to pred(NUM_HUFF_TBLS) do
|
|
begin
|
|
cinfo^.dc_huff_tbl_ptrs[i] := NIL;
|
|
cinfo^.ac_huff_tbl_ptrs[i] := NIL;
|
|
end;
|
|
|
|
cinfo^.script_space := NIL;
|
|
|
|
cinfo^.input_gamma := 1.0; { in case application forgets }
|
|
|
|
{ OK, I'm ready }
|
|
cinfo^.global_state := CSTATE_START;
|
|
end;
|
|
|
|
|
|
{ Destruction of a JPEG compression object }
|
|
|
|
{GLOBAL}
|
|
procedure jpeg_destroy_compress (cinfo : j_compress_ptr);
|
|
begin
|
|
jpeg_destroy(j_common_ptr(cinfo)); { use common routine }
|
|
end;
|
|
|
|
|
|
{ Abort processing of a JPEG compression operation,
|
|
but don't destroy the object itself. }
|
|
|
|
{GLOBAL}
|
|
procedure jpeg_abort_compress (cinfo : j_compress_ptr);
|
|
begin
|
|
jpeg_abort(j_common_ptr(cinfo)); { use common routine }
|
|
end;
|
|
|
|
|
|
{ Forcibly suppress or un-suppress all quantization and Huffman tables.
|
|
Marks all currently defined tables as already written (if suppress)
|
|
or not written (if !suppress). This will control whether they get emitted
|
|
by a subsequent jpeg_start_compress call.
|
|
|
|
This routine is exported for use by applications that want to produce
|
|
abbreviated JPEG datastreams. It logically belongs in jcparam.c, but
|
|
since it is called by jpeg_start_compress, we put it here --- otherwise
|
|
jcparam.o would be linked whether the application used it or not. }
|
|
|
|
{GLOBAL}
|
|
procedure jpeg_suppress_tables (cinfo : j_compress_ptr;
|
|
suppress : boolean);
|
|
var
|
|
i : int;
|
|
qtbl : JQUANT_TBL_PTR;
|
|
htbl : JHUFF_TBL_PTR;
|
|
begin
|
|
for i := 0 to pred(NUM_QUANT_TBLS) do
|
|
begin
|
|
qtbl := cinfo^.quant_tbl_ptrs[i];
|
|
if (qtbl <> NIL) then
|
|
qtbl^.sent_table := suppress;
|
|
end;
|
|
|
|
for i := 0 to pred(NUM_HUFF_TBLS) do
|
|
begin
|
|
htbl := cinfo^.dc_huff_tbl_ptrs[i];
|
|
if (htbl <> NIL) then
|
|
htbl^.sent_table := suppress;
|
|
htbl := cinfo^.ac_huff_tbl_ptrs[i];
|
|
if (htbl <> NIL) then
|
|
htbl^.sent_table := suppress;
|
|
end;
|
|
end;
|
|
|
|
|
|
{ Finish JPEG compression.
|
|
|
|
If a multipass operating mode was selected, this may do a great deal of
|
|
work including most of the actual output. }
|
|
|
|
{GLOBAL}
|
|
procedure jpeg_finish_compress (cinfo : j_compress_ptr);
|
|
var
|
|
iMCU_row : JDIMENSION;
|
|
begin
|
|
if (cinfo^.global_state = CSTATE_SCANNING) or
|
|
(cinfo^.global_state = CSTATE_RAW_OK) then
|
|
begin
|
|
{ Terminate first pass }
|
|
if (cinfo^.next_scanline < cinfo^.image_height) then
|
|
ERREXIT(j_common_ptr(cinfo), JERR_TOO_LITTLE_DATA);
|
|
cinfo^.master^.finish_pass (cinfo);
|
|
end
|
|
else
|
|
if (cinfo^.global_state <> CSTATE_WRCOEFS) then
|
|
ERREXIT1(j_common_ptr(cinfo), JERR_BAD_STATE, cinfo^.global_state);
|
|
{ Perform any remaining passes }
|
|
while (not cinfo^.master^.is_last_pass) do
|
|
begin
|
|
cinfo^.master^.prepare_for_pass (cinfo);
|
|
for iMCU_row := 0 to pred(cinfo^.total_iMCU_rows) do
|
|
begin
|
|
if (cinfo^.progress <> NIL) then
|
|
begin
|
|
cinfo^.progress^.pass_counter := long (iMCU_row);
|
|
cinfo^.progress^.pass_limit := long (cinfo^.total_iMCU_rows);
|
|
cinfo^.progress^.progress_monitor (j_common_ptr(cinfo));
|
|
end;
|
|
{ We bypass the main controller and invoke coef controller directly;
|
|
all work is being done from the coefficient buffer. }
|
|
|
|
if (not cinfo^.coef^.compress_data (cinfo, JSAMPIMAGE(NIL))) then
|
|
ERREXIT(j_common_ptr(cinfo), JERR_CANT_SUSPEND);
|
|
end;
|
|
cinfo^.master^.finish_pass (cinfo);
|
|
end;
|
|
{ Write EOI, do final cleanup }
|
|
cinfo^.marker^.write_file_trailer (cinfo);
|
|
cinfo^.dest^.term_destination (cinfo);
|
|
{ We can use jpeg_abort to release memory and reset global_state }
|
|
jpeg_abort(j_common_ptr(cinfo));
|
|
end;
|
|
|
|
|
|
{ Write a special marker.
|
|
This is only recommended for writing COM or APPn markers.
|
|
Must be called after jpeg_start_compress() and before
|
|
first call to jpeg_write_scanlines() or jpeg_write_raw_data(). }
|
|
|
|
{GLOBAL}
|
|
procedure jpeg_write_marker (cinfo : j_compress_ptr;
|
|
marker : int;
|
|
dataptr : JOCTETptr;
|
|
datalen : uInt);
|
|
var
|
|
write_marker_byte : procedure(info : j_compress_ptr; val : int);
|
|
begin
|
|
if (cinfo^.next_scanline <> 0) or
|
|
((cinfo^.global_state <> CSTATE_SCANNING) and
|
|
(cinfo^.global_state <> CSTATE_RAW_OK) and
|
|
(cinfo^.global_state <> CSTATE_WRCOEFS)) then
|
|
ERREXIT1(j_common_ptr(cinfo), JERR_BAD_STATE, cinfo^.global_state);
|
|
|
|
cinfo^.marker^.write_marker_header (cinfo, marker, datalen);
|
|
write_marker_byte := cinfo^.marker^.write_marker_byte; { copy for speed }
|
|
while (datalen <> 0) do
|
|
begin
|
|
Dec(datalen);
|
|
write_marker_byte (cinfo, dataptr^);
|
|
Inc(dataptr);
|
|
end;
|
|
end;
|
|
|
|
{ Same, but piecemeal. }
|
|
|
|
{GLOBAL}
|
|
procedure jpeg_write_m_header (cinfo : j_compress_ptr;
|
|
marker : int;
|
|
datalen : uint);
|
|
begin
|
|
if (cinfo^.next_scanline <> 0) or
|
|
((cinfo^.global_state <> CSTATE_SCANNING) and
|
|
(cinfo^.global_state <> CSTATE_RAW_OK) and
|
|
(cinfo^.global_state <> CSTATE_WRCOEFS)) then
|
|
ERREXIT1(j_common_ptr(cinfo), JERR_BAD_STATE, cinfo^.global_state);
|
|
|
|
cinfo^.marker^.write_marker_header (cinfo, marker, datalen);
|
|
end;
|
|
|
|
{GLOBAL}
|
|
procedure jpeg_write_m_byte (cinfo : j_compress_ptr; val : int);
|
|
begin
|
|
cinfo^.marker^.write_marker_byte (cinfo, val);
|
|
end;
|
|
|
|
|
|
{ Alternate compression function: just write an abbreviated table file.
|
|
Before calling this, all parameters and a data destination must be set up.
|
|
|
|
To produce a pair of files containing abbreviated tables and abbreviated
|
|
image data, one would proceed as follows:
|
|
|
|
initialize JPEG object
|
|
set JPEG parameters
|
|
set destination to table file
|
|
jpeg_write_tables(cinfo);
|
|
set destination to image file
|
|
jpeg_start_compress(cinfo, FALSE);
|
|
write data...
|
|
jpeg_finish_compress(cinfo);
|
|
|
|
jpeg_write_tables has the side effect of marking all tables written
|
|
(same as jpeg_suppress_tables(..., TRUE)). Thus a subsequent start_compress
|
|
will not re-emit the tables unless it is passed write_all_tables=TRUE. }
|
|
|
|
{GLOBAL}
|
|
procedure jpeg_write_tables (cinfo : j_compress_ptr);
|
|
begin
|
|
if (cinfo^.global_state <> CSTATE_START) then
|
|
ERREXIT1(j_common_ptr(cinfo), JERR_BAD_STATE, cinfo^.global_state);
|
|
|
|
{ (Re)initialize error mgr and destination modules }
|
|
cinfo^.err^.reset_error_mgr (j_common_ptr(cinfo));
|
|
cinfo^.dest^.init_destination (cinfo);
|
|
{ Initialize the marker writer ... bit of a crock to do it here. }
|
|
jinit_marker_writer(cinfo);
|
|
{ Write them tables! }
|
|
cinfo^.marker^.write_tables_only (cinfo);
|
|
{ And clean up. }
|
|
cinfo^.dest^.term_destination (cinfo);
|
|
|
|
{ In library releases up through v6a, we called jpeg_abort() here to free
|
|
any working memory allocated by the destination manager and marker
|
|
writer. Some applications had a problem with that: they allocated space
|
|
of their own from the library memory manager, and didn't want it to go
|
|
away during write_tables. So now we do nothing. This will cause a
|
|
memory leak if an app calls write_tables repeatedly without doing a full
|
|
compression cycle or otherwise resetting the JPEG object. However, that
|
|
seems less bad than unexpectedly freeing memory in the normal case.
|
|
An app that prefers the old behavior can call jpeg_abort for itself after
|
|
each call to jpeg_write_tables(). }
|
|
end;
|
|
|
|
end.
|