The Independent JPEG Group's JPEG software v3

This commit is contained in:
Thomas G. Lane 1992-03-17 00:00:00 +00:00 committed by DRC
parent bd543f030e
commit 4a6b730364
81 changed files with 7327 additions and 2454 deletions

View File

@ -1,5 +1,45 @@
CHANGELOG for Independent JPEG Group's JPEG software
Version 3 17-Mar-92
--------------------
Memory manager is finally capable of swapping to temp files. There are
separate versions of jmemsys.c for no temp files (same behavior as older
versions), simple temp files with or without tmpfile(), and a DOS-specific
version (including special code for EMS and XMS). This is probably much more
system-dependent than any of the older code; some bugs may surface here.
Hooks added for user interface to install progress monitoring routine
(percent-done bar, etc). See comments with dummy progress_monitor
routines in jcdeflts.c, jddeflts.c.
Two-pass color quantization (finally!). This is now the default method when
quantizing; say '-1' to djpeg for quick-and-ugly 1-pass method. There is
a test file for checking 2-pass quantization and GIF output.
Fixed bug in jcopy_block_row that broke cjpeg -o option and djpeg -b option
on MSDOS machines.
Miscellaneous small speedups; notably, DCT computation rearranged so that
GCC "inline" feature is no longer needed for good code quality.
File config.c renamed ckconfig.c to avoid name conflict with /etc/config
on Unix systems.
Added example.c to document usage of JPEG subroutines better.
Memory manager now knows how to release all storage during error exit ---
avoids memory leak when using JPEG as subroutines. This implies a couple
small changes to the subroutine interface: the old free_defaults subroutines
are no longer needed, but if you have a replacement error_exit method then it
must call the new free_all method. Also, jselvirtmem renamed to jselmemmgr.
Code for reading Targa files with 32-bit pixels was incorrect.
Colorspace conversion slightly faster and more accurate; because of
this, old "test" files will no longer match bit-for-bit.
Version 2 13-Dec-91
--------------------

119
README
View File

@ -1,10 +1,10 @@
The Independent JPEG Group's JPEG software
==========================================
README for release 2 of 13-Dec-91
=================================
README for release 3 of 17-Mar-92
==================================
This distribution contains the second public release of the Independent JPEG
This distribution contains the third official release of the Independent JPEG
Group's free JPEG software. You are welcome to redistribute this software and
to use it for any purpose, subject to the conditions under LEGAL ISSUES, below.
@ -12,8 +12,8 @@ For installation instructions, see file SETUP; for usage instructions, see
file USAGE (or the cjpeg.1 and djpeg.1 manual pages).
This software is still undergoing revision. Updated versions may be obtained
by FTP or UUCP to uunet.uu.net and other archive sites; see ARCHIVE LOCATIONS
below for details.
by FTP or UUCP to UUNET and other archive sites; see ARCHIVE LOCATIONS below
for details.
If you intend to become a serious user of this software, please contact
jpeg-info@uunet.uu.net to be added to our electronic mailing list. Then
@ -21,7 +21,7 @@ you'll be notified of updates and have a chance to participate in discussions,
etc.
This software is the work of Tom Lane, Philip Gladstone, Luis Ortiz,
Lee Crocker, and other members of the Independent JPEG Group.
Lee Crocker, Ge' Weijers, and other members of the Independent JPEG Group.
DISCLAIMER
@ -38,7 +38,7 @@ Please report any problems with this software to jpeg-info@uunet.uu.net.
WHAT'S HERE
===========
This distribution contains software to implement JPEG image compression and
This distribution contains C software to implement JPEG image compression and
decompression. JPEG (pronounced "jay-peg") is a standardized compression
method for full-color and gray-scale images. JPEG is intended for
"real-world" scenes; cartoons and other non-realistic images are not its
@ -55,9 +55,9 @@ processes. Provision is made for supporting all variants of these processes,
although some uncommon parameter settings aren't implemented yet. For legal
reasons, we are not distributing code for the arithmetic-coding process; see
LEGAL ISSUES. At present we have made no provision for supporting the
progressive or lossless processes defined in the standard.
progressive, hierarchical, or lossless processes defined in the standard.
The present software is still largely in the prototype stage. It does not
The present software is not far beyond the prototype stage. It does not
support all possible variants of the JPEG standard, and some functions have
rather slow and/or crude implementations. However, it is useful already.
@ -71,7 +71,7 @@ This software can be used on several levels:
* As canned software for JPEG compression and decompression. Just edit the
Makefile and configuration files as needed (see file SETUP), compile and go.
Members of the independent JPEG group will improve the out-of-the-box
Members of the Independent JPEG Group will improve the out-of-the-box
functionality and speed as time goes on.
* As the basis for other JPEG programs. For example, you could incorporate
@ -89,17 +89,17 @@ This software can be used on several levels:
decompressor module. You'd probably also want to extend the user interface
to give you more detailed control over the JPEG compression parameters.
In particular, we welcome the use of this software as the basis for commercial
In particular, we welcome the use of this software as a component of commercial
products; no royalty is required.
ARCHIVE LOCATIONS
=================
The "official" archive site for this software is uunet.uu.net (Internet
address 137.39.1.2 or 192.48.96.2). The most recent released version can
The "official" archive site for this software is ftp.uu.net (Internet
address 137.39.1.9 or 192.48.96.9). The most recent released version can
always be found there in directory graphics/jpeg. This particular version
will be archived as jpegsrc.v2.tar.Z. If you are on the Internet, you can
will be archived as jpegsrc.v3.tar.Z. If you are on the Internet, you can
retrieve files from UUNET by anonymous FTP. If you don't have FTP access,
UUNET's archives are also available via UUCP; contact postmaster@uunet.uu.net
for information on retrieving files that way.
@ -109,7 +109,7 @@ may not be up-to-date. In Europe, try nic.funet.fi (128.214.6.100; look in
directory pub/graphics/programs/jpeg).
You can also obtain this software from CompuServe, in the GRAPHSUPPORT forum
(GO PICS), library 10; this version will be file jpsrc2.zip.
(GO PICS), library 10; this version will be file jpsrc3.zip.
If you are not reasonably handy at configuring and installing portable C
programs, you may have some difficulty installing this package. You may
@ -135,11 +135,16 @@ work on any non-Unix machine.
If you are using X Windows you might want to use the xv or xloadimage viewers
to save yourself the trouble of converting PPM to some other format. Both of
these can be found in the contrib directory at export.lcs.mit.edu.
There will soon be a new release of xv that incorporates our software and thus
can read and write JPEG files directly. (NOTE: since xv internally reduces
all images to 8 bits/pixel, a JPEG file written by xv will not be very high
quality. Caveat user.)
these can be found in the contrib directory at export.lcs.mit.edu. Actually,
xv version 2.00 and up incorporates our software and thus can read and write
JPEG files directly. (NOTE: since xv internally reduces all images to 8
bits/pixel, a JPEG file written by xv will not be very high quality; you may
also prefer xloadimage for viewing if you have a 24-bit display. Caveat user.)
For DOS machines, Lee Crocker's free Piclab program is a useful companion to
the JPEG software. The latest version, currently 1.91, is available by FTP
from SIMTEL20 and its various mirror sites, file <msdos.graphics>piclb191.zip.
CompuServe also has it, in the same library as the JPEG software.
SOFTWARE THAT'S NO HELP AT ALL
@ -152,10 +157,10 @@ to produce compatible files with its -j switch, and their decompression
program JPG2GIF can read our files (at least ones produced with our default
option settings).
Unfortunately, most commercial JPEG implementations are also incompatible as
Unfortunately, many commercial JPEG implementations are also incompatible as
of this writing, especially programs released before summer 1991. The root of
the problem is that the ISO JPEG committee failed to specify a concrete file
format. Many vendors "filled in the blanks" on their own, creating
format. Some vendors "filled in the blanks" on their own, creating
proprietary formats that no one else could read. (For example, none of the
early commercial JPEG implementations for the Macintosh were able to exchange
compressed files.)
@ -174,6 +179,52 @@ to help force rapid convergence to de facto standards for JPEG file formats.
SUPPORT STANDARD, NON-PROPRIETARY FORMATS: demand JFIF or JPEG-in-TIFF!
USING JPEG AS A SUBROUTINE IN A LARGER PROGRAM
==============================================
You can readily incorporate the JPEG compression and decompression routines in
a larger program. The file example.c provides a skeleton of the interface
routines you'll need for this purpose. Essentially, you replace jcmain.c (for
compression) and/or jdmain.c (for decompression) with your own code. Note
that the fewer JPEG options you allow the user to twiddle, the less code you
need; all the default options are set up automatically. (Alternately, if you
know a lot about JPEG or have a special application, you may want to twiddle
the default options even more extensively than jcmain/jdmain do.)
Most likely, you will want the uncompressed image to come from memory (for
compression) or go to memory or the screen (for decompression). For this
purpose you must provide image reading or writing routines that match the
interface used by the image file I/O modules (jrdXXX or jwrXXX); again,
example.c shows a skeleton of what is required.
By default, any error detected inside the JPEG routines will cause a message
to be printed on stderr, followed by exit(). You can override this behavior
by supplying your own message-printing and/or error-exit routines; again,
example.c shows how.
Mechanics: we recommend you create libjpeg.a as shown in the Makefile, then
link that with your surrounding program. (If your linker is at all
reasonable, only the code you actually need will get loaded.) Include the
files jconfig.h and jpegdata.h in C files that need to call the JPEG routines.
CAUTION: some people have tried to compile JPEG and their surrounding code
with different compilers, e.g., cc for JPEG and c++ or gcc for the rest. This
is a Real Bad Move and you will deserve what happens to you if you try it.
(Hint: the parameter structures can get laid out differently with no warning.)
Read our "architecture" file for more info. If it seems to you that the
software structure doesn't accommodate what you want to do, please contact
the authors.
Beginning with version 3, we will endeavor to hold the interface described by
example.c constant, so that you can plug in updated versions of the JPEG code
just by recompiling. However, we can't guarantee this, especially if you
choose to twiddle any JPEG options not listed in example.c. Check the
CHANGELOG when installing any new version, and compare example.c against the
prior version. Recompile your calling software (don't just relink), as we may
add or subtract fields in the parameter structures.
REFERENCES
==========
@ -184,6 +235,12 @@ algorithm is Wallace's article in the April '91 CACM:
(Adjacent articles in that issue discuss MPEG motion picture compression,
applications of JPEG, and related topics.) We highly recommend reading that
article before trying to understand the innards of any JPEG software.
If you don't have the CACM issue handy, a PostScript file containing a revised
version of the article is available at ftp.uu.net, graphics/jpeg/wallace.ps.Z.
The file (actually a preprint for an article to appear in IEEE Trans. Consumer
Electronics) omits the sample images that appeared in CACM, but it includes
corrections and some added material. Note: the Wallace article is copyright
ACM and IEEE, and it may not be used for commercial purposes.
For more detail about the JPEG standard you pretty much have to go to the
draft standard (which is not nearly as intelligible as Wallace's article).
@ -211,8 +268,12 @@ format. For the omitted details we follow the "JFIF" conventions, revision
399A West Trimble Road
San Jose, CA 95131
(408) 944-6300
Requests can also be e-mailed to info@c3.pla.ca.us. The same source can
supply copies of the draft JPEG-in-TIFF specs.
The same source can supply copies of the draft JPEG-in-TIFF documents
(Appendixes O and P to the TIFF spec). PostScript versions of these
documents can also be obtained by e-mail from the C-Cube mail server,
netlib@c3.pla.ca.us. Send the message "send jfif_ps from jpeg" to obtain the
JFIF document; "send app_o_ps from jpeg" and "send app_p_ps from jpeg" will
produce the TIFF documents. Send the message "help" if you have trouble.
If you want to understand this implementation, start by reading the
"architecture" documentation file. Please read "codingrules" if you want to
@ -227,7 +288,7 @@ with respect to this software, its quality, accuracy, merchantability, or
fitness for a particular purpose. This software is provided "AS IS", and you,
its user, assume the entire risk as to its quality and accuracy.
This software is copyright (C) 1991, Thomas G. Lane.
This software is copyright (C) 1991, 1992, Thomas G. Lane.
All Rights Reserved except as specified below.
Permission is hereby granted to use, copy, modify, and distribute this
@ -286,12 +347,8 @@ TO DO
=====
Many of the modules need fleshing out to provide more complete
implementations, or to provide faster paths for common cases. The greatest
needs are for (a) decent color quantization, and (b) a memory manager
implementation that can work in limited memory by swapping "big" images to
temporary files. I (Tom Lane) am going to work on color quantization next.
Volunteers to write a PC memory manager, or to work on any other modules, are
welcome.
implementations, or to provide faster paths for common cases.
Improving the speed will be the next big work item for the JPEG group.
We'd appreciate it if people would compile and check out the code on as wide a
variety of systems as possible, and report any portability problems

229
SETUP
View File

@ -26,16 +26,19 @@ STEP 1: PREPARE A MAKEFILE
First, select a makefile and copy it to "Makefile" (or whatever your version
of make uses as the default makefile name; for example, "makefile.mak" for
Borland C). We include several standard makefiles in the distribution:
old versions of Borland C). We include several standard makefiles in the
distribution:
makefile.ansi: for Unix systems with ANSI-compatible C compilers.
makefile.unix: for Unix systems with non-ANSI C compilers.
makefile.mc5: for Microsoft C 5.x under MS-DOS.
makefile.mc6: for Microsoft C 6.x under MS-DOS.
makefile.tc: for Borland's Turbo C under MS-DOS.
makefile.bcc: for Borland C (Turbo C) under MS-DOS.
makefile.pwc: for Mix Software's Power C under MS-DOS.
makefile.manx: for Manx Aztec C on Amigas.
makefile.sas: for SAS C on Amigas.
makefile.mms: for VAX/VMS systems with MMS.
makefile.vms: for VAX/VMS systems without MMS.
If you don't see a makefile for your system, we recommend starting from either
makefile.ansi or makefile.unix, depending on whether your compiler accepts
@ -46,24 +49,27 @@ preprocesses the source code to convert function definitions to old-style C.
(Our thanks to Peter Deutsch of Aladdin Enterprises for the ansi2knr program.)
If you don't know whether your compiler supports ANSI-style function
definitions, then take a look at config.c. It is a test program that will
definitions, then take a look at ckconfig.c. It is a test program that will
help you figure out this fact, as well as some other facts you'll need in
later steps. You must compile and execute config.c by hand; the makefiles
don't provide any support for this. config.c may not compile the first try
later steps. You must compile and execute ckconfig.c by hand; the makefiles
don't provide any support for this. ckconfig.c may not compile the first try
(in fact, the whole idea is for it to fail if anything is going to). If you
get compile errors, fix them by editing config.c according to the directions
given in config.c. Once you get it to run, select a makefile according to the
advice it prints out, and make any other changes it recommends.
get compile errors, fix them by editing ckconfig.c according to the directions
given in ckconfig.c. Once you get it to run, select a makefile according to
the advice it prints out, and make any other changes it recommends.
Look over the selected Makefile and adjust options as needed. In particular
you may want to change the CC and CFLAGS definitions. For instance, if you
are using GCC, set CC=gcc.
are using GCC, set CC=gcc. If you had to use any compiler switches to get
ckconfig.c to work, make sure the same switches are in CFLAGS.
If you are on a system that doesn't use makefiles, you'll need to set up
project files (or whatever you do use) to compile all the source files and
link them into executable files cjpeg and djpeg. See the file lists in any of
the makefiles to find out which files go into each program (makcjpeg.lst and
makdjpeg.lst are handy summaries).
the makefiles to find out which files go into each program. As a last resort,
you can make a batch script that just compiles everything and links it all
together; makefile.vms is an example of this (it's for VMS systems that have
no make-like utility).
STEP 2: EDIT JCONFIG.H
@ -79,8 +85,8 @@ older compilers other changes may be needed, depending on what ANSI features
are supported.
If you don't know enough about C programming to understand the questions in
jconfig.h, then use config.c to figure out what to change. (See description
of config.c in step 1.)
jconfig.h, then use ckconfig.c to figure out what to change. (See description
of ckconfig.c in step 1.)
A note about TWO_FILE_COMMANDLINE: defining this selects the command line
syntax in which the input and output files are both named on the command line.
@ -91,13 +97,70 @@ is true for most MS-DOS compilers, for example. If you're not on a Unix
system, it's probably safest to assume you need two-file style.
STEP 3: MAKE
STEP 3: SELECT SYSTEM-DEPENDENT FILES
=====================================
The only system-dependent file in the current version is jmemsys.c. This file
controls use of temporary files for big images that won't fit in main memory.
You'll notice there is no file by that name in the distribution; you must
select one of the provided versions and copy, rename, or link it to jmemsys.c.
Here are the provided versions:
jmemansi.c This is a reasonably portable version that should
work on most ANSI and near-ANSI C compilers. It uses
the ANSI-standard library routine tmpfile(), which not
all pre-ANSI systems have. On some systems tmpfile()
may put the temporary file in a non-optimal location;
if you don't like what it does, use jmemname.c.
jmemname.c This version constructs the temp file name by itself.
For anything except a Unix machine, you'll need to
configure the select_file_name() routine appropriately;
see the comments near the head of jmemname.c.
If you use this version, define NEED_SIGNAL_CATCHER
in jconfig.h or in the Makefile to make sure the temp
files are removed if the program is aborted.
jmemnobs.c (That stands for No Backing Store :-). This will
compile on almost any system, but it assumes you
have enough main memory or virtual memory to hold
the biggest images you need to work with.
jmemdos.c This should be used in most MS-DOS installations; see
the system-specific notes about MS-DOS for more info.
IMPORTANT: if you use this, also copy jmemdos.h to
jmemsys.h, replacing the standard version. ALSO,
include the assembly file jmemdosa.asm in the programs.
(This last is already done if you used one of the
supplied MS-DOS-specific makefiles.)
If you have plenty of (real or virtual) main memory, just use jmemnobs.c.
"Plenty" means at least ten bytes for every pixel in the largest images
you plan to process, so a lot of systems don't meet this criterion.
If yours doesn't, try jmemansi.c first. If that doesn't compile, you'll have
to use jmemname.c; be sure to adjust select_file_name() for local conditions.
You may also need to change unlink() to remove() in close_backing_store().
Except with jmemnobs.c, you need to adjust the #define DEFAULT_MAX_MEM to a
reasonable value for your system (either by editing jmemsys.c, or by adding
a -D switch to the Makefile). This value limits the amount of data space the
program will attempt to allocate. Code and static data space isn't counted,
so the actual memory needs for cjpeg or djpeg are typically 100 to 150Kb more
than the max-memory setting. Larger max-memory settings reduce the amount of
I/O needed to process a large image, but too large a value can result in
"insufficient memory" failures. On most Unix machines (and other systems with
virtual memory), just set DEFAULT_MAX_MEM to several million and forget it.
At the other end of the spectrum, for MS-DOS machines you probably can't go
much above 300K to 400K.
STEP 4: MAKE
============
Now you should be able to "make" the software.
If you have trouble with missing system include files or inclusion of the
wrong ones, look at jinclude.h (or use config.c, if you are not a C expert).
wrong ones, look at jinclude.h (or use ckconfig.c, if you are not a C expert).
If your compiler complains about big_sarray_control and big_barray_control
being undefined structures, you should be able to shut it up by adding
@ -109,27 +172,34 @@ some compilers will issue warnings about this, which you can ignore. Any
other warning deserves investigation.
STEP 4: TEST
STEP 5: TEST
============
As a quick test of functionality we've included three small sample files:
As a quick test of functionality we've included a small sample image in
several forms:
testorig.jpg A reduced section of the well-known Lenna picture.
testimg.ppm The output of djpeg testorig.jpg
testimg.gif The output of djpeg -G testorig.jpg
testimg.jpg The output of cjpeg testimg.ppm
(The two .jpg files aren't identical since JPEG is lossy.) If you can
generate duplicates of testimg.ppm and testimg.jpg then you probably have a
working port.
generate duplicates of the testimg.* files then you probably have working
programs.
With most of the makefiles, "make test" will perform the necessary
comparisons. If you're using a makefile that doesn't provide this option, run
djpeg and cjpeg to generate testout.ppm and testout.jpg, then compare these to
testimg.* with whatever file comparison tool you have. The files should be
bit-for-bit identical.
djpeg and cjpeg to generate testout.ppm, testout.gif, and testout.jpg, then
compare these to testimg.* with whatever binary file comparison tool you have.
The files should be bit-for-bit identical.
If your choice of jmemsys.c was anything other than jmemnobs.c, you should
also test that temporary-file usage works. Try "djpeg -G -m 0 testorig.jpg"
and make sure its output matches testimg.gif. If you have any really large
images handy, try compressing them with -o and/or decompressing with -G
to make sure your DEFAULT_MAX_MEM setting is not too large.
NOTE: this is far from an exhaustive test of the JPEG software; some modules,
such as color quantization and GIF I/O, are not exercised at all. It's just a
quick test to give you some confidence that you haven't missed something
major.
such as fast color quantization, are not exercised at all. It's just a quick
test to give you some confidence that you haven't missed something major.
If the test passes, you can copy the executable files cjpeg and djpeg to
wherever you normally install programs. Read the file USAGE to learn more
@ -152,13 +222,7 @@ follows:
"lib" subdirectory of the URT distribution).
If you want to incorporate the JPEG code as subroutines in a larger program,
we recommend that you make libjpeg.a. Then use the jconfig.h and jpegdata.h
files as your interface to the JPEG functions, and link libjpeg.a with your
program. Your surrounding program will have to provide functionality similar
to what's in jcmain.c or jdmain.c, and you may want to replace jerror.c and
possibly other modules depending on your needs. See the "architecture" file
for more info. If it seems to you that the system structure doesn't
accommodate what you want to do, please contact the authors.
we recommend that you make libjpeg.a. (See file README for more info.)
CAUTION: When you use the JPEG code as subroutines, we recommend that you make
any required configuration changes by modifying jconfig.h, not by adding -D
@ -178,33 +242,53 @@ NOTES FOR SPECIFIC SYSTEMS
==========================
We welcome reports on changes needed for systems not mentioned here.
Submit 'em to jpeg-info@uunet.uu.net. Also, config.c is fairly new and not
Submit 'em to jpeg-info@uunet.uu.net. Also, ckconfig.c is fairly new and not
yet thoroughly tested; if it's wrong about how to configure the JPEG software
for your system, please let us know.
Amiga:
Makefiles are provided for Manx Aztec C and SAS C. I have also heard from
people who have compiled with the free DICE compiler, using makefile.ansi as a
starting point (set "CC= dcc" and "CFLAGS= -c -DAMIGA -DTWO_FILE_COMMANDLINE
-DNEED_SIGNAL_CATCHER" in the makefile). For all compilers, we recommend you
use jmemname.c as the system-dependent memory manager. Assuming you have
-DAMIGA in the makefile, jmemname.c will put temporary files in JPEGTMP:.
Change jmemname.c if you don't like this.
Cray:
Should you be so fortunate as to be running JPEG on a Cray YMP, there is a
compiler bug in Cray's Standard C versions prior to 3.1. You'll need to
insert a line reading "#pragma novector" just before the loop
for (i = 1; i <= (int) htbl->bits[l]; i++)
huffsize[p++] = (char) l;
in fix_huff_tbl (in V2, line 42 of jchuff.c and line 38 of jdhuff.c). The
usual symptom of not adding this line is a core-dump. See Cray's SPR 48222.
HP/Apollo DOMAIN:
At least in version 10.3.5, the C compiler is ANSI but the system include
files are not. Use makefile.ansi and add -DNONANSI_INCLUDES to CFLAGS.
HP-UX:
If you have HP-UX 7.05 or later with the "software development" C compiler,
then you can use makefile.ansi. Add "-Aa" to the CFLAGS line in the
makefile. If you have a pre-7.05 system, or if you are using the non-ANSI C
compiler delivered with a minimum HP-UX 8.0 system, then you must use
makefile.unix (and do NOT add -Aa). Also, adding "-lmalloc" to LDLIBS is
recommended if you have libmalloc.a (it seems not to be present in minimum
8.0).
then you can use makefile.ansi. Add "-Aa" to the CFLAGS line in the makefile
to make the compiler work in ANSI mode. If you have a pre-7.05 system, or if
you are using the non-ANSI C compiler delivered with a minimum HP-UX 8.0
system, then you must use makefile.unix (and do NOT add -Aa). Also, adding
"-lmalloc" to LDLIBS is recommended if you have libmalloc.a (it seems not to
be present in minimum 8.0).
On HP series 800 machines, the HP C compiler is buggy in revisions prior to
A.08.07. If you get complaints about "not a typedef name", you'll have to
On HP 9000 series 800 machines, the HP C compiler is buggy in revisions prior
to A.08.07. If you get complaints about "not a typedef name", you'll have to
convert the code to K&R style (i.e., use makefile.unix).
IBM RS/6000 AIX:
The CFLAGS switch to make the compiler define __STDC__ is "-qlanglvl=ansi".
Macintosh Think C:
@ -215,11 +299,56 @@ project. Also add the ANSI and Unix C libraries in a separate segment. You
may need to divide the JPEG files into more than one segment; you can do this
pretty much as you please.
If you have Think C version 5.0 you should be able to just turn on __STDC__
through the compiler switch that enables that. With version 4.0 you must
manually edit jconfig.h. (You can #define __STDC__, but also #define const.)
If you have Think C version 5.0 you need not modify jconfig.h; instead you
should turn on both the ANSI Settings and Language Extensions option buttons
(so that both __STDC__ and THINK_C are predefined). With version 4.0 you must
edit jconfig.h. (You can #define HAVE_STDC to do the right thing for all
options except const; you must also #define const.)
Microsoft C for MS-DOS:
jcmain and jdmain are set up to provide the usual command-line interface
by means of Think's ccommand() library routine. Anybody want to write a
more Mac-like interface for us?
MS-DOS, generic comments:
The JPEG code is designed to be compiled with 80x86 "small" or "medium" memory
models (i.e., data pointers are 16 bits unless explicitly declared "far"; code
pointers can be either size). You should be able to use small model to
compile cjpeg or djpeg by itself, but you will probably have to go to medium
model if you include the JPEG code in a larger application. This shouldn't
hurt performance much. You *will* take a noticeable performance hit if you
compile in a large-data memory model, and you should avoid "huge" model if at
all possible. Be sure that NEED_FAR_POINTERS is defined by jconfig.h or by
the Makefile if you use a small-data model; be sure it is NOT defined if you
use a large-data memory model. (As distributed, jconfig.h defines
NEED_FAR_POINTERS if MSDOS is defined.)
The DOS-specific memory manager, jmemdos.c, should be used if possible.
(Be sure to install jmemdos.h and jmemdosa.asm along with it.) If you
can't use jmemdos.c for some reason --- for example, because you don't have
a Microsoft-compatible assembler to assemble jmemdosa.asm --- you'll have
to fall back to jmemansi.c or jmemname.c. IMPORTANT: if you use either of
those files, you will have to compile in a large-data memory model in order
to get the right stdio library. Too bad.
None of the above advice applies if you are using a 386 flat-memory-space
environment, such as DJGPP or Watcom C. For these compilers, do NOT define
NEED_FAR_POINTERS, and do NOT use jmemdos.c. Use jmemnobs.c if the
environment supplies adequate virtual memory, otherwise use jmemansi.c or
jmemname.c.
MS-DOS, DJGPP:
The file egetopt.c conflicts with some library routines in DJGPP 1.05.
Remove #include "egetopt.c" from jcmain.c and jdmain.c, and in each of
those files change the egetopt(...) call to getopt(...). This will be
fixed more cleanly in some future version. Use makefile.ansi, and put
"-DTWO_FILE_COMMANDLINE" (but *not* -DMSDOS) in CFLAGS.
MS-DOS, Microsoft C:
Some versions of MS C fail with an "out of macro expansion space" error
because they can't cope with the macro TRACEMS8 (defined in jpegdata.h).
@ -227,6 +356,10 @@ If this happens to you, the easiest solution is to change TRACEMS8 to
expand to nothing. You'll lose the ability to dump out JPEG coefficient
tables with djpeg -d -d, but at least you can compile.
makefile.mc6 (MS C 6.x makefile) has not been tested since jmemdosa.asm
was added; we'd appreciate hearing whether it works or not.
Sun:
Don't forget to add -DBSD to CFLAGS. If you are using GCC on SunOS 4.0.1 or

140
USAGE
View File

@ -1,19 +1,24 @@
USAGE instructions for the Independent JPEG Group's JPEG software
=================================================================
INTRODUCTION
This distribution contains software to implement JPEG image compression and
decompression. JPEG (pronounced "jay-peg") is a standardized compression
method for full-color and gray-scale images. JPEG is intended for
"real-world" scenes; cartoons and other non-realistic images are not its
strong suit. JPEG is lossy, meaning that the output image is not necessarily
identical to the input image. Hence you should not use JPEG if you have to
have identical output bits. However, on typical images of real-world scenes,
very good compression levels can be obtained with no visible change, and
amazingly high compression levels can be obtained if you can tolerate a
low-quality image.
method for full-color and gray-scale images. JPEG is designed to handle
"real-world" scenes, for example scanned photographs. Cartoons, line
drawings, and other non-realistic images are not JPEG's strong suit; on this
sort of material you may get poor image quality and/or little compression.
JPEG is lossy, meaning that the output image is not necessarily identical to
the input image. Hence you should not use JPEG if you have to have identical
output bits. However, on typical real-world images, very good compression
levels can be obtained with no visible change, and amazingly high compression
is possible if you can tolerate a low-quality image. You can trade off image
quality against file size by adjusting the compressor's "quality" setting.
This file describes usage of the standard programs "cjpeg" and "djpeg" that
can be built directly from the distributed software. See the README file for
can be built directly from the distributed C code. See the README file for
hints on incorporating the JPEG software into other programs.
If you are on a Unix machine you may prefer to read the Unix-style manual
@ -23,6 +28,8 @@ NOTE: at some point we will probably redesign the user interface, so the
command line switches described here will change.
GENERAL USAGE
We provide two programs, cjpeg to compress an image file into JPEG format,
and djpeg to decompress a JPEG file back into a conventional image format.
@ -35,25 +42,27 @@ named. They always write to standard output (with trace/error messages to
standard error). These conventions are handy for piping images between
programs.
On PC, Macintosh, and Amiga systems, you say:
On most non-Unix systems, you say:
cjpeg [switches] imagefile jpegfile
or
djpeg [switches] jpegfile imagefile
i.e., both input and output files are named on the command line. This style
is a little more foolproof, and it loses no functionality if you don't have
pipes. (You can get this style on Unix too, if you prefer, by defining
TWO_FILE_COMMANDLINE; see SETUP.)
i.e., both the input and output files are named on the command line. This
style is a little more foolproof, and it loses no functionality if you don't
have pipes. (You can get this style on Unix too, if you prefer, by defining
TWO_FILE_COMMANDLINE when you compile the programs; see SETUP.)
The currently supported image file formats are: PPM (PBMPLUS color format),
PGM (PBMPLUS gray-scale format), GIF, Targa, and RLE (Utah Raster Toolkit
format). (RLE is supported only if the URT library is available.)
cjpeg recognizes the input image format automatically, with the exception
of some Targa-format files.
of some Targa-format files. You have to tell djpeg which format to generate.
The only JPEG file format currently supported is the JFIF format. Support for
the TIFF/JPEG format will probably be added at some future date.
CJPEG DETAILS
The command line switches for cjpeg are:
-Q quality Scale quantization tables to adjust image quality.
@ -63,8 +72,9 @@ The command line switches for cjpeg are:
-o Perform optimization of entropy encoding parameters.
Without this, default encoding parameters are used.
-o usually makes the JPEG file a little smaller, but
cjpeg runs much slower. Image quality and speed of
decompression are unaffected by -o.
cjpeg runs somewhat slower and needs much more memory.
Image quality and speed of decompression are unaffected
by -o.
-T Input file is Targa format. Targa files that contain
an "identification" field will not be automatically
@ -79,6 +89,12 @@ The command line switches for cjpeg are:
-d Enable debug printout. More -d's give more printout.
Also, version information is printed at startup.
-m memory Set limit for amount of memory to use in processing
large images. Value is in thousands of bytes, or
millions of bytes if "M" is attached to the number.
For example, -m 4m selects 4000000 bytes. If more
space is needed, temporary files will be used.
The -Q switch lets you trade off compressed file size against quality of the
reconstructed image: the higher the -Q setting, the larger the JPEG file, and
the closer the output image will be to the original input. Normally you want
@ -105,6 +121,8 @@ cjpeg emits a warning message when you give such a -Q value, because some
commercial JPEG programs may be unable to decode the resulting file.)
DJPEG DETAILS
The command line switches for djpeg are:
-G Select GIF output format (implies -q, with default
@ -122,41 +140,73 @@ The command line switches for djpeg are:
if -q is specified; otherwise, 24-bit full-color
format is emitted.
-g Force gray-scale output even if input is color.
-q N Quantize to N colors. This reduces the number of
colors in the output image so that it can be displayed
on a colormapped display or stored in a colormapped
file format. For example, if you have an 8-bit
display, you'd need to quantize to 256 or fewer colors.
-D Do not use dithering in color quantization.
By default, Floyd-Steinberg dithering is applied when
quantizing colors, but on some images dithering may
result in objectionable "graininess". If that
happens, you can turn off dithering with -D.
-D is ignored unless you also say -q or -G.
-1 Use one-pass instead of two-pass color quantization.
The one-pass method is faster and needs less memory,
but it produces a lower-quality image.
-1 is ignored unless you also say -q or -G. Also,
the one-pass method is always used for gray-scale
output (the two-pass method is no improvement then).
-b Perform cross-block smoothing. This is quite
memory-intensive and only seems to improve the image
at very low quality settings (-Q 10 to 20 or so).
At normal -Q settings it may make the image worse.
-g Force gray-scale output even if input is color.
-q N Quantize to N colors.
-D Do NOT use dithering in color quantization.
By default, Floyd-Steinberg dithering is applied when
quantizing colors, but on some images dithering may
result in objectionable "graininess". If that
happens, you can turn off dithering with -D.
-2 Use two-pass color quantization (not yet supported).
-d Enable debug printout. More -d's give more printout.
Also, version information is printed at startup.
Color quantization currently uses a rather shoddy algorithm (although it's not
as horrible when dithered). Because of this, the GIF output mode is NOT
RECOMMENDED in the current release, except for gray-scale output. You can get
better results by applying ppmquant to the unquantized (PPM) output of djpeg,
then converting to GIF with ppmtogif. (See SUPPORTING SOFTWARE in the README
file.) We expect to provide a considerably better quantization algorithm in a
future release. (The same applies to colormapped RLE or Targa output, of
course.)
-m memory Set limit for amount of memory to use in processing
large images. Value is in thousands of bytes, or
millions of bytes if "M" is attached to the number.
For example, -m 4m selects 4000000 bytes. If more
space is needed, temporary files will be used.
Note that djpeg *can* read noninterleaved JPEG files even though cjpeg can't
yet generate them. For most applications this is a nonissue, since hardly
anybody seems to be using noninterleaved format.
On a non-virtual-memory machine, you may run out of memory if you use -I or -o
in cjpeg, or -q ... -2 in djpeg, or try to read an interlaced GIF file, or try
to read or write an RLE file, or try to read an interlaced or bottom-up Targa
file. This will be addressed soon by replacing jvirtmem.c with something that
uses temporary files for large images.
HINTS
Avoid running an image through a series of JPEG compression/decompression
cycles. Image quality loss will accumulate; after ten or so cycles the image
may be noticeably worse than it was after one cycle. It's best to use a
lossless format while manipulating an image, then convert to JPEG format when
you are ready to file the image away.
The -o option to cjpeg is worth using when you are making a "final" version
for posting or archiving. It's also a win when you are using low -Q settings
to make very small JPEG files; the percentage improvement is often a lot more
than it is on larger files.
The default memory usage limit (-m) is set when the software is compiled.
If you get an "insufficient memory" error, try specifying a smaller -m value,
even -m 0 to use the absolute minimum space. You may want to recompile with
a smaller default value if this happens often.
djpeg with two-pass color quantization requires a good deal of space; on
MS-DOS machines it may run out of memory even with -m 0. In that case you
can still decompress, with some loss of image quality, by specifying -1
for one-pass quantization.
If more space is needed than will fit in the available main memory (as
determined by -m), temporary files will be used. (MS-DOS versions will try to
get extended or expanded memory first.) The temporary files are often rather
large: in typical cases they occupy three bytes per pixel, for example
3*800*600 = 1.44Mb for an 800x600 image. If you don't have enough free disk
space, leave out -o (for cjpeg) or specify -1 (for djpeg). On MS-DOS, the
temporary files are created in the directory named by the TMP or TEMP
environment variable, or in the current directory if neither of those exist.
Amiga implementations put the temp files in the directory named by JPEGTMP:,
so be sure to assign JPEGTMP: to a disk partition with adequate free space.

View File

@ -1,5 +1,5 @@
JPEG SYSTEM ARCHITECTURE 3-OCT-91
JPEG SYSTEM ARCHITECTURE 29-FEB-92
This file provides an overview of the "architecture" of the portable JPEG
@ -13,7 +13,7 @@ to the mark. Also, it is frequently the case that several different modules
present a common interface to callers; the term "object" or "method" refers to
this common interface (see "Poor man's object-oriented programming", below).
JPEG-specific terminology follows the JPEG R9 draft:
JPEG-specific terminology follows the JPEG standard:
A "component" means a color channel, e.g., Red or Luminance.
A "sample" is a pixel component value (i.e., one number in the image data).
A "coefficient" is a frequency coefficient (a DCT transform output number).
@ -52,8 +52,7 @@ real-time, which nobody is going to do with a pure software implementation.
There is some value in supporting the hierarchical mode, which allows for
successive frames of higher resolution. This could be of use for including
"thumbnail" representations. Also, Storm's JPEG++ files probably use the
hierarchical mode (I haven't looked). However, this appears to add a lot more
"thumbnail" representations. However, this appears to add a lot more
complexity than it is worth.
A variety of uncompressed image file formats and user interfaces must be
@ -79,10 +78,10 @@ baggage.)
The *logical* steps needed in (non-lossless) JPEG compression are:
1. Conversion from incoming image format to a standardized internal form
(either RGB or greyscale).
(either RGB or grayscale).
2. Color space conversion (e.g., RGB to YCbCr). This is a null step for
greyscale (unless we support mapping color inputs to greyscale, which
grayscale (unless we support mapping color inputs to grayscale, which
would most easily be done here). Gamma adjustment may also be needed here.
3. Subsampling (reduction of number of samples in some color components).
@ -171,7 +170,7 @@ The *logical* steps needed in (non-lossless) JPEG decompression are:
4. MCU disassembly (conversion of a possibly interleaved sequence of 8x8
blocks back to separate components in pixel map order).
5. (Optional) Cross-block smoothing per JPEG section 13.10 or a similar
5. (Optional) Cross-block smoothing per JPEG section K.8 or a similar
algorithm. (Steps 5-8 operate independently on each component.)
6. Inverse DCT transformation of each 8x8 block.
@ -189,19 +188,23 @@ The *logical* steps needed in (non-lossless) JPEG decompression are:
sizes.
10. Color space reconversion (e.g., YCbCr to RGB). This is a null step for
greyscale. (Note that if we support mapping color JPEG to greyscale,
it could be done as part of this step.) Gamma adjustment may also be
needed here.
grayscale. (Note that mapping a color JPEG to grayscale output is most
easily done in this step.) Gamma adjustment may also be needed here.
11. Color quantization (only if a colormapped output format is requested).
NOTE: it might be better to do this on the internal color space instead of
RGB? If so, it would need to be performed one step earlier.
NOTE: it is probably preferable to perform quantization in the internal
(JPEG) colorspace rather than the output colorspace. Doing it that way,
color conversion need only be applied to the colormap entries, not to
every pixel; and quantization gets to operate in a non-gamma-corrected
space. But the internal space may not be suitable for some algorithms.
The system design is such that only the color quantizer module knows
whether color conversion happens before or after quantization.
12. Writing of the desired image format.
As before, some of these will be combined into single steps. When dealing
with a noninterleaved JPEG file, steps 2-9 will be performed once for each
scan; the resulting data will need to be buffered up so that step 10 can
scan; the resulting data will need to be buffered up so that steps 10-12 can
process all the color components together.
The same auxiliary modules are needed as before, except for compression
@ -429,12 +432,8 @@ different instances (choose to execute different modules).
To minimize the number of object pointers that have to be passed around, it
will be easiest to have just a few big structs containing all the method
pointers. We'll actually use two such structs, one for "globally" defined
methods (applicable to the whole file or to all components of the current
scan) and one for methods applicable to a single component. There'll be one
copy of the second kind of struct for each component of the current scan.
This is necessary so that preselection of an optimal method can be done based
on component-specific information (like sampling ratios...)
pointers. We'll actually use two such structs, one for "system-dependent"
methods (memory allocation and error handling) and one for everything else.
Because of this choice, it's best not to think of an "object" as a specific
data structure. Rather, an "object" is just a group of related methods.
@ -528,7 +527,10 @@ aren't described here; see the header files. Notice that any object that
might need to allocate working storage receives an "init" and a "term" call;
"term" should be careful to free all allocated storage so that the JPEG system
can be used multiple times during a program run. (For the same reason,
depending on static initialization of variables is a no-no.)
depending on static initialization of variables is a no-no. The only
exception to the free-all-allocated-storage rule is that storage allocated for
the entire processing of an image need not be explicitly freed, since the
memory manager's free_all cleanup will free it.)
1. Input file conversion to standardized form. This provides these methods:
input_init: read the file header, report image size & component count.
@ -677,8 +679,8 @@ depending on static initialization of variables is a no-no.)
afresh for each non-Unix-like platform the compressor is ported to.
The UI is expected to supply input and output files and values for all
non-automatically-chosen compression parameters. (Hence defaults are
determined by the UI; we should probably provide helpful routines to fill
in recommended defaults.) The UI must also supply error handling
determined by the UI; we should provide helpful routines to fill in
the recommended defaults.) The UI must also supply error handling
routines and some mechanism for trace messages.
(This module hides the user interface provided --- command line,
interactive, etc. Except for error/message handling, the UI calls the
@ -749,7 +751,8 @@ depending on static initialization of variables is a no-no.)
alloc_small: allocate an object of given size; use for any random
data that's not an image array.
free_small: release same.
alloc_medium: like alloc_small, but returns a FAR pointer.
alloc_medium: like alloc_small, but returns a FAR pointer. Use for
any object bigger than a couple kilobytes.
free_medium: release same.
alloc_small_sarray: construct an all-in-memory image sample array.
free_small_sarray: release same.
@ -766,9 +769,13 @@ depending on static initialization of variables is a no-no.)
figure out how much space to leave unallocated.
access_big_sarray: obtain access to a specified portion of a virtual
image sample array.
access_big_barray: ditto for block (coefficient) arrays.
free_big_sarray: release a virtual sample array.
access_big_barray,
free_big_barray: ditto for block (coefficient) arrays.
free_all: release any remaining storage. This is called
before normal or error termination; the main reason
why it must exist is to ensure that any temporary
files will be deleted upon error termination.
alloc_big_arrays will be called by the pipeline controller, which does
most of the memory allocation anyway. The only reason for having separate
@ -783,8 +790,8 @@ depending on static initialization of variables is a no-no.)
The distinction between sample and coefficient array routines is annoying,
but it has to be maintained for machines in which "char *" is represented
differently from "int *"... on byte-addressable machines some of these
methods could point to the same code.
differently from "int *". On byte-addressable machines some of these
methods could perhaps point to the same code.
The array routines will operate on only 2-D arrays (one component at a
time), since different components may require different-size arrays.
@ -796,8 +803,8 @@ Note that any given implementation will presumably contain only one
instantiation of input file header reading, overall control, user interface,
and memory management. Thus these could be called as simple subroutines,
without bothering with an object indirection. This is essential for overall
control (which has to initialize the object structure); I'm undecided whether
to impose objectness on the other three.
control (which has to initialize the object structure); for consistency we
will impose objectness on the other three.
*** Decompression object structure ***
@ -835,7 +842,7 @@ comments at the top of the compression object section also apply here.
interface module to single-handedly implement special applications like
reading from a non-stdio source. For JPEG-in-TIFF format, the need for
random access will make it impossible for this to work; hence the TIFF
header module will probably override the UI read_jpeg_data routine.
header module will override the UI-supplied read_jpeg_data routine.
Non-stdio input from a TIFF file will require extensive surgery to the TIFF
header module, if indeed it is practical at all.
@ -864,7 +871,7 @@ comments at the top of the compression object section also apply here.
always a multiple of an MCU's dimensions.
(An object on the grounds that multiple instantiations might be useful.)
5. Cross-block smoothing per JPEG section 13.10 or a similar algorithm.
5. Cross-block smoothing per JPEG section K.8 or a similar algorithm.
smooth_coefficients: Given three block rows' worth of a single
component, emit a smoothed equivalent of the
middle row. The "above" and "below" pointers
@ -874,8 +881,13 @@ comments at the top of the compression object section also apply here.
extra memory is needed to buffer the additional block rows.
(This object hides the details of the smoothing algorithm.)
6. Inverse DCT transformation of each 8x8 block. (This can be a plain
subroutine processing one block per call.)
6. Inverse DCT transformation of each 8x8 block.
reverse_DCT: given an MCU row's worth of blocks, perform inverse
DCT on each block and output the results into an array
of samples.
We put this method into the jdmcu module for symmetry with the division of
labor in compression. Note that the actual IDCT code is a separate source
file.
7. De-subsampling and smoothing: this will be applied to one component at a
time. Note that cross-pixel smoothing, which was a separate step in the
@ -905,9 +917,13 @@ comments at the top of the compression object section also apply here.
output are image arrays of same size but possibly
different numbers of components.
colorout_term: cleanup (probably a no-op except for memory dealloc).
In practice will always be given an MCU row's worth of pixel rows, except
In practice will usually be given an MCU row's worth of pixel rows, except
at the bottom where a smaller number of rows may be left over. Note that
this object works on all the components at once.
When quantizing colors, color_convert may be applied to the colormap
instead of actual pixel data. color_convert is called by the color
quantizer in this case; the pipeline controller calls color_convert
directly only when not quantizing.
(Hides all knowledge of color space semantics and conversion. Remaining
modules only need to know the number of JPEG and output components.)
@ -927,33 +943,44 @@ comments at the top of the compression object section also apply here.
"big" sample image, output is via put_color_map and
put_pixel_rows. (Used only in 2-pass quantization.)
color_quant_term: cleanup (probably a no-op except for memory dealloc).
The input to the color quantizer is always in the unconverted colorspace;
its output colormap must be in the converted colorspace. The quantizer
has the choice of which space to work in internally. It must call
color_convert either on its input data or on the colormap it sends to the
output module.
For one-pass quantization the image is simply processed by color_quantize,
a few rows at a time. For two-pass quantization, the pipeline controller
accumulates the output of color_convert into a "big" sample image. The
accumulates the output of steps 1-8 into a "big" sample image. The
color_quant_prescan method is invoked during this process so that the
quantizer can accumulate statistics. At the end of the image,
color_quant_doit is called; it must rescan the "big" image and pass
converted data to the output module. Additional scans of the image could
be made before the output pass is done (in fact, prescan could be a no-op).
quantizer can accumulate statistics. (If the input file has multiple
scans, the prescan may be done during the final scan or as a separate
pass.) At the end of the image, color_quant_doit is called; it must
create and output a colormap, then rescan the "big" image and pass mapped
data to the output module. Additional scans of the image could be made
before the output pass is done (in fact, prescan could be a no-op).
As with entropy parameter optimization, the pipeline controller actually
passes an iterator function rather than direct access to the big image.
NOTE: it might be better to do this on the internal color space instead of
RGB? If so, it would need to be performed one step earlier.
(Hides color quantization algorithm.)
11. Writing of the desired image format.
output_init: produce the file header given data from read_file_header.
put_color_map: output colormap, if any (called by color quantizer).
If used, must be called before any pixel data is output.
put_pixel_rows: output image data in desired format.
output_term: finish up at the end.
The actual timing of I/O may differ from that suggested by the routine
names; for instance, writing of the file header may be delayed until
put_color_map time if the actual number of colors is needed in the header.
Also, the colormap is available to put_pixel_rows and output_term as well
as put_color_map.
Note that whether colormapping is needed will be determined by the user
interface object prior to method selection. In implementations that
support multiple output formats, the actual output format will also be
determined by the user interface.
(Hides format of output image and mechanism used to write it. Note that
several other objects know the color model used by the output format. The
actual mechanism for writing the file is private to this object and the
user interface.)
several other objects know the color model used by the output format.
The actual mechanism for writing the file is private to this object and
the user interface.)
12. Pipeline control. This object will provide the "main loop" that invokes
all the pipeline objects. Note that we will need several different main
@ -985,9 +1012,6 @@ comments at the top of the compression object section also apply here.
application program", i.e., that which invokes the JPEG decompressor.
The UI is expected to supply input and output files and values for all
operational parameters. The UI must also supply error handling routines.
At the moment I can't think of any nonfatal errors the JPEG code is likely
to report, so a single report-this-error-and-exit method should be
sufficient.
(This module hides the user interface provided --- command line,
interactive, etc. Except for error handling, the UI calls the portable
JPEG code, not the other way around.)
@ -1050,9 +1074,52 @@ needs a lot smaller temp file than is implied by the maximum-height method.
For this approach we'd simply treat DNL as a no-op in the decompressor (at
most, check that it matches the SOF image height).
We will not worry about making the compressor capable of outputting DNL. Note
that something similar to the first scheme above could be applied if anyone
ever wants to make that work.
We will not worry about making the compressor capable of outputting DNL.
Something similar to the first scheme above could be applied if anyone ever
wants to make that work.
*** Memory manager internal structure ***
The memory manager contains the most potential for system dependencies.
To isolate system dependencies as much as possible, we have broken the
memory manager into two parts. There is a reasonably system-independent
"front end" (jmemmgr.c) and a "back end" that contains only the code
likely to change across systems. All of the memory management methods
outlined above are implemented by the front end. The back end provides
the following routines for use by the front end (none of these routines
are known to the rest of the JPEG code):
jmem_init, jmem_term system-dependent initialization/shutdown
jget_small, jfree_small interface to malloc and free library routines
jget_large, jfree_large interface to FAR malloc/free in MS-DOS machines;
otherwise same as jget_small/jfree_small
jmem_available estimate available memory
jopen_backing_store create a backing-store object
read_backing_store, manipulate a backing store object
write_backing_store,
close_backing_store
On some systems there will be more than one type of backing-store object
(specifically, in MS-DOS a backing store file might be an area of extended
memory as well as a disk file). jopen_backing_store is responsible for
choosing how to implement a given object. The read/write/close routines
are method pointers in the structure that describes a given object; this
lets them be different for different object types.
It may be necessary to ensure that backing store objects are explicitly
released upon abnormal program termination. (For example, MS-DOS won't free
extended memory by itself.) To support this, we will expect the main program
or surrounding application to arrange to call the free_all method upon
abnormal termination; this may require a SIGINT signal handler, for instance.
(We don't want to have the system-dependent module install its own signal
handler, because that would pre-empt the surrounding application's ability
to control signal handling.)
*** Notes for MS-DOS implementors ***
@ -1067,10 +1134,10 @@ significant speed penalty.
When integrating the JPEG code into a larger application, it's a good idea to
stay with a small-data-space model if possible. An 8K stack is much more than
sufficient for the JPEG code, and its static data requirements are less than
1K. When executed, it will typically malloc about 10K worth of near heap
1K. When executed, it will typically malloc about 10K-20K worth of near heap
space (and lots of far heap, but that doesn't count in this calculation).
This figure will vary depending on image size and other factors, but figuring
20K should be more than sufficient. Thus you have about 35K available for
30K should be more than sufficient. Thus you have about 25K available for
other modules' static data and near heap requirements before you need to go to
a larger memory model. The C library's static data will account for several K
of this, but that still leaves a good deal for your needs. (If you are tight
@ -1084,6 +1151,13 @@ JPEG code is stand-alone. (The LZW tables in jrdgif/jwrgif are examples.)
To make an optimal implementation, you might want to move these structures
back to near heap if you know there is sufficient space.
FAR data space may also be a tight resource when you are dealing with large
images. The most memory-intensive case is decompression with two-pass color
quantization. This requires a 128Kb color histogram plus strip buffers
amounting to about 150 bytes per column for typical sampling ratios (eg, about
96000 bytes for a 640-pixel-wide image). You may not be able to process wide
images if you have large data structures of your own.
*** Potential optimizations ***

18
cjpeg.1
View File

@ -1,4 +1,4 @@
.TH CJPEG 1 "11 December 1991"
.TH CJPEG 1 "28 February 1992"
.SH NAME
cjpeg \- compress an image file to a JPEG file
.SH SYNOPSIS
@ -10,6 +10,9 @@ cjpeg \- compress an image file to a JPEG file
.B \-oTIad
]
[
.BI \-m " memory"
]
[
.I filename
]
.LP
@ -33,7 +36,8 @@ encoding parameters are used.
.B \-o
usually makes the JPEG file a little smaller, but
.B cjpeg
runs much slower. Image quality and speed of decompression are unaffected by
runs somewhat slower and needs much more memory. Image quality and speed of
decompression are unaffected by
.BR \-o .
.TP
.B \-T
@ -57,6 +61,13 @@ supported for legal reasons).
Enable debug printout. More
.BR \-d 's
give more output. Also, version information is printed at startup.
.TP
.BI \-m " memory"
Set limit for amount of memory to use in processing large images. Value is
in thousands of bytes, or millions of bytes if "M" is attached to the
number. For example,
.B \-m 4m
selects 4000000 bytes. If more space is needed, temporary files will be used.
.PP
The
.B \-Q
@ -113,6 +124,9 @@ This example compresses the PPM file foo.ppm with a quality factor of
.SH SEE ALSO
.BR djpeg (1)
.br
.BR ppm (5),
.BR pgm (5)
.br
Wallace, Gregory K. "The JPEG Still Picture Compression Standard",
Communications of the ACM, April 1991 (vol. 34, no. 4), pp. 30-44.
.SH AUTHOR

View File

@ -1,7 +1,7 @@
/*
* config.c
* ckconfig.c
*
* Copyright (C) 1991, Thomas G. Lane.
* Copyright (C) 1991, 1992, 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.
*/
@ -121,12 +121,18 @@ int testfunction (int arg1, int * arg2); /* check prototypes */
struct methods_struct { /* check method-pointer declarations */
int (*error_exit) (char *msgtext);
int (*trace_message) (char *msgtext);
int (*another_method) (void);
};
int testfunction (int arg1, int * arg2) /* check definitions */
{
return arg2[arg1];
}
int testfunction1 (void) /* check void arg list */
{
return 0;
}
#endif
@ -278,7 +284,7 @@ int main (argc, argv)
/* Check whether we have all the ANSI features, */
/* and whether this agrees with __STDC__ being predefined. */
#ifdef __STDC__
#define MY__STDC__ /* ANSI compilers won't allow redefining __STDC__ */
#define HAVE_STDC /* ANSI compilers won't allow redefining __STDC__ */
#endif
#ifdef HAVE_ANSI_DEFINITIONS
@ -292,28 +298,23 @@ int main (argc, argv)
#endif
#ifdef HAVE_ALL_ANSI_FEATURES
#ifndef MY__STDC__
#ifndef HAVE_STDC
new_change();
printf("Your compiler doesn't claim to be ANSI-compliant, but it is close enough\n");
printf("for me. Either add -D__STDC__ to CFLAGS, or add #define __STDC__ at the\n");
printf("beginning of jinclude.h (NOT jconfig.h).\n");
printf("Some compilers will not let you do this: they will complain that __STDC__\n");
printf("is a reserved name. In that case you have a compiler that really is ANSI,\n");
printf("but you have to give it a special switch (often -ansi) to make it so.\n");
printf("Check your compiler documentation and add the proper switch to CFLAGS.\n");
#define MY__STDC__
printf("for me. Either add -DHAVE_STDC to CFLAGS, or add #define HAVE_STDC at the\n");
printf("beginning of jconfig.h.\n");
#define HAVE_STDC
#endif
#else /* !HAVE_ALL_ANSI_FEATURES */
#ifdef MY__STDC__
#ifdef HAVE_STDC
new_change();
printf("Your compiler claims to be ANSI-compliant, but it is lying!\n");
printf("Either add -U__STDC__ to CFLAGS, or add #undef __STDC__\n");
printf("at the beginning of jinclude.h (NOT jconfig.h).\n");
#undef MY__STDC__
printf("Delete the line #define HAVE_STDC near the beginning of jconfig.h.\n");
#undef HAVE_STDC
#endif
#endif /* HAVE_ALL_ANSI_FEATURES */
#ifndef MY__STDC__
#ifndef HAVE_STDC
#ifdef HAVE_ANSI_DEFINITIONS
new_change();
@ -326,31 +327,30 @@ int main (argc, argv)
#ifdef HAVE_UNSIGNED_SHORT
new_change();
printf("You should add -DHAVE_UNSIGNED_CHAR and -DHAVE_UNSIGNED_SHORT\n");
printf("to CFLAGS, or else take out the #ifdef __STDC__/#endif lines\n");
printf("to CFLAGS, or else take out the #ifdef HAVE_STDC/#endif lines\n");
printf("surrounding #define HAVE_UNSIGNED_CHAR and #define HAVE_UNSIGNED_SHORT\n");
printf("in jconfig.h.\n");
#else /* only unsigned char */
new_change();
printf("You should add -DHAVE_UNSIGNED_CHAR to CFLAGS,\n");
printf("or else move #define HAVE_UNSIGNED_CHAR outside the\n");
printf("#ifdef __STDC__/#endif lines surrounding it in jconfig.h.\n");
printf("#ifdef HAVE_STDC/#endif lines surrounding it in jconfig.h.\n");
#endif
#else /* !HAVE_UNSIGNED_CHAR */
#ifdef HAVE_UNSIGNED_SHORT
new_change();
printf("You should add -DHAVE_UNSIGNED_SHORT to CFLAGS,\n");
printf("or else move #define HAVE_UNSIGNED_SHORT outside the\n");
printf("#ifdef __STDC__/#endif lines surrounding it in jconfig.h.\n");
printf("#ifdef HAVE_STDC/#endif lines surrounding it in jconfig.h.\n");
#endif
#endif /* HAVE_UNSIGNED_CHAR */
#ifdef HAVE_CONST
new_change();
printf("You can delete the #define const line from jconfig.h.\n");
printf("(But things should still work if you don't.)\n");
printf("You should delete the #define const line from jconfig.h.\n");
#endif
#endif /* MY__STDC__ */
#endif /* HAVE_STDC */
test_char_sign((int) signed_char_check);
@ -365,13 +365,13 @@ int main (argc, argv)
#endif
#ifdef INCLUDES_ARE_ANSI
#ifndef MY__STDC__
#ifndef __STDC__
new_change();
printf("You should add -DINCLUDES_ARE_ANSI to CFLAGS, or else add\n");
printf("#define INCLUDES_ARE_ANSI at the beginning of jinclude.h (NOT jconfig.h).\n");
#endif
#else /* !INCLUDES_ARE_ANSI */
#ifdef MY__STDC__
#ifdef __STDC__
new_change();
printf("You should add -DNONANSI_INCLUDES to CFLAGS, or else add\n");
printf("#define NONANSI_INCLUDES at the beginning of jinclude.h (NOT jconfig.h).\n");

82
djpeg.1
View File

@ -1,13 +1,16 @@
.TH DJPEG 1 "11 December 1991"
.TH DJPEG 1 "28 February 1992"
.SH NAME
djpeg \- decompress a JPEG file to an image file
.SH SYNOPSIS
.B djpeg
[
.B \-GPRTbgD2d
.B \-GPRTgD1bd
]
[
.BI \-q " N"
.BI \-q " colors"
]
[
.BI \-m " memory"
]
[
.I filename
@ -20,22 +23,12 @@ decompresses the named JPEG file, or the standard input if no file is named,
and produces an image file on the standard output. PPM, GIF, Targa, or RLE
output format can be selected. (RLE is supported only if the URT library is
available.)
.LP
The color quantization algorithm is currently shoddy. Because of this, the
GIF output mode is not recommended in the current release, except for
gray-scale output (obtained with
.BR \-g ).
.SH OPTIONS
.TP
.B \-G
Select GIF output format (implies
.BR \-q ,
with default of 256 colors).
Currently the color quantization uses a shoddy algorithm and external
quantization (e.g.
.IR ppmquant ,
.IR rlequant )
is recommended before conversion to GIF format.
.TP
.B \-P
Select PPM or PGM output format (this is the default). PGM is emitted if the
@ -54,18 +47,14 @@ is specified; otherwise, colormapped format is emitted if
.B \-q
is specified; otherwise, 24-bit full-color format is emitted.
.TP
.B \-b
Perform cross-block smoothing. This is quite memory-intensive and only seems
to improve the image at low quality settings (\fB\-Q\fR 10 to 20 or so).
At normal
.B \-Q
settings it may make the image worse.
.TP
.B \-g
Force gray-scale output even if input is color.
.TP
.BI \-q " N"
Quantize to N colors.
Quantize to N colors. This reduces the number of colors in the output image
so that it can be displayed on a colormapped display or stored in a
colormapped file format. For example, if you have an 8-bit display, you'd
need to quantize to 256 or fewer colors.
.TP
.B \-D
Do not use dithering in color quantization. By default, Floyd-Steinberg
@ -73,42 +62,61 @@ dithering is applied when quantizing colors, but on some images dithering may
result in objectionable "graininess". If that happens, you can turn off
dithering with
.BR \-D .
.B \-D
is ignored unless you also say
.B \-q
or
.BR \-G .
.TP
.B \-2
Use two-pass color quantization (not yet supported).
.B \-1
Use one-pass instead of two-pass color quantization. The one-pass method is
faster and needs less memory, but it produces a lower-quality image.
.B \-1
is ignored unless you also say
.B \-q
or
.BR \-G .
Also, the one-pass method is always used for gray-scale output (the two-pass
method is no improvement then).
.TP
.B \-b
Perform cross-block smoothing. This is quite memory-intensive and only seems
to improve the image at low quality settings (\fB\-Q\fR 10 to 20 or so).
At normal
.B \-Q
settings it may make the image worse.
.TP
.B \-d
Enable debug printout. More
.BR \-d 's
give more output. Also, version information is printed at startup.
.TP
.BI \-m " memory"
Set limit for amount of memory to use in processing large images. Value is
in thousands of bytes, or millions of bytes if "M" is attached to the
number. For example,
.B \-m 4m
selects 4000000 bytes. If more space is needed, temporary files will be used.
.SH EXAMPLES
.LP
This example decompresses the JPEG file foo.jpg and saves the output
as a gray-scale image in foo.pgm:
This example decompresses the JPEG file foo.jpg, quantizes to 256 colors,
and saves the output in GIF format in foo.gif:
.IP
.B djpeg \-g
.B djpeg \-G
.I foo.jpg
.B >
.I foo.pgm
.I foo.gif
.SH SEE ALSO
.BR cjpeg (1)
.br
.BR ppmquant (1)
[From the PBMplus distribution]
.br
.BR rlequant (1)
[From the Utah Raster Toolkit distribution]
.BR ppm (5),
.BR pgm (5)
.br
Wallace, Gregory K. "The JPEG Still Picture Compression Standard",
Communications of the ACM, April 1991 (vol. 34, no. 4), pp. 30-44.
.SH AUTHOR
Independent JPEG Group
.SH BUGS
.B djpeg
currently uses a shoddy color quantization algorithm. This leads to
poor GIF file output. Two-pass color quantization is not yet
supported.
.PP
Arithmetic coding is not supported for legal reasons.
.PP
Not as fast as we'd like.

624
example.c Normal file
View File

@ -0,0 +1,624 @@
/*
* example.c
*
* This file is not actually part of the JPEG software. Rather, it provides
* a skeleton that may be useful for constructing applications that use the
* JPEG software as subroutines. This code will NOT do anything useful as is.
*
* This file illustrates how to use the JPEG code as a subroutine library
* to read or write JPEG image files. We assume here that you are not
* merely interested in converting the image to yet another image file format
* (if you are, you should be adding another I/O module to cjpeg/djpeg, not
* constructing a new application). Instead, we show how to pass the
* decompressed image data into or out of routines that you provide. For
* example, a viewer program might use the JPEG decompressor together with
* routines that write the decompressed image directly to a display.
*
* We present these routines in the same coding style used in the JPEG code
* (ANSI function definitions, etc); but you are of course free to code your
* routines in a different style if you prefer.
*/
/*
* Include file for declaring JPEG data structures.
* This file also includes some system headers like <stdio.h>;
* if you prefer, you can include "jconfig.h" and "jpegdata.h" instead.
*/
#include "jinclude.h"
/*
* <setjmp.h> is used for the optional error recovery mechanism shown in
* the second part of the example.
*/
#include <setjmp.h>
/******************** JPEG COMPRESSION SAMPLE INTERFACE *******************/
/* This half of the example shows how to feed data into the JPEG compressor.
* We present a minimal version that does not worry about refinements such
* as error recovery (the JPEG code will just exit() if it gets an error).
*/
/*
* To supply the image data for compression, you must define three routines
* input_init, get_input_row, and input_term. These routines will be called
* from the JPEG compressor via function pointer values that you store in the
* cinfo data structure; hence they need not be globally visible and the exact
* names don't matter. (In fact, the "METHODDEF" macro expands to "static" if
* you use the unmodified JPEG include files.)
*
* The input file reading modules (jrdppm.c, jrdgif.c, jrdtarga.c, etc) may be
* useful examples of what these routines should actually do, although each of
* them is encrusted with a lot of specialized code for its own file format.
*/
METHODDEF void
input_init (compress_info_ptr cinfo)
/* Initialize for input; return image size and component data. */
{
/* This routine must return five pieces of information about the incoming
* image, and must do any setup needed for the get_input_row routine.
* The image information is returned in fields of the cinfo struct.
* (If you don't care about modularity, you could initialize these fields
* in the main JPEG calling routine, and make this routine be a no-op.)
* We show some example values here.
*/
cinfo->image_width = 640; /* width in pixels */
cinfo->image_height = 480; /* height in pixels */
/* JPEG views an image as being a rectangular array of pixels, with each
* pixel having the same number of "component" values (color channels).
* You must specify how many components there are and the colorspace
* interpretation of the components. Most applications will use RGB data or
* grayscale data. If you want to use something else, you'll need to study
* and perhaps modify jcdeflts.c, jccolor.c, and jdcolor.c.
*/
cinfo->input_components = 3; /* or 1 for grayscale */
cinfo->in_color_space = CS_RGB; /* or CS_GRAYSCALE for grayscale */
cinfo->data_precision = 8; /* bits per pixel component value */
/* In the current JPEG software, data_precision must be set equal to
* BITS_IN_JSAMPLE, which is 8 unless you twiddle jconfig.h. Future
* versions might allow you to say either 8 or 12 if compiled with
* 12-bit JSAMPLEs, or up to 16 in lossless mode. In any case,
* it is up to you to scale incoming pixel values to the range
* 0 .. (1<<data_precision)-1.
* If your image data format is fixed at a byte per component,
* then saying "8" is probably the best long-term solution.
*/
}
/*
* This function is called repeatedly and must supply the next row of pixels
* on each call. The rows MUST be returned in top-to-bottom order if you want
* your JPEG files to be compatible with everyone else's. (If you cannot
* readily read your data in that order, you'll need an intermediate array to
* hold the image. See jrdtarga.c or jrdrle.c for examples of handling
* bottom-to-top source data using the JPEG code's portable mechanisms.)
* The data is to be returned into a 2-D array of JSAMPLEs, indexed as
* JSAMPLE pixel_row[component][column]
* where component runs from 0 to cinfo->input_components-1, and column runs
* from 0 to cinfo->image_width-1 (column 0 is left edge of image). Note that
* this is actually an array of pointers to arrays rather than a true 2D array,
* since C does not support variable-size multidimensional arrays.
* JSAMPLE is typically typedef'd as "unsigned char".
*/
METHODDEF void
get_input_row (compress_info_ptr cinfo, JSAMPARRAY pixel_row)
/* Read next row of pixels into pixel_row[][] */
{
/* This example shows how you might read RGB data (3 components)
* from an input file in which the data is stored 3 bytes per pixel
* in left-to-right, top-to-bottom order.
*/
register FILE * infile = cinfo->input_file;
register JSAMPROW ptr0, ptr1, ptr2;
register long col;
ptr0 = pixel_row[0];
ptr1 = pixel_row[1];
ptr2 = pixel_row[2];
for (col = 0; col < cinfo->image_width; col++) {
*ptr0++ = (JSAMPLE) getc(infile); /* red */
*ptr1++ = (JSAMPLE) getc(infile); /* green */
*ptr2++ = (JSAMPLE) getc(infile); /* blue */
}
}
METHODDEF void
input_term (compress_info_ptr cinfo)
/* Finish up at the end of the input */
{
/* This termination routine will very often have no work to do, */
/* but you must provide it anyway. */
/* Note that the JPEG code will only call it during successful exit; */
/* if you want it called during error exit, you gotta do that yourself. */
}
/*
* That's it for the routines that deal with reading the input image data.
* Now we have overall control and parameter selection routines.
*/
/*
* This routine must determine what output JPEG file format is to be written,
* and make any other compression parameter changes that are desirable.
* This routine gets control after the input file header has been read
* (i.e., right after input_init has been called). You could combine its
* functions into input_init, or even into the main control routine, but
* if you have several different input_init routines, it's a definite win
* to keep this separate. You MUST supply this routine even if it's a no-op.
*/
METHODDEF void
c_ui_method_selection (compress_info_ptr cinfo)
{
/* If the input is gray scale, generate a monochrome JPEG file. */
if (cinfo->in_color_space == CS_GRAYSCALE)
j_monochrome_default(cinfo);
/* For now, always select JFIF output format. */
jselwjfif(cinfo);
}
/*
* OK, here is the main function that actually causes everything to happen.
* We assume here that the target filename is supplied by the caller of this
* routine, and that all JPEG compression parameters can be default values.
*/
GLOBAL void
write_JPEG_file (char * filename)
{
/* These three structs contain JPEG parameters and working data.
* They must survive for the duration of parameter setup and one
* call to jpeg_compress; typically, making them local data in the
* calling routine is the best strategy.
*/
struct compress_info_struct cinfo;
struct compress_methods_struct c_methods;
struct external_methods_struct e_methods;
/* Initialize the system-dependent method pointers. */
cinfo.methods = &c_methods; /* links to method structs */
cinfo.emethods = &e_methods;
/* Here we use the default JPEG error handler, which will just print
* an error message on stderr and call exit(). See the second half of
* this file for an example of more graceful error recovery.
*/
jselerror(&e_methods); /* select std error/trace message routines */
/* Here we use the standard memory manager provided with the JPEG code.
* In some cases you might want to replace the memory manager, or at
* least the system-dependent part of it, with your own code.
*/
jselmemmgr(&e_methods); /* select std memory allocation routines */
/* If the compressor requires full-image buffers (for entropy-coding
* optimization or a noninterleaved JPEG file), it will create temporary
* files for anything that doesn't fit within the maximum-memory setting.
* (Note that temp files are NOT needed if you use the default parameters.)
* You can change the default maximum-memory setting by changing
* e_methods.max_memory_to_use after jselmemmgr returns.
* On some systems you may also need to set up a signal handler to
* ensure that temporary files are deleted if the program is interrupted.
* (This is most important if you are on MS-DOS and use the jmemdos.c
* memory manager back end; it will try to grab extended memory for
* temp files, and that space will NOT be freed automatically.)
* See jcmain.c or jdmain.c for an example signal handler.
*/
/* Here, set up pointers to your own routines for input data handling
* and post-init parameter selection.
*/
c_methods.input_init = input_init;
c_methods.get_input_row = get_input_row;
c_methods.input_term = input_term;
c_methods.c_ui_method_selection = c_ui_method_selection;
/* Set up default JPEG parameters in the cinfo data structure. */
j_c_defaults(&cinfo, 75, FALSE);
/* Note: 75 is the recommended default quality level; you may instead pass
* a user-specified quality level. Be aware that values below 25 will cause
* non-baseline JPEG files to be created (and a warning message to that
* effect to be emitted on stderr). This won't bother our decoder, but some
* commercial JPEG implementations may choke on non-baseline JPEG files.
* If you want to force baseline compatibility, pass TRUE instead of FALSE.
* (If non-baseline files are fine, but you could do without that warning
* message, set e_methods.trace_level to -1.)
*/
/* At this point you can modify the default parameters set by j_c_defaults
* as needed. For a minimal implementation, you shouldn't need to change
* anything. See jcmain.c for some examples of what you might change.
*/
/* Select the input and output files.
* Note that cinfo.input_file is only used if your input reading routines
* use it; otherwise, you can just make it NULL.
* VERY IMPORTANT: use "b" option to fopen() if you are on a machine that
* requires it in order to write binary files.
*/
cinfo.input_file = NULL; /* if no actual input file involved */
if ((cinfo.output_file = fopen(filename, "wb")) == NULL) {
fprintf(stderr, "can't open %s\n", filename);
exit(1);
}
/* Here we go! */
jpeg_compress(&cinfo);
/* That's it, son. Nothin' else to do, except close files. */
/* Here we assume only the output file need be closed. */
fclose(cinfo.output_file);
/* Note: if you want to compress more than one image, we recommend you
* repeat this whole routine. You MUST repeat the j_c_defaults()/alter
* parameters/jpeg_compress() sequence, as some data structures allocated
* in j_c_defaults are freed upon exit from jpeg_compress.
*/
}
/******************** JPEG DECOMPRESSION SAMPLE INTERFACE *******************/
/* This half of the example shows how to read data from the JPEG decompressor.
* It's a little more refined than the above in that we show how to do your
* own error recovery. If you don't care about that, you don't need these
* next two routines.
*/
/*
* These routines replace the default trace/error routines included with the
* JPEG code. The example trace_message routine shown here is actually the
* same as the standard one, but you could modify it if you don't want messages
* sent to stderr. The example error_exit routine is set up to return
* control to read_JPEG_file() rather than calling exit(). You can use the
* same routines for both compression and decompression error recovery.
*/
/* These static variables are needed by the error routines. */
static jmp_buf setjmp_buffer; /* for return to caller */
static external_methods_ptr emethods; /* needed for access to message_parm */
/* This routine is used for any and all trace, debug, or error printouts
* from the JPEG code. The parameter is a printf format string; up to 8
* integer data values for the format string have been stored in the
* message_parm[] field of the external_methods struct.
*/
METHODDEF void
trace_message (const char *msgtext)
{
fprintf(stderr, msgtext,
emethods->message_parm[0], emethods->message_parm[1],
emethods->message_parm[2], emethods->message_parm[3],
emethods->message_parm[4], emethods->message_parm[5],
emethods->message_parm[6], emethods->message_parm[7]);
fprintf(stderr, "\n"); /* there is no \n in the format string! */
}
/*
* The error_exit() routine should not return to its caller. The default
* routine calls exit(), but here we assume that we want to return to
* read_JPEG_data, which has set up a setjmp context for the purpose.
* You should make sure that the free_all method is called, either within
* error_exit or after the return to the outer-level routine.
*/
METHODDEF void
error_exit (const char *msgtext)
{
trace_message(msgtext); /* report the error message */
(*emethods->free_all) (); /* clean up memory allocation & temp files */
longjmp(setjmp_buffer, 1); /* return control to outer routine */
}
/*
* To accept the image data from decompression, you must define four routines
* output_init, put_color_map, put_pixel_rows, and output_term.
*
* You must understand the distinction between full color output mode
* (N independent color components) and colormapped output mode (a single
* output component representing an index into a color map). You should use
* colormapped mode to write to a colormapped display screen or output file.
* Colormapped mode is also useful for reducing grayscale output to a small
* number of gray levels: when using the 1-pass quantizer on grayscale data,
* the colormap entries will be evenly spaced from 0 to MAX_JSAMPLE, so you
* can regard the indexes are directly representing gray levels at reduced
* precision. In any other case, you should not depend on the colormap
* entries having any particular order.
* To get colormapped output, set cinfo->quantize_colors to TRUE and set
* cinfo->desired_number_of_colors to the maximum number of entries in the
* colormap. This can be done either in your main routine or in
* d_ui_method_selection. For grayscale quantization, also set
* cinfo->two_pass_quantize to FALSE to ensure the 1-pass quantizer is used
* (presently this is the default, but it may not be so in the future).
*
* The output file writing modules (jwrppm.c, jwrgif.c, jwrtarga.c, etc) may be
* useful examples of what these routines should actually do, although each of
* them is encrusted with a lot of specialized code for its own file format.
*/
METHODDEF void
output_init (decompress_info_ptr cinfo)
/* This routine should do any setup required */
{
/* This routine can initialize for output based on the data passed in cinfo.
* Useful fields include:
* image_width, image_height Pretty obvious, I hope.
* data_precision bits per pixel value; typically 8.
* out_color_space output colorspace previously requested
* color_out_comps number of color components in same
* final_out_comps number of components actually output
* final_out_comps is 1 if quantize_colors is true, else it is equal to
* color_out_comps.
*
* If you have requested color quantization, the colormap is NOT yet set.
* You may wish to defer output initialization until put_color_map is called.
*/
}
/*
* This routine is called if and only if you have set cinfo->quantize_colors
* to TRUE. It is given the selected colormap and can complete any required
* initialization. This call will occur after output_init and before any
* calls to put_pixel_rows. Note that the colormap pointer is also placed
* in a cinfo field, whence it can be used by put_pixel_rows or output_term.
* num_colors will be less than or equal to desired_number_of_colors.
*
* The colormap data is supplied as a 2-D array of JSAMPLEs, indexed as
* JSAMPLE colormap[component][indexvalue]
* where component runs from 0 to cinfo->color_out_comps-1, and indexvalue
* runs from 0 to num_colors-1. Note that this is actually an array of
* pointers to arrays rather than a true 2D array, since C does not support
* variable-size multidimensional arrays.
* JSAMPLE is typically typedef'd as "unsigned char". If you want your code
* to be as portable as the JPEG code proper, you should always access JSAMPLE
* values with the GETJSAMPLE() macro, which will do the right thing if the
* machine has only signed chars.
*/
METHODDEF void
put_color_map (decompress_info_ptr cinfo, int num_colors, JSAMPARRAY colormap)
/* Write the color map */
{
/* You need not provide this routine if you always set cinfo->quantize_colors
* FALSE; but a safer practice is to provide it and have it just print an
* error message, like this:
*/
fprintf(stderr, "put_color_map called: there's a bug here somewhere!\n");
}
/*
* This function is called repeatedly, with a few more rows of pixels supplied
* on each call. With the current JPEG code, some multiple of 8 rows will be
* passed on each call except the last, but it is extremely bad form to depend
* on this. You CAN assume num_rows > 0.
* The data is supplied in top-to-bottom row order (the standard order within
* a JPEG file). If you cannot readily use the data in that order, you'll
* need an intermediate array to hold the image. See jwrrle.c for an example
* of outputting data in bottom-to-top order.
*
* The data is supplied as a 3-D array of JSAMPLEs, indexed as
* JSAMPLE pixel_data[component][row][column]
* where component runs from 0 to cinfo->final_out_comps-1, row runs from 0 to
* num_rows-1, and column runs from 0 to cinfo->image_width-1 (column 0 is
* left edge of image). Note that this is actually an array of pointers to
* pointers to arrays rather than a true 3D array, since C does not support
* variable-size multidimensional arrays.
* JSAMPLE is typically typedef'd as "unsigned char". If you want your code
* to be as portable as the JPEG code proper, you should always access JSAMPLE
* values with the GETJSAMPLE() macro, which will do the right thing if the
* machine has only signed chars.
*
* If quantize_colors is true, then there is only one component, and its values
* are indexes into the previously supplied colormap. Otherwise the values
* are actual data in your selected output colorspace.
*/
METHODDEF void
put_pixel_rows (decompress_info_ptr cinfo, int num_rows, JSAMPIMAGE pixel_data)
/* Write some rows of output data */
{
/* This example shows how you might write full-color RGB data (3 components)
* to an output file in which the data is stored 3 bytes per pixel.
*/
register FILE * outfile = cinfo->output_file;
register JSAMPROW ptr0, ptr1, ptr2;
register long col;
register int row;
for (row = 0; row < num_rows; row++) {
ptr0 = pixel_data[0][row];
ptr1 = pixel_data[1][row];
ptr2 = pixel_data[2][row];
for (col = 0; col < cinfo->image_width; col++) {
putc(GETJSAMPLE(*ptr0), outfile); /* red */
ptr0++;
putc(GETJSAMPLE(*ptr1), outfile); /* green */
ptr1++;
putc(GETJSAMPLE(*ptr2), outfile); /* blue */
ptr2++;
}
}
}
METHODDEF void
output_term (decompress_info_ptr cinfo)
/* Finish up at the end of the output */
{
/* This termination routine may not need to do anything. */
/* Note that the JPEG code will only call it during successful exit; */
/* if you want it called during error exit, you gotta do that yourself. */
}
/*
* That's it for the routines that deal with writing the output image.
* Now we have overall control and parameter selection routines.
*/
/*
* This routine gets control after the JPEG file header has been read;
* at this point the image size and colorspace are known.
* The routine must determine what output routines are to be used, and make
* any decompression parameter changes that are desirable. For example,
* if it is found that the JPEG file is grayscale, you might want to do
* things differently than if it is color. You can also delay setting
* quantize_colors and associated options until this point.
*
* j_d_defaults initializes out_color_space to CS_RGB. If you want grayscale
* output you should set out_color_space to CS_GRAYSCALE. Note that you can
* force grayscale output from a color JPEG file (though not vice versa).
*/
METHODDEF void
d_ui_method_selection (decompress_info_ptr cinfo)
{
/* if grayscale input, force grayscale output; */
/* else leave the output colorspace as set by main routine. */
if (cinfo->jpeg_color_space == CS_GRAYSCALE)
cinfo->out_color_space = CS_GRAYSCALE;
/* select output routines */
cinfo->methods->output_init = output_init;
cinfo->methods->put_color_map = put_color_map;
cinfo->methods->put_pixel_rows = put_pixel_rows;
cinfo->methods->output_term = output_term;
}
/*
* OK, here is the main function that actually causes everything to happen.
* We assume here that the JPEG filename is supplied by the caller of this
* routine, and that all decompression parameters can be default values.
* The routine returns 1 if successful, 0 if not.
*/
GLOBAL int
read_JPEG_file (char * filename)
{
/* These three structs contain JPEG parameters and working data.
* They must survive for the duration of parameter setup and one
* call to jpeg_decompress; typically, making them local data in the
* calling routine is the best strategy.
*/
struct decompress_info_struct cinfo;
struct decompress_methods_struct dc_methods;
struct external_methods_struct e_methods;
/* Select the input and output files.
* In this example we want to open the input file before doing anything else,
* so that the setjmp() error recovery below can assume the file is open.
* Note that cinfo.output_file is only used if your output handling routines
* use it; otherwise, you can just make it NULL.
* VERY IMPORTANT: use "b" option to fopen() if you are on a machine that
* requires it in order to read binary files.
*/
if ((cinfo.input_file = fopen(filename, "rb")) == NULL) {
fprintf(stderr, "can't open %s\n", filename);
return 0;
}
cinfo.output_file = NULL; /* if no actual output file involved */
/* Initialize the system-dependent method pointers. */
cinfo.methods = &dc_methods; /* links to method structs */
cinfo.emethods = &e_methods;
/* Here we supply our own error handler; compare to use of standard error
* handler in the previous write_JPEG_file example.
*/
emethods = &e_methods; /* save struct addr for possible access */
e_methods.error_exit = error_exit; /* supply error-exit routine */
e_methods.trace_message = trace_message; /* supply trace-message routine */
/* prepare setjmp context for possible exit from error_exit */
if (setjmp(setjmp_buffer)) {
/* If we get here, the JPEG code has signaled an error.
* Memory allocation has already been cleaned up (see free_all call in
* error_exit), but we need to close the input file before returning.
* You might also need to close an output file, etc.
*/
fclose(cinfo.input_file);
return 0;
}
/* Here we use the standard memory manager provided with the JPEG code.
* In some cases you might want to replace the memory manager, or at
* least the system-dependent part of it, with your own code.
*/
jselmemmgr(&e_methods); /* select std memory allocation routines */
/* If the decompressor requires full-image buffers (for two-pass color
* quantization or a noninterleaved JPEG file), it will create temporary
* files for anything that doesn't fit within the maximum-memory setting.
* You can change the default maximum-memory setting by changing
* e_methods.max_memory_to_use after jselmemmgr returns.
* On some systems you may also need to set up a signal handler to
* ensure that temporary files are deleted if the program is interrupted.
* (This is most important if you are on MS-DOS and use the jmemdos.c
* memory manager back end; it will try to grab extended memory for
* temp files, and that space will NOT be freed automatically.)
* See jcmain.c or jdmain.c for an example signal handler.
*/
/* Here, set up the pointer to your own routine for post-header-reading
* parameter selection. You could also initialize the pointers to the
* output data handling routines here, if they are not dependent on the
* image type.
*/
dc_methods.d_ui_method_selection = d_ui_method_selection;
/* Set up default decompression parameters. */
j_d_defaults(&cinfo, TRUE);
/* TRUE indicates that an input buffer should be allocated.
* In unusual cases you may want to allocate the input buffer yourself;
* see jddeflts.c for commentary.
*/
/* At this point you can modify the default parameters set by j_d_defaults
* as needed; for example, you can request color quantization or force
* grayscale output. See jdmain.c for examples of what you might change.
*/
/* Set up to read a JFIF or baseline-JPEG file. */
/* This is the only JPEG file format currently supported. */
jselrjfif(&cinfo);
/* Here we go! */
jpeg_decompress(&cinfo);
/* That's it, son. Nothin' else to do, except close files. */
/* Here we assume only the input file need be closed. */
fclose(cinfo.input_file);
return 1; /* indicate success */
/* Note: if you want to decompress more than one image, we recommend you
* repeat this whole routine. You MUST repeat the j_d_defaults()/alter
* parameters/jpeg_decompress() sequence, as some data structures allocated
* in j_d_defaults are freed upon exit from jpeg_decompress.
*/
}

View File

@ -1,7 +1,7 @@
/*
* jbsmooth.c
*
* Copyright (C) 1991, Thomas G. Lane.
* Copyright (C) 1991, 1992, 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.
*
@ -43,7 +43,7 @@ smooth_coefficients (decompress_info_ptr cinfo,
if (above != NULL && below != NULL) {
for (col = 1; col < blocks_in_row-1; col++) {
/* See section 13.10 of JPEG-8-R8, or K.8 of JPEG-9-R6.
/* See section K.8 of the JPEG standard.
*
* As I understand it, this produces approximations
* for the low frequency AC components, based on the
@ -51,9 +51,7 @@ smooth_coefficients (decompress_info_ptr cinfo,
* (Thus it can't be used for blocks on the image edges.)
*/
/* The layout of these variables corresponds to
* the text in 13.10
*/
/* The layout of these variables corresponds to text and figure in K.8 */
JCOEF DC1, DC2, DC3;
JCOEF DC4, DC5, DC6;

View File

@ -1,7 +1,7 @@
/*
* jcarith.c
*
* Copyright (C) 1991, Thomas G. Lane.
* Copyright (C) 1991, 1992, 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.
*

View File

@ -1,7 +1,7 @@
/*
* jccolor.c
*
* Copyright (C) 1991, Thomas G. Lane.
* Copyright (C) 1991, 1992, 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.
*
@ -32,11 +32,35 @@ colorin_init (compress_info_ptr cinfo)
/*
* Fetch some rows of pixels from get_input_row and convert to the
* JPEG colorspace.
*/
/*
* This version handles RGB -> YCbCr conversion.
* YCbCr is defined per CCIR 601-1, except that Cb and Cr are
* normalized to the range 0..MAXJSAMPLE rather than -0.5 .. 0.5.
* The conversion equations to be implemented are therefore
* Y = 0.29900 * R + 0.58700 * G + 0.11400 * B
* Cb = -0.16874 * R - 0.33126 * G + 0.50000 * B
* Cr = 0.50000 * R - 0.41869 * G - 0.08131 * B
* where Cb and Cr must be incremented by MAXJSAMPLE/2 to create a
* nonnegative output value.
* (These numbers are derived from TIFF Appendix O, draft of 4/10/91.)
*
* To avoid floating-point arithmetic, we represent the fractional constants
* as integers scaled up by 2^14 (about 4 digits precision); we have to divide
* the products by 2^14, with appropriate rounding, to get the correct answer.
*
* For even more speed, we could avoid any multiplications in the inner loop
* by precalculating the constants times R,G,B for all possible values.
* This is not currently implemented.
*/
#define SCALEBITS 14
#define ONE_HALF ((INT32) 1 << (SCALEBITS-1))
#define FIX(x) ((INT32) ((x) * (1L<<SCALEBITS) + 0.5))
METHODDEF void
get_rgb_ycc_rows (compress_info_ptr cinfo,
int rows_to_read, JSAMPIMAGE image_data)
@ -63,17 +87,22 @@ get_rgb_ycc_rows (compress_info_ptr cinfo,
g = GETJSAMPLE(*inptr1++);
b = GETJSAMPLE(*inptr2++);
/* If the inputs are 0..MAXJSAMPLE, the outputs of these equations
* must be too; do not need an explicit range-limiting operation.
* must be too; we do not need an explicit range-limiting operation.
* Hence the value being shifted is never negative, and we don't
* need the general RIGHT_SHIFT macro.
*/
/* Y */
*outptr0++ = (JSAMPLE)
(( 306*r + 601*g + 117*b + (INT32) 512) >> 10);
(( FIX(0.29900)*r + FIX(0.58700)*g + FIX(0.11400)*b
+ ONE_HALF) >> SCALEBITS);
/* Cb */
*outptr1++ = (JSAMPLE)
(((-173)*r - 339*g + 512*b + (INT32) 512*(MAXJSAMPLE+1)) >> 10);
(((-FIX(0.16874))*r - FIX(0.33126)*g + FIX(0.50000)*b
+ ONE_HALF*(MAXJSAMPLE+1)) >> SCALEBITS);
/* Cr */
*outptr2++ = (JSAMPLE)
(( 512*r - 429*g - 83*b + (INT32) 512*(MAXJSAMPLE+1)) >> 10);
(( FIX(0.50000)*r - FIX(0.41869)*g - FIX(0.08131)*b
+ ONE_HALF*(MAXJSAMPLE+1)) >> SCALEBITS);
}
}
}
@ -132,9 +161,7 @@ get_noconvert_rows (compress_info_ptr cinfo,
METHODDEF void
colorin_term (compress_info_ptr cinfo)
{
/* Release the workspace. */
(*cinfo->emethods->free_small_sarray)
(pixel_row, (long) cinfo->input_components);
/* no work (we let free_all release the workspace) */
}
@ -153,6 +180,8 @@ jselccolor (compress_info_ptr cinfo)
break;
case CS_RGB:
case CS_YCbCr:
case CS_YIQ:
if (cinfo->input_components != 3)
ERREXIT(cinfo->emethods, "Bogus input colorspace");
break;
@ -183,6 +212,8 @@ jselccolor (compress_info_ptr cinfo)
ERREXIT(cinfo->emethods, "Bogus JPEG colorspace");
if (cinfo->in_color_space == CS_RGB)
cinfo->methods->get_sample_rows = get_rgb_ycc_rows;
else if (cinfo->in_color_space == CS_YCbCr)
cinfo->methods->get_sample_rows = get_noconvert_rows;
else
ERREXIT(cinfo->emethods, "Unsupported color conversion request");
break;

View File

@ -1,7 +1,7 @@
/*
* jcdeflts.c
*
* Copyright (C) 1991, Thomas G. Lane.
* Copyright (C) 1991, 1992, 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.
*
@ -13,6 +13,35 @@
#include "jinclude.h"
/* Default do-nothing progress monitoring routine.
* This can be overridden by a user interface that wishes to
* provide progress monitoring; just set methods->progress_monitor
* after j_c_defaults is done. The routine will be called periodically
* during the compression process.
*
* During any one pass, loopcounter increases from 0 up to (not including)
* looplimit; the step size is not necessarily 1. Both the step size and
* the limit may differ between passes. The expected total number of passes
* is in cinfo->total_passes, and the number of passes already completed is
* in cinfo->completed_passes. Thus the fraction of work completed may be
* estimated as
* completed_passes + (loopcounter/looplimit)
* ------------------------------------------
* total_passes
* ignoring the fact that the passes may not be equal amounts of work.
*/
METHODDEF void
progress_monitor (compress_info_ptr cinfo, long loopcounter, long looplimit)
{
/* do nothing */
}
/*
* Table setup routines
*/
LOCAL void
add_huff_table (compress_info_ptr cinfo,
HUFF_TBL **htblptr, const UINT8 *bits, const UINT8 *val)
@ -38,7 +67,8 @@ add_huff_table (compress_info_ptr cinfo,
LOCAL void
std_huff_tables (compress_info_ptr cinfo)
/* Set up the standard Huffman tables (cf. JPEG-8-R8 section 13.3) */
/* Set up the standard Huffman tables (cf. JPEG standard section K.3) */
/* IMPORTANT: these are only valid for 8-bit data precision! */
{
static const UINT8 dc_luminance_bits[17] =
{ /* 0-base */ 0, 0, 1, 5, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0 };
@ -111,7 +141,7 @@ std_huff_tables (compress_info_ptr cinfo)
}
/* This is the sample quantization table given in JPEG-8-R8 sec 13.1,
/* This is the sample quantization table given in the JPEG spec section K.1,
* but expressed in zigzag order (as are all of our quant. tables).
* The spec says that the values given produce "good" quality, and
* when divided by 2, "very good" quality. (These two settings are
@ -226,14 +256,9 @@ j_set_quality (compress_info_ptr cinfo, int quality, boolean force_baseline)
* you should also change the component ID codes, and you should NOT emit
* a JFIF header (set write_JFIF_header = FALSE).
*
* CAUTION: if you want to compress multiple images per run, it's safest
* to call j_c_defaults before *each* call to jpeg_compress (and
* j_c_free_defaults afterwards). If this isn't practical, you'll have to
* be careful to reset any individual parameters that may change during
* the compression run. The main thing you need to worry about at present
* is that the sent_table boolean in each Huffman table must be reset to
* FALSE before each compression; otherwise, Huffman tables won't get
* emitted for the second and subsequent images.
* CAUTION: if you want to compress multiple images per run, it's necessary
* to call j_c_defaults before *each* call to jpeg_compress, since subsidiary
* structures like the Huffman tables are automatically freed during cleanup.
*/
GLOBAL void
@ -252,7 +277,7 @@ j_c_defaults (compress_info_ptr cinfo, int quality, boolean force_baseline)
cinfo->ac_huff_tbl_ptrs[i] = NULL;
}
cinfo->data_precision = 8; /* default; can be overridden by input_init */
cinfo->data_precision = BITS_IN_JSAMPLE; /* default; can be overridden by input_init */
cinfo->density_unit = 0; /* Pixel size is unknown by default */
cinfo->X_density = 1; /* Pixel aspect ratio is square by default */
cinfo->Y_density = 1;
@ -324,6 +349,9 @@ j_c_defaults (compress_info_ptr cinfo, int quality, boolean force_baseline)
/* No restart markers */
cinfo->restart_interval = 0;
/* Install default do-nothing progress monitoring method. */
cinfo->methods->progress_monitor = progress_monitor;
}
@ -341,27 +369,3 @@ j_monochrome_default (compress_info_ptr cinfo)
compptr->h_samp_factor = 1;
compptr->v_samp_factor = 1;
}
/* This routine releases storage allocated by j_c_defaults.
* Note that freeing the method pointer structs and the compress_info_struct
* itself are the responsibility of the user interface.
*/
GLOBAL void
j_c_free_defaults (compress_info_ptr cinfo)
{
short i;
#define FREE(ptr) if ((ptr) != NULL) \
(*cinfo->emethods->free_small) ((void *) ptr)
FREE(cinfo->comp_info);
for (i = 0; i < NUM_QUANT_TBLS; i++)
FREE(cinfo->quant_tbl_ptrs[i]);
for (i = 0; i < NUM_HUFF_TBLS; i++) {
FREE(cinfo->dc_huff_tbl_ptrs[i]);
FREE(cinfo->ac_huff_tbl_ptrs[i]);
}
}

View File

@ -1,7 +1,7 @@
/*
* jcexpand.c
*
* Copyright (C) 1991, Thomas G. Lane.
* Copyright (C) 1991, 1992, 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.
*

View File

@ -1,7 +1,7 @@
/*
* jchuff.c
*
* Copyright (C) 1991, Thomas G. Lane.
* Copyright (C) 1991, 1992, 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.
*
@ -34,7 +34,7 @@ fix_huff_tbl (HUFF_TBL * htbl)
UINT16 huffcode[257];
UINT16 code;
/* Figure 7.3.5.4.2.1: make table of Huffman code length for each symbol */
/* Figure C.1: make table of Huffman code length for each symbol */
/* Note that this is in code-length order. */
p = 0;
@ -45,7 +45,7 @@ fix_huff_tbl (HUFF_TBL * htbl)
huffsize[p] = 0;
lastp = p;
/* Figure 7.3.5.4.2.2: generate the codes themselves */
/* Figure C.2: generate the codes themselves */
/* Note that this is in code-length order. */
code = 0;
@ -60,27 +60,21 @@ fix_huff_tbl (HUFF_TBL * htbl)
si++;
}
/* Figure 7.3.5.4.2.3: generate encoding tables */
/* Figure C.3: generate encoding tables */
/* These are code and size indexed by symbol value */
/* Set any codeless symbols to have code length 0;
* this allows emit_bits to detect any attempt to emit such symbols.
*/
MEMZERO((void *) htbl->ehufsi, SIZEOF(htbl->ehufsi));
for (p = 0; p < lastp; p++) {
htbl->ehufco[htbl->huffval[p]] = huffcode[p];
htbl->ehufsi[htbl->huffval[p]] = huffsize[p];
}
/* Figure 13.4.2.3.1: generate decoding tables */
p = 0;
for (l = 1; l <= 16; l++) {
if (htbl->bits[l]) {
htbl->valptr[l] = p; /* huffval[] index of 1st sym of code len l */
htbl->mincode[l] = huffcode[p]; /* minimum code of length l */
p += htbl->bits[l];
htbl->maxcode[l] = huffcode[p-1]; /* maximum code of length l */
} else {
htbl->maxcode[l] = -1;
}
}
/* We don't bother to fill in the decoding tables mincode[], maxcode[], */
/* and valptr[], since they are not used for encoding. */
}
@ -117,6 +111,10 @@ emit_bits (UINT16 code, int size)
register INT32 put_buffer = code;
register int put_bits = huff_put_bits;
/* if size is 0, caller used an invalid Huffman table entry */
if (size == 0)
ERREXIT(cinfo->emethods, "Missing Huffman code table entry");
put_buffer &= (((INT32) 1) << size) - 1; /* Mask off any excess bits in code */
put_bits += size; /* new number of bits in buffer */
@ -161,7 +159,7 @@ encode_one_block (JBLOCK block, HUFF_TBL *dctbl, HUFF_TBL *actbl)
register int nbits;
register int k, r, i;
/* Encode the DC coefficient difference per section 7.3.5.1 */
/* Encode the DC coefficient difference per section F.1.2.1 */
temp = temp2 = block[0];
@ -184,9 +182,10 @@ encode_one_block (JBLOCK block, HUFF_TBL *dctbl, HUFF_TBL *actbl)
/* Emit that number of bits of the value, if positive, */
/* or the complement of its magnitude, if negative. */
emit_bits((UINT16) temp2, nbits);
if (nbits) /* emit_bits rejects calls with size 0 */
emit_bits((UINT16) temp2, nbits);
/* Encode the AC coefficients per section 7.3.5.2 */
/* Encode the AC coefficients per section F.1.2.2 */
r = 0; /* r = run length of zeros */
@ -378,7 +377,7 @@ gen_huff_coding (compress_info_ptr cinfo, HUFF_TBL *htbl, long freq[])
int p, i, j;
long v;
/* This algorithm is explained in section 13.2 of JPEG-8-R8 */
/* This algorithm is explained in section K.2 of the JPEG standard */
MEMZERO((void *) bits, SIZEOF(bits));
MEMZERO((void *) codesize, SIZEOF(codesize));
@ -512,7 +511,7 @@ htest_one_block (JBLOCK block, JCOEF block0,
register int nbits;
register int k, r;
/* Encode the DC coefficient difference per section 7.3.5.1 */
/* Encode the DC coefficient difference per section F.1.2.1 */
/* Find the number of bits needed for the magnitude of the coefficient */
temp = block0;
@ -524,7 +523,7 @@ htest_one_block (JBLOCK block, JCOEF block0,
/* Count the Huffman symbol for the number of bits */
dc_counts[nbits]++;
/* Encode the AC coefficients per section 7.3.5.2 */
/* Encode the AC coefficients per section F.1.2.2 */
r = 0; /* r = run length of zeros */
@ -689,6 +688,15 @@ jselchuffman (compress_info_ptr cinfo)
cinfo->methods->entropy_encoder_term = huff_term;
#ifdef ENTROPY_OPT_SUPPORTED
cinfo->methods->entropy_optimize = huff_optimize;
/* The standard Huffman tables are only valid for 8-bit data precision.
* If the precision is higher, force optimization on so that usable
* tables will be computed. This test can be removed if default tables
* are supplied that are valid for the desired precision.
*/
if (cinfo->data_precision > 8)
cinfo->optimize_coding = TRUE;
if (cinfo->optimize_coding)
cinfo->total_passes++; /* one pass needed for entropy optimization */
#endif
}
}

View File

@ -1,7 +1,7 @@
/*
* jcmain.c
*
* Copyright (C) 1991, Thomas G. Lane.
* Copyright (C) 1991, 1992, 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.
*
@ -24,6 +24,9 @@
#ifdef INCLUDES_ARE_ANSI
#include <stdlib.h> /* to declare exit() */
#endif
#ifdef NEED_SIGNAL_CATCHER
#include <signal.h> /* to declare signal() */
#endif
#ifdef THINK_C
#include <console.h> /* command-line reader for Macintosh */
@ -37,6 +40,18 @@
#define WRITE_BINARY "wb"
#endif
#ifndef EXIT_FAILURE /* define exit() codes if not provided */
#define EXIT_FAILURE 1
#endif
#ifndef EXIT_SUCCESS
#ifdef VMS
#define EXIT_SUCCESS 1 /* VMS is very nonstandard */
#else
#define EXIT_SUCCESS 0
#endif
#endif
#include "jversion.h" /* for version message */
@ -149,18 +164,39 @@ c_ui_method_selection (compress_info_ptr cinfo)
}
/*
* Signal catcher to ensure that temporary files are removed before aborting.
* NB: for Amiga Manx C this is actually a global routine named _abort();
* see -Dsignal_catcher=_abort in CFLAGS. Talk about bogus...
*/
#ifdef NEED_SIGNAL_CATCHER
static external_methods_ptr emethods; /* for access to free_all */
GLOBAL void
signal_catcher (int signum)
{
emethods->trace_level = 0; /* turn off trace output */
(*emethods->free_all) (); /* clean up memory allocation & temp files */
exit(EXIT_FAILURE);
}
#endif
LOCAL void
usage (char * progname)
/* complain about bad command line */
{
fprintf(stderr, "usage: %s ", progname);
fprintf(stderr, "[-Q quality 0..100] [-o] [-T] [-I] [-a] [-d]");
fprintf(stderr, "[-Q quality 0..100] [-o] [-T] [-I] [-a] [-d] [-m mem]");
#ifdef TWO_FILE_COMMANDLINE
fprintf(stderr, " inputfile outputfile\n");
#else
fprintf(stderr, " [inputfile]\n");
#endif
exit(2);
exit(EXIT_FAILURE);
}
@ -168,7 +204,7 @@ usage (char * progname)
* The main program.
*/
GLOBAL void
GLOBAL int
main (int argc, char **argv)
{
struct compress_info_struct cinfo;
@ -185,16 +221,25 @@ main (int argc, char **argv)
cinfo.methods = &c_methods;
cinfo.emethods = &e_methods;
jselerror(&e_methods); /* error/trace message routines */
jselvirtmem(&e_methods); /* memory allocation routines */
jselmemmgr(&e_methods); /* memory allocation routines */
c_methods.c_ui_method_selection = c_ui_method_selection;
/* Now OK to enable signal catcher. */
#ifdef NEED_SIGNAL_CATCHER
emethods = &e_methods;
signal(SIGINT, signal_catcher);
#ifdef SIGTERM /* not all systems have SIGTERM */
signal(SIGTERM, signal_catcher);
#endif
#endif
/* Set up default JPEG parameters. */
j_c_defaults(&cinfo, 75, FALSE); /* default quality level = 75 */
is_targa = FALSE;
/* Scan command line options, adjust parameters */
while ((c = egetopt(argc, argv, "IQ:Taod")) != EOF)
while ((c = egetopt(argc, argv, "IQ:Taom:d")) != EOF)
switch (c) {
case 'I': /* Create noninterleaved file. */
#ifdef MULTISCAN_FILES_SUPPORTED
@ -202,7 +247,7 @@ main (int argc, char **argv)
#else
fprintf(stderr, "%s: sorry, multiple-scan support was not compiled\n",
argv[0]);
exit(2);
exit(EXIT_FAILURE);
#endif
break;
case 'Q': /* Quality factor. */
@ -227,7 +272,7 @@ main (int argc, char **argv)
#else
fprintf(stderr, "%s: sorry, arithmetic coding not supported\n",
argv[0]);
exit(2);
exit(EXIT_FAILURE);
#endif
break;
case 'o': /* Enable entropy parm optimization. */
@ -236,9 +281,22 @@ main (int argc, char **argv)
#else
fprintf(stderr, "%s: sorry, entropy optimization was not compiled\n",
argv[0]);
exit(2);
exit(EXIT_FAILURE);
#endif
break;
case 'm': /* Maximum memory in Kb (or Mb with 'm'). */
{ long lval;
char ch = 'x';
if (optarg == NULL)
usage(argv[0]);
if (sscanf(optarg, "%ld%c", &lval, &ch) < 1)
usage(argv[0]);
if (ch == 'm' || ch == 'M')
lval *= 1000L;
e_methods.max_memory_to_use = lval * 1000L;
}
break;
case 'd': /* Debugging. */
e_methods.trace_level++;
break;
@ -263,11 +321,11 @@ main (int argc, char **argv)
}
if ((cinfo.input_file = fopen(argv[optind], READ_BINARY)) == NULL) {
fprintf(stderr, "%s: can't open %s\n", argv[0], argv[optind]);
exit(2);
exit(EXIT_FAILURE);
}
if ((cinfo.output_file = fopen(argv[optind+1], WRITE_BINARY)) == NULL) {
fprintf(stderr, "%s: can't open %s\n", argv[0], argv[optind+1]);
exit(2);
exit(EXIT_FAILURE);
}
#else /* not TWO_FILE_COMMANDLINE -- use Unix style */
@ -282,7 +340,7 @@ main (int argc, char **argv)
if (optind < argc) {
if ((cinfo.input_file = fopen(argv[optind], READ_BINARY)) == NULL) {
fprintf(stderr, "%s: can't open %s\n", argv[0], argv[optind]);
exit(2);
exit(EXIT_FAILURE);
}
}
@ -294,13 +352,7 @@ main (int argc, char **argv)
/* Do it to it! */
jpeg_compress(&cinfo);
/* Release memory. */
j_c_free_defaults(&cinfo);
#ifdef MEM_STATS
if (e_methods.trace_level > 0) /* Optional memory-usage statistics */
j_mem_stats();
#endif
/* All done. */
exit(0);
exit(EXIT_SUCCESS);
return 0; /* suppress no-return-value warnings */
}

View File

@ -1,7 +1,7 @@
/*
* jcmaster.c
*
* Copyright (C) 1991, Thomas G. Lane.
* Copyright (C) 1991, 1992, 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.
*
@ -92,6 +92,10 @@ initial_setup (compress_info_ptr cinfo)
GLOBAL void
jpeg_compress (compress_info_ptr cinfo)
{
/* Init pass counts to 0 --- total_passes is adjusted in method selection */
cinfo->total_passes = 0;
cinfo->completed_passes = 0;
/* Read the input file header: determine image size & component count.
* NOTE: the user interface must have initialized the input_init method
* pointer (eg, by calling jselrppm) before calling me.
@ -123,5 +127,7 @@ jpeg_compress (compress_info_ptr cinfo)
(*cinfo->methods->colorin_term) (cinfo);
(*cinfo->methods->input_term) (cinfo);
(*cinfo->emethods->free_all) ();
/* My, that was easy, wasn't it? */
}

View File

@ -1,7 +1,7 @@
/*
* jcmcu.c
*
* Copyright (C) 1991, Thomas G. Lane.
* Copyright (C) 1991, 1992, 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.
*

View File

@ -1,7 +1,7 @@
/*
* jconfig.h
*
* Copyright (C) 1991, Thomas G. Lane.
* Copyright (C) 1991, 1992, 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.
*
@ -20,10 +20,23 @@
* predefined by such compilers.
*/
/*
* HAVE_STDC is tested below to see whether ANSI features are available.
* We avoid testing __STDC__ directly for arcane reasons of portability.
* (On some compilers, __STDC__ is only defined if a switch is given,
* but the switch also disables machine-specific features we need to get at.
* In that case, -DHAVE_STDC in the Makefile is a convenient solution.)
*/
#ifdef __STDC__ /* if compiler claims to be ANSI, believe it */
#define HAVE_STDC
#endif
/* Does your compiler support function prototypes? */
/* (If not, you also need to use ansi2knr, see SETUP) */
#ifdef __STDC__ /* ANSI C compilers always have prototypes */
#ifdef HAVE_STDC /* ANSI C compilers always have prototypes */
#define PROTO
#else
#ifdef __cplusplus /* So do C++ compilers */
@ -34,7 +47,7 @@
/* Does your compiler support the declaration "unsigned char" ? */
/* How about "unsigned short" ? */
#ifdef __STDC__ /* ANSI C compilers must support both */
#ifdef HAVE_STDC /* ANSI C compilers must support both */
#define HAVE_UNSIGNED_CHAR
#define HAVE_UNSIGNED_SHORT
#endif
@ -49,7 +62,6 @@
/* Define this if your compiler implements ">>" on signed values as a logical
* (unsigned) shift; leave it undefined if ">>" is a signed (arithmetic) shift,
* which is the normal and rational definition.
* The DCT and IDCT routines will compute wrong values if you get this wrong!
*/
/* #define RIGHT_SHIFT_IS_UNSIGNED */
@ -64,7 +76,7 @@
/* Define const as empty if your compiler doesn't know the "const" keyword. */
/* (Even if it does, defining const as empty won't break anything.) */
#ifndef __STDC__ /* ANSI C and C++ compilers should know it. */
#ifndef HAVE_STDC /* ANSI C and C++ compilers should know it. */
#ifndef __cplusplus
#define const
#endif
@ -77,16 +89,12 @@
* "far" pointers and to be allocated with a special version of malloc.)
*/
#ifdef MSDOS /* Microsoft C and compatibles */
#ifdef MSDOS
#define NEED_FAR_POINTERS
#else
#ifdef __TURBOC__ /* Turbo C doesn't define MSDOS */
#define NEED_FAR_POINTERS
#endif
#endif
/* The next couple of symbols only affect the system-dependent user interface
/* The next three symbols only affect the system-dependent user interface
* modules (jcmain.c, jdmain.c). You can ignore these if you are supplying
* your own user interface code.
*/
@ -99,15 +107,20 @@
#ifdef MSDOS /* two-file style is needed for PCs */
#define TWO_FILE_COMMANDLINE
#else
#ifdef __TURBOC__ /* Turbo C doesn't define MSDOS */
#define TWO_FILE_COMMANDLINE
#endif
#endif
#ifdef THINK_C /* needed for Macintosh too */
#define TWO_FILE_COMMANDLINE
#endif
/* Define this if your system needs explicit cleanup of temporary files.
* This is crucial under MS-DOS, where the temporary "files" may be areas
* of extended memory; on most other systems it's not as important.
*/
#ifdef MSDOS
#define NEED_SIGNAL_CATCHER
#endif
/* By default, we open image files with fopen(...,"rb") or fopen(...,"wb").
* This is necessary on systems that distinguish text files from binary files,
* and is harmless on most systems that don't. If you have one of the rare
@ -122,16 +135,6 @@
*/
/* If your compiler supports inline functions, define INLINE as
* the inline keyword; otherwise define it as empty.
*/
#ifdef __GNUC__ /* GNU C has inline... */
#define INLINE inline
#else /* ...but I don't think anyone else does. */
#define INLINE
#endif
/* On a few systems, type boolean and/or macros FALSE, TRUE may appear
* in standard header files. Or you may have conflicts with application-
* specific header files that you want to include together with these files.
@ -168,13 +171,13 @@ typedef int boolean;
#define ENTROPY_OPT_SUPPORTED /* Optimization of entropy coding parms? */
#define BLOCK_SMOOTHING_SUPPORTED /* Block smoothing during decoding? */
#define QUANT_1PASS_SUPPORTED /* 1-pass color quantization? */
#undef QUANT_2PASS_SUPPORTED /* 2-pass color quantization? (not yet impl.) */
#define QUANT_2PASS_SUPPORTED /* 2-pass color quantization? */
/* these defines indicate which JPEG file formats are allowed */
#define JFIF_SUPPORTED /* JFIF or "raw JPEG" files */
#undef JTIFF_SUPPORTED /* JPEG-in-TIFF (not yet implemented) */
/* these defines indicate which image (non-JPEG) file formats are allowed */
#define GIF_SUPPORTED /* GIF image file format */
/* #define RLE_SUPPORTED */ /* RLE image file format */
/* #define RLE_SUPPORTED */ /* RLE image file format (by default, no) */
#define PPM_SUPPORTED /* PPM/PGM image file format */
#define TARGA_SUPPORTED /* Targa image file format */
#undef TIFF_SUPPORTED /* TIFF image file format (not yet impl.) */
@ -190,6 +193,11 @@ typedef int boolean;
* color value. 16-bit should only be used for the lossless JPEG mode (not
* currently supported). Note that 12- and 16-bit values take up twice as
* much memory as 8-bit!
* Note: if you select 12- or 16-bit precision, it is dangerous to turn off
* ENTROPY_OPT_SUPPORTED. The standard Huffman tables are only good for 8-bit
* precision, so jchuff.c normally uses entropy optimization to compute
* usable tables for higher precision. If you don't want to do optimization,
* you'll have to supply different default Huffman tables.
*/
#define EIGHT_BIT_SAMPLES
@ -209,8 +217,6 @@ typedef int boolean;
/* First define the representation of a single pixel element value. */
#ifdef EIGHT_BIT_SAMPLES
#define BITS_IN_JSAMPLE 8
/* JSAMPLE should be the smallest type that will hold the values 0..255.
* You can use a signed char by having GETJSAMPLE mask it with 0xFF.
* If you have only signed chars, and you are more worried about speed than
@ -236,6 +242,7 @@ typedef char JSAMPLE;
#endif /* CHAR_IS_UNSIGNED */
#endif /* HAVE_UNSIGNED_CHAR */
#define BITS_IN_JSAMPLE 8
#define MAXJSAMPLE 255
#define CENTERJSAMPLE 128
@ -243,14 +250,13 @@ typedef char JSAMPLE;
#ifdef TWELVE_BIT_SAMPLES
#define BITS_IN_JSAMPLE 12
/* JSAMPLE should be the smallest type that will hold the values 0..4095. */
/* On nearly all machines "short" will do nicely. */
typedef short JSAMPLE;
#define GETJSAMPLE(value) (value)
#define BITS_IN_JSAMPLE 12
#define MAXJSAMPLE 4095
#define CENTERJSAMPLE 2048
@ -258,8 +264,6 @@ typedef short JSAMPLE;
#ifdef SIXTEEN_BIT_SAMPLES
#define BITS_IN_JSAMPLE 16
/* JSAMPLE should be the smallest type that will hold the values 0..65535. */
#ifdef HAVE_UNSIGNED_SHORT
@ -278,6 +282,7 @@ typedef unsigned int JSAMPLE;
#endif /* HAVE_UNSIGNED_SHORT */
#define BITS_IN_JSAMPLE 16
#define MAXJSAMPLE 65535
#define CENTERJSAMPLE 32768

View File

@ -1,7 +1,7 @@
/*
* jcpipe.c
*
* Copyright (C) 1991, Thomas G. Lane.
* Copyright (C) 1991, 1992, 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.
*
@ -169,18 +169,17 @@ alloc_sampling_buffer (compress_info_ptr cinfo, JSAMPIMAGE fullsize_data[2],
}
#if 0 /* this routine not currently needed */
LOCAL void
free_sampling_buffer (compress_info_ptr cinfo, JSAMPIMAGE fullsize_data[2])
/* Release a sampling buffer created by alloc_sampling_buffer */
{
short ci, vs;
vs = cinfo->max_v_samp_factor; /* row group height */
short ci;
for (ci = 0; ci < cinfo->num_components; ci++) {
/* Free the real storage */
(*cinfo->emethods->free_small_sarray)
(fullsize_data[0][ci], (long) (vs * (DCTSIZE+2)));
(*cinfo->emethods->free_small_sarray) (fullsize_data[0][ci]);
/* Free the scrambled-order pointers */
(*cinfo->emethods->free_small) ((void *) fullsize_data[1][ci]);
}
@ -190,6 +189,8 @@ free_sampling_buffer (compress_info_ptr cinfo, JSAMPIMAGE fullsize_data[2])
(*cinfo->emethods->free_small) ((void *) fullsize_data[1]);
}
#endif
LOCAL void
subsample (compress_info_ptr cinfo,
@ -302,6 +303,8 @@ dump_scan_MCUs (compress_info_ptr cinfo, MCU_output_method_ptr output_method)
next_index = MCUs_in_big_row;
for (mcurow = 0; mcurow < cinfo->MCU_rows_in_scan; mcurow++) {
(*cinfo->methods->progress_monitor) (cinfo, mcurow,
cinfo->MCU_rows_in_scan);
for (mcuindex = 0; mcuindex < cinfo->MCUs_per_row; mcuindex++) {
if (next_index >= MCUs_in_big_row) {
rowptr = (*cinfo->emethods->access_big_barray) (whole_scan_MCUs,
@ -311,7 +314,7 @@ dump_scan_MCUs (compress_info_ptr cinfo, MCU_output_method_ptr output_method)
}
#ifdef NEED_FAR_POINTERS
jcopy_block_row(rowptr[0] + next_index * cinfo->blocks_in_MCU,
(JBLOCKROW) MCU_data, /* note cast */
(JBLOCKROW) MCU_data, /* casts near to far pointer! */
(long) cinfo->blocks_in_MCU);
(*output_method) (cinfo, MCU_data);
#else
@ -320,6 +323,8 @@ dump_scan_MCUs (compress_info_ptr cinfo, MCU_output_method_ptr output_method)
next_index++;
}
}
cinfo->completed_passes++;
}
@ -360,6 +365,7 @@ single_ccontroller (compress_info_ptr cinfo)
/* in an interleaved scan, one MCU row contains Vk block rows */
mcu_rows_per_loop = 1;
}
cinfo->total_passes++;
/* Compute dimensions of full-size pixel buffers */
/* Note these are the same whether interleaved or not. */
@ -403,6 +409,9 @@ single_ccontroller (compress_info_ptr cinfo)
for (cur_pixel_row = 0; cur_pixel_row < cinfo->image_height;
cur_pixel_row += rows_in_mem) {
(*cinfo->methods->progress_monitor) (cinfo, cur_pixel_row,
cinfo->image_height);
whichss ^= 1; /* switch to other fullsize_data buffer */
/* Obtain rows_this_time pixel rows and expand to rows_in_mem rows. */
@ -463,15 +472,10 @@ single_ccontroller (compress_info_ptr cinfo)
(*cinfo->methods->subsample_term) (cinfo);
(*cinfo->methods->entropy_encoder_term) (cinfo);
(*cinfo->methods->write_scan_trailer) (cinfo);
cinfo->completed_passes++;
/* Release working memory */
free_sampling_buffer(cinfo, fullsize_data);
for (ci = 0; ci < cinfo->num_components; ci++) {
(*cinfo->emethods->free_small_sarray)
(subsampled_data[ci],
(long) (cinfo->comp_info[ci].v_samp_factor * DCTSIZE));
}
(*cinfo->emethods->free_small) ((void *) subsampled_data);
/* (no work -- we let free_all release what's needful) */
}
@ -514,6 +518,7 @@ single_eopt_ccontroller (compress_info_ptr cinfo)
/* in an interleaved scan, one MCU row contains Vk block rows */
mcu_rows_per_loop = 1;
}
cinfo->total_passes += 2; /* entropy encoder must add # passes it uses */
/* Compute dimensions of full-size pixel buffers */
/* Note these are the same whether interleaved or not. */
@ -566,6 +571,9 @@ single_eopt_ccontroller (compress_info_ptr cinfo)
for (cur_pixel_row = 0; cur_pixel_row < cinfo->image_height;
cur_pixel_row += rows_in_mem) {
(*cinfo->methods->progress_monitor) (cinfo, cur_pixel_row,
cinfo->image_height);
whichss ^= 1; /* switch to other fullsize_data buffer */
/* Obtain rows_this_time pixel rows and expand to rows_in_mem rows. */
@ -626,6 +634,8 @@ single_eopt_ccontroller (compress_info_ptr cinfo)
(*cinfo->methods->extract_term) (cinfo);
(*cinfo->methods->subsample_term) (cinfo);
cinfo->completed_passes++;
(*cinfo->methods->entropy_optimize) (cinfo, dump_scan_MCUs);
/* Emit scan to output file */
@ -639,14 +649,7 @@ single_eopt_ccontroller (compress_info_ptr cinfo)
(*cinfo->methods->write_scan_trailer) (cinfo);
/* Release working memory */
free_sampling_buffer(cinfo, fullsize_data);
for (ci = 0; ci < cinfo->num_components; ci++) {
(*cinfo->emethods->free_small_sarray)
(subsampled_data[ci],
(long) (cinfo->comp_info[ci].v_samp_factor * DCTSIZE));
}
(*cinfo->emethods->free_small) ((void *) subsampled_data);
(*cinfo->emethods->free_big_barray) (whole_scan_MCUs);
/* (no work -- we let free_all release what's needful) */
}
#endif /* ENTROPY_OPT_SUPPORTED */

View File

@ -1,7 +1,7 @@
/*
* jcsample.c
*
* Copyright (C) 1991, Thomas G. Lane.
* Copyright (C) 1991, 1992, 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.
*

View File

@ -1,7 +1,7 @@
/*
* jdarith.c
*
* Copyright (C) 1991, Thomas G. Lane.
* Copyright (C) 1991, 1992, 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.
*

198
jdcolor.c
View File

@ -1,7 +1,7 @@
/*
* jdcolor.c
*
* Copyright (C) 1991, Thomas G. Lane.
* Copyright (C) 1991, 1992, 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.
*
@ -13,34 +13,107 @@
#include "jinclude.h"
/**************** YCbCr -> RGB conversion: most common case **************/
/*
* YCbCr is defined per CCIR 601-1, except that Cb and Cr are
* normalized to the range 0..MAXJSAMPLE rather than -0.5 .. 0.5.
* The conversion equations to be implemented are therefore
* R = Y + 1.40200 * Cr
* G = Y - 0.34414 * Cb - 0.71414 * Cr
* B = Y + 1.77200 * Cb
* where Cb and Cr represent the incoming values less MAXJSAMPLE/2.
* (These numbers are derived from TIFF Appendix O, draft of 4/10/91.)
*
* To avoid floating-point arithmetic, we represent the fractional constants
* as integers scaled up by 2^14 (about 4 digits precision); we have to divide
* the products by 2^14, with appropriate rounding, to get the correct answer.
* Notice that Y, being an integral input, does not contribute any fraction
* so it need not participate in the rounding.
*
* For even more speed, we avoid doing any multiplications in the inner loop
* by precalculating the constants times Cb and Cr for all possible values.
* For 8-bit JSAMPLEs this is very reasonable (only 256 table entries); for
* 12-bit samples it is still acceptable. It's not very reasonable for 16-bit
* samples, but if you want lossless storage you shouldn't be changing
* colorspace anyway.
* The Cr=>R and Cb=>B values can be rounded to integers in advance; the
* values for the G calculation are left scaled up, since we must add them
* together before rounding.
*/
#define SCALEBITS 14
#define ONE_HALF ((INT32) 1 << (SCALEBITS-1))
#define FIX(x) ((INT32) ((x) * (1L<<SCALEBITS) + 0.5))
static INT16 * Cr_r_tab; /* => table for Cr to R conversion */
static INT16 * Cb_b_tab; /* => table for Cb to B conversion */
static INT32 * Cr_g_tab; /* => table for Cr to G conversion */
static INT32 * Cb_g_tab; /* => table for Cb to G conversion */
/*
* Initialize for colorspace conversion.
*/
METHODDEF void
colorout_init (decompress_info_ptr cinfo)
ycc_rgb_init (decompress_info_ptr cinfo)
{
/* no work needed */
#ifdef SIXTEEN_BIT_SAMPLES
INT32 i, x2;
#else
int i, x2; /* smart compiler may do 16x16=>32 multiply */
#endif
SHIFT_TEMPS
Cr_r_tab = (INT16 *) (*cinfo->emethods->alloc_small)
((MAXJSAMPLE+1) * SIZEOF(INT16));
Cb_b_tab = (INT16 *) (*cinfo->emethods->alloc_small)
((MAXJSAMPLE+1) * SIZEOF(INT16));
Cr_g_tab = (INT32 *) (*cinfo->emethods->alloc_small)
((MAXJSAMPLE+1) * SIZEOF(INT32));
Cb_g_tab = (INT32 *) (*cinfo->emethods->alloc_small)
((MAXJSAMPLE+1) * SIZEOF(INT32));
for (i = 0; i <= MAXJSAMPLE; i++) {
/* i is the actual input pixel value, in the range 0..MAXJSAMPLE */
/* The Cb or Cr value we are thinking of is x = i - MAXJSAMPLE/2 */
x2 = 2*i - MAXJSAMPLE; /* twice x */
/* Cr=>R value is nearest int to 1.40200 * x */
Cr_r_tab[i] = (INT16)
RIGHT_SHIFT(FIX(1.40200/2) * x2 + ONE_HALF, SCALEBITS);
/* Cb=>B value is nearest int to 1.77200 * x */
Cb_b_tab[i] = (INT16)
RIGHT_SHIFT(FIX(1.77200/2) * x2 + ONE_HALF, SCALEBITS);
/* Cr=>G value is scaled-up -0.71414 * x */
Cr_g_tab[i] = (- FIX(0.71414/2)) * x2;
/* Cb=>G value is scaled-up -0.34414 * x */
/* We also add in ONE_HALF so that need not do it in inner loop */
Cb_g_tab[i] = (- FIX(0.34414/2)) * x2 + ONE_HALF;
}
}
/*
* Convert some rows of samples to the output colorspace.
* This version handles YCbCr -> RGB conversion.
* YCbCr is defined per CCIR 601-1, except that Cb and Cr are
* normalized to the range 0..MAXJSAMPLE rather than -0.5 .. 0.5.
*/
METHODDEF void
ycc_rgb_convert (decompress_info_ptr cinfo, int num_rows,
ycc_rgb_convert (decompress_info_ptr cinfo, int num_rows, long num_cols,
JSAMPIMAGE input_data, JSAMPIMAGE output_data)
{
register INT32 y, u, v, x;
#ifdef SIXTEEN_BIT_SAMPLES
register UINT16 y, cb, cr;
register INT32 x;
#else
register int y, cb, cr;
register int x;
#endif
register JSAMPROW inptr0, inptr1, inptr2;
register JSAMPROW outptr0, outptr1, outptr2;
register long col;
register long width = cinfo->image_width;
register int row;
long col;
int row;
SHIFT_TEMPS
for (row = 0; row < num_rows; row++) {
inptr0 = input_data[0][row];
@ -49,45 +122,70 @@ ycc_rgb_convert (decompress_info_ptr cinfo, int num_rows,
outptr0 = output_data[0][row];
outptr1 = output_data[1][row];
outptr2 = output_data[2][row];
for (col = width; col > 0; col--) {
y = GETJSAMPLE(*inptr0++);
u = (int) GETJSAMPLE(*inptr1++) - CENTERJSAMPLE;
v = (int) GETJSAMPLE(*inptr2++) - CENTERJSAMPLE;
for (col = num_cols; col > 0; col--) {
y = GETJSAMPLE(*inptr0++);
cb = GETJSAMPLE(*inptr1++);
cr = GETJSAMPLE(*inptr2++);
/* Note: if the inputs were computed directly from RGB values,
* range-limiting would be unnecessary here; but due to possible
* noise in the DCT/IDCT phase, we do need to apply range limits.
*/
y *= 1024; /* in case compiler can't spot common subexpression */
x = y + 1436*v + 512; /* red */
x = y + Cr_r_tab[cr]; /* red */
if (x < 0) x = 0;
if (x > ((INT32) MAXJSAMPLE*1024)) x = (INT32) MAXJSAMPLE*1024;
*outptr0++ = (JSAMPLE) (x >> 10);
x = y - 352*u - 731*v + 512; /* green */
else if (x > MAXJSAMPLE) x = MAXJSAMPLE;
*outptr0++ = (JSAMPLE) x;
x = y + ((int) RIGHT_SHIFT(Cb_g_tab[cb] + Cr_g_tab[cr], SCALEBITS));
if (x < 0) x = 0;
if (x > ((INT32) MAXJSAMPLE*1024)) x = (INT32) MAXJSAMPLE*1024;
*outptr1++ = (JSAMPLE) (x >> 10);
x = y + 1815*u + 512; /* blue */
else if (x > MAXJSAMPLE) x = MAXJSAMPLE;
*outptr1++ = (JSAMPLE) x;
x = y + Cb_b_tab[cb]; /* blue */
if (x < 0) x = 0;
if (x > ((INT32) MAXJSAMPLE*1024)) x = (INT32) MAXJSAMPLE*1024;
*outptr2++ = (JSAMPLE) (x >> 10);
else if (x > MAXJSAMPLE) x = MAXJSAMPLE;
*outptr2++ = (JSAMPLE) x;
}
}
}
/*
* Finish up at the end of the file.
*/
METHODDEF void
ycc_rgb_term (decompress_info_ptr cinfo)
{
/* no work (we let free_all release the workspace) */
}
/**************** Cases other than YCbCr -> RGB **************/
/*
* Initialize for colorspace conversion.
*/
METHODDEF void
null_init (decompress_info_ptr cinfo)
/* colorout_init for cases where no setup is needed */
{
/* no work needed */
}
/*
* Color conversion for no colorspace change: just copy the data.
*/
METHODDEF void
null_convert (decompress_info_ptr cinfo, int num_rows,
null_convert (decompress_info_ptr cinfo, int num_rows, long num_cols,
JSAMPIMAGE input_data, JSAMPIMAGE output_data)
{
short ci;
for (ci = 0; ci < cinfo->num_components; ci++) {
jcopy_sample_rows(input_data[ci], 0, output_data[ci], 0,
num_rows, cinfo->image_width);
num_rows, num_cols);
}
}
@ -99,11 +197,11 @@ null_convert (decompress_info_ptr cinfo, int num_rows,
*/
METHODDEF void
grayscale_convert (decompress_info_ptr cinfo, int num_rows,
grayscale_convert (decompress_info_ptr cinfo, int num_rows, long num_cols,
JSAMPIMAGE input_data, JSAMPIMAGE output_data)
{
jcopy_sample_rows(input_data[0], 0, output_data[0], 0,
num_rows, cinfo->image_width);
num_rows, num_cols);
}
@ -112,12 +210,14 @@ grayscale_convert (decompress_info_ptr cinfo, int num_rows,
*/
METHODDEF void
colorout_term (decompress_info_ptr cinfo)
null_term (decompress_info_ptr cinfo)
/* colorout_term for cases where no teardown is needed */
{
/* no work needed */
}
/*
* The method selection routine for output colorspace conversion.
*/
@ -133,8 +233,8 @@ jseldcolor (decompress_info_ptr cinfo)
break;
case CS_RGB:
case CS_YIQ:
case CS_YCbCr:
case CS_YIQ:
if (cinfo->num_components != 3)
ERREXIT(cinfo->emethods, "Bogus JPEG colorspace");
break;
@ -155,32 +255,37 @@ jseldcolor (decompress_info_ptr cinfo)
cinfo->color_out_comps = 1;
if (cinfo->jpeg_color_space == CS_GRAYSCALE ||
cinfo->jpeg_color_space == CS_YCbCr ||
cinfo->jpeg_color_space == CS_YIQ)
cinfo->jpeg_color_space == CS_YIQ) {
cinfo->methods->color_convert = grayscale_convert;
else
cinfo->methods->colorout_init = null_init;
cinfo->methods->colorout_term = null_term;
} else
ERREXIT(cinfo->emethods, "Unsupported color conversion request");
break;
case CS_RGB:
cinfo->color_out_comps = 3;
if (cinfo->jpeg_color_space == CS_YCbCr)
if (cinfo->jpeg_color_space == CS_YCbCr) {
cinfo->methods->color_convert = ycc_rgb_convert;
else if (cinfo->jpeg_color_space == CS_RGB)
cinfo->methods->colorout_init = ycc_rgb_init;
cinfo->methods->colorout_term = ycc_rgb_term;
} else if (cinfo->jpeg_color_space == CS_RGB) {
cinfo->methods->color_convert = null_convert;
else
ERREXIT(cinfo->emethods, "Unsupported color conversion request");
break;
case CS_CMYK:
cinfo->color_out_comps = 4;
if (cinfo->jpeg_color_space == CS_CMYK)
cinfo->methods->color_convert = null_convert;
else
cinfo->methods->colorout_init = null_init;
cinfo->methods->colorout_term = null_term;
} else
ERREXIT(cinfo->emethods, "Unsupported color conversion request");
break;
default:
ERREXIT(cinfo->emethods, "Unsupported output colorspace");
/* Permit null conversion from CMYK or YCbCr to same output space */
if (cinfo->out_color_space == cinfo->jpeg_color_space) {
cinfo->color_out_comps = cinfo->num_components;
cinfo->methods->color_convert = null_convert;
cinfo->methods->colorout_init = null_init;
cinfo->methods->colorout_term = null_term;
} else /* unsupported non-null conversion */
ERREXIT(cinfo->emethods, "Unsupported color conversion request");
break;
}
@ -188,7 +293,4 @@ jseldcolor (decompress_info_ptr cinfo)
cinfo->final_out_comps = 1; /* single colormapped output component */
else
cinfo->final_out_comps = cinfo->color_out_comps;
cinfo->methods->colorout_init = colorout_init;
cinfo->methods->colorout_term = colorout_term;
}

View File

@ -1,7 +1,7 @@
/*
* jddeflts.c
*
* Copyright (C) 1991, Thomas G. Lane.
* Copyright (C) 1991, 1992, 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.
*
@ -13,19 +13,45 @@
#include "jinclude.h"
/* Default do-nothing progress monitoring routine.
* This can be overridden by a user interface that wishes to
* provide progress monitoring; just set methods->progress_monitor
* after j_d_defaults is done. The routine will be called periodically
* during the decompression process.
*
* During any one pass, loopcounter increases from 0 up to (not including)
* looplimit; the step size is not necessarily 1. Both the step size and
* the limit may differ between passes. The expected total number of passes
* is in cinfo->total_passes, and the number of passes already completed is
* in cinfo->completed_passes. Thus the fraction of work completed may be
* estimated as
* completed_passes + (loopcounter/looplimit)
* ------------------------------------------
* total_passes
* ignoring the fact that the passes may not be equal amounts of work.
*
* When decompressing, the total_passes figure is an estimate that may be
* on the high side; completed_passes will jump by more than one if some
* passes are skipped.
*/
METHODDEF void
progress_monitor (decompress_info_ptr cinfo, long loopcounter, long looplimit)
{
/* do nothing */
}
/*
* Reload the input buffer after it's been emptied, and return the next byte.
* See the JGETC macro for calling conditions.
*
* This routine is used only if the system-dependent user interface passes
* standard_buffering = TRUE to j_d_defaults. Otherwise, the UI must supply
* a corresponding routine. Note that in any case, this routine is likely
* to be used only for JFIF or similar serial-access JPEG file formats.
* The input file control module for a random-access format such as TIFF/JPEG
* would need to override the read_jpeg_data method with its own routine.
*
* This routine would need to be replaced if reading JPEG data from something
* other than a stdio stream.
* This routine can be overridden by the system-dependent user interface,
* in case the data source is not a stdio stream or some other special
* condition applies. Note, however, that this capability only applies for
* JFIF or similar serial-access JPEG file formats. The input file control
* module for a random-access format such as TIFF/JPEG would most likely
* override the read_jpeg_data method with its own routine.
*/
METHODDEF int
@ -33,9 +59,9 @@ read_jpeg_data (decompress_info_ptr cinfo)
{
cinfo->next_input_byte = cinfo->input_buffer + MIN_UNGET;
cinfo->bytes_in_buffer = (int) FREAD(cinfo->input_file,
cinfo->next_input_byte,
JPEG_BUF_SIZE);
cinfo->bytes_in_buffer = (int) JFREAD(cinfo->input_file,
cinfo->next_input_byte,
JPEG_BUF_SIZE);
if (cinfo->bytes_in_buffer <= 0)
ERREXIT(cinfo->emethods, "Unexpected EOF in JPEG file");
@ -53,19 +79,43 @@ read_jpeg_data (decompress_info_ptr cinfo)
* is the recommended approach since, if we add any new parameters,
* your code will still work (they'll be set to reasonable defaults).
*
* standard_buffering should be TRUE if the JPEG data is to come from
* a stdio stream and the user interface isn't interested in changing
* the normal input-buffering logic. If FALSE is passed, the user
* interface must provide its own read_jpeg_data method and must
* set up its own input buffer. (Alternately, you can pass TRUE to
* let the buffer be allocated here, then override read_jpeg_data with
* your own routine.)
* standard_buffering should be TRUE to cause an input buffer to be allocated
* (the normal case); if FALSE, the user interface must provide a buffer.
* This option is most useful in the case that the buffer must not be freed
* at the end of an image. (For example, when reading a sequence of images
* from a single file, the remaining data in the buffer represents the
* start of the next image and mustn't be discarded.) To handle this,
* allocate the input buffer yourself at startup, WITHOUT using alloc_small
* (probably a direct call to malloc() instead). Then pass FALSE on each
* call to j_d_defaults to ensure the buffer state is not modified.
*
* If the source of the JPEG data is not a stdio stream, override the
* read_jpeg_data method with your own routine after calling j_d_defaults.
* You can still use the standard buffer if it's appropriate.
*
* CAUTION: if you want to decompress multiple images per run, it's necessary
* to call j_d_defaults before *each* call to jpeg_decompress, since subsidiary
* structures like the quantization tables are automatically freed during
* cleanup.
*/
GLOBAL void
j_d_defaults (decompress_info_ptr cinfo, boolean standard_buffering)
/* NB: the external methods must already be set up. */
{
short i;
/* Initialize pointers as needed to mark stuff unallocated. */
/* Outer application may fill in default tables for abbreviated files... */
cinfo->comp_info = NULL;
for (i = 0; i < NUM_QUANT_TBLS; i++)
cinfo->quant_tbl_ptrs[i] = NULL;
for (i = 0; i < NUM_HUFF_TBLS; i++) {
cinfo->dc_huff_tbl_ptrs[i] = NULL;
cinfo->ac_huff_tbl_ptrs[i] = NULL;
}
cinfo->colormap = NULL;
/* Default to RGB output */
/* UI can override by changing out_color_space */
cinfo->out_color_space = CS_RGB;
@ -81,7 +131,7 @@ j_d_defaults (decompress_info_ptr cinfo, boolean standard_buffering)
cinfo->quantize_colors = FALSE;
/* but set reasonable default parameters for quantization, */
/* so that turning on quantize_colors is sufficient to do something useful */
cinfo->two_pass_quantize = FALSE; /* may change to TRUE later */
cinfo->two_pass_quantize = TRUE;
cinfo->use_dithering = TRUE;
cinfo->desired_number_of_colors = 256;
@ -89,29 +139,16 @@ j_d_defaults (decompress_info_ptr cinfo, boolean standard_buffering)
cinfo->do_block_smoothing = FALSE;
cinfo->do_pixel_smoothing = FALSE;
/* Allocate memory for input buffer, unless outer application provides it. */
if (standard_buffering) {
/* Allocate memory for input buffer. */
cinfo->input_buffer = (char *) (*cinfo->emethods->alloc_small)
((size_t) (JPEG_BUF_SIZE + MIN_UNGET));
cinfo->bytes_in_buffer = 0; /* initialize buffer to empty */
/* Install standard buffer-reloading method. */
cinfo->methods->read_jpeg_data = read_jpeg_data;
}
}
/* This routine releases storage allocated by j_d_defaults.
* Note that freeing the method pointer structs and the decompress_info_struct
* itself are the responsibility of the user interface.
*
* standard_buffering must agree with what was passed to j_d_defaults.
*/
GLOBAL void
j_d_free_defaults (decompress_info_ptr cinfo, boolean standard_buffering)
{
if (standard_buffering) {
(*cinfo->emethods->free_small) ((void *) cinfo->input_buffer);
}
/* Install standard buffer-reloading method (outer code may override). */
cinfo->methods->read_jpeg_data = read_jpeg_data;
/* Install default do-nothing progress monitoring method. */
cinfo->methods->progress_monitor = progress_monitor;
}

View File

@ -1,7 +1,7 @@
/*
* jdhuff.c
*
* Copyright (C) 1991, Thomas G. Lane.
* Copyright (C) 1991, 1992, 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.
*
@ -25,12 +25,12 @@ LOCAL void
fix_huff_tbl (HUFF_TBL * htbl)
/* Compute derived values for a Huffman table */
{
int p, i, l, lastp, si;
int p, i, l, si;
char huffsize[257];
UINT16 huffcode[257];
UINT16 code;
/* Figure 7.3.5.4.2.1: make table of Huffman code length for each symbol */
/* Figure C.1: make table of Huffman code length for each symbol */
/* Note that this is in code-length order. */
p = 0;
@ -39,9 +39,8 @@ fix_huff_tbl (HUFF_TBL * htbl)
huffsize[p++] = (char) l;
}
huffsize[p] = 0;
lastp = p;
/* Figure 7.3.5.4.2.2: generate the codes themselves */
/* Figure C.2: generate the codes themselves */
/* Note that this is in code-length order. */
code = 0;
@ -55,16 +54,11 @@ fix_huff_tbl (HUFF_TBL * htbl)
code <<= 1;
si++;
}
/* Figure 7.3.5.4.2.3: generate encoding tables */
/* These are code and size indexed by symbol value */
for (p = 0; p < lastp; p++) {
htbl->ehufco[htbl->huffval[p]] = huffcode[p];
htbl->ehufsi[htbl->huffval[p]] = huffsize[p];
}
/* Figure 13.4.2.3.1: generate decoding tables */
/* We don't bother to fill in the encoding tables ehufco[] and ehufsi[], */
/* since they are not used for decoding. */
/* Figure F.15: generate decoding tables */
p = 0;
for (l = 1; l <= 16; l++) {
@ -115,7 +109,7 @@ get_bits (int nbits)
get_bits(1))
/* Figure 13.4.2.3.2: extract next coded symbol from input stream */
/* Figure F.16: extract next coded symbol from input stream */
LOCAL int
huff_DECODE (HUFF_TBL * htbl)
@ -142,7 +136,7 @@ huff_DECODE (HUFF_TBL * htbl)
}
/* Figure 13.4.2.1.1: extend sign bit */
/* Figure F.12: extend sign bit */
/* NB: on some compilers this will only work for s > 0 */
@ -163,7 +157,7 @@ decode_one_block (JBLOCK block, HUFF_TBL *dctbl, HUFF_TBL *actbl)
MEMZERO((void *) block, SIZEOF(JBLOCK));
/* Section 13.4.2.1: decode the DC coefficient difference */
/* Section F.2.2.1: decode the DC coefficient difference */
s = huff_DECODE(dctbl);
if (s) {
@ -172,7 +166,7 @@ decode_one_block (JBLOCK block, HUFF_TBL *dctbl, HUFF_TBL *actbl)
}
block[0] = s;
/* Section 13.4.2.2: decode the AC coefficients */
/* Section F.2.2.2: decode the AC coefficients */
for (k = 1; k < DCTSIZE2; k++) {
r = huff_DECODE(actbl);

View File

@ -1,7 +1,7 @@
/*
* jdmain.c
*
* Copyright (C) 1991, Thomas G. Lane.
* Copyright (C) 1991, 1992, 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.
*
@ -24,6 +24,9 @@
#ifdef INCLUDES_ARE_ANSI
#include <stdlib.h> /* to declare exit() */
#endif
#ifdef NEED_SIGNAL_CATCHER
#include <signal.h> /* to declare signal() */
#endif
#ifdef THINK_C
#include <console.h> /* command-line reader for Macintosh */
@ -37,6 +40,18 @@
#define WRITE_BINARY "wb"
#endif
#ifndef EXIT_FAILURE /* define exit() codes if not provided */
#define EXIT_FAILURE 1
#endif
#ifndef EXIT_SUCCESS
#ifdef VMS
#define EXIT_SUCCESS 1 /* VMS is very nonstandard */
#else
#define EXIT_SUCCESS 0
#endif
#endif
#include "jversion.h" /* for version message */
@ -117,18 +132,39 @@ d_ui_method_selection (decompress_info_ptr cinfo)
}
/*
* Signal catcher to ensure that temporary files are removed before aborting.
* NB: for Amiga Manx C this is actually a global routine named _abort();
* see -Dsignal_catcher=_abort in CFLAGS. Talk about bogus...
*/
#ifdef NEED_SIGNAL_CATCHER
static external_methods_ptr emethods; /* for access to free_all */
GLOBAL void
signal_catcher (int signum)
{
emethods->trace_level = 0; /* turn off trace output */
(*emethods->free_all) (); /* clean up memory allocation & temp files */
exit(EXIT_FAILURE);
}
#endif
LOCAL void
usage (char * progname)
/* complain about bad command line */
{
fprintf(stderr, "usage: %s ", progname);
fprintf(stderr, "[-G] [-P] [-R] [-T] [-b] [-g] [-q colors] [-2] [-D] [-d]");
fprintf(stderr, "[-G] [-P] [-R] [-T] [-b] [-g] [-q colors] [-1] [-D] [-d] [-m mem]");
#ifdef TWO_FILE_COMMANDLINE
fprintf(stderr, " inputfile outputfile\n");
#else
fprintf(stderr, " [inputfile]\n");
#endif
exit(2);
exit(EXIT_FAILURE);
}
@ -136,7 +172,7 @@ usage (char * progname)
* The main program.
*/
GLOBAL void
GLOBAL int
main (int argc, char **argv)
{
struct decompress_info_struct cinfo;
@ -153,16 +189,25 @@ main (int argc, char **argv)
cinfo.methods = &dc_methods;
cinfo.emethods = &e_methods;
jselerror(&e_methods); /* error/trace message routines */
jselvirtmem(&e_methods); /* memory allocation routines */
jselmemmgr(&e_methods); /* memory allocation routines */
dc_methods.d_ui_method_selection = d_ui_method_selection;
/* Now OK to enable signal catcher. */
#ifdef NEED_SIGNAL_CATCHER
emethods = &e_methods;
signal(SIGINT, signal_catcher);
#ifdef SIGTERM /* not all systems have SIGTERM */
signal(SIGTERM, signal_catcher);
#endif
#endif
/* Set up default JPEG parameters. */
j_d_defaults(&cinfo, TRUE);
requested_fmt = DEFAULT_FMT; /* set default output file format */
/* Scan command line options, adjust parameters */
while ((c = egetopt(argc, argv, "GPRTbdgq:2D")) != EOF)
while ((c = egetopt(argc, argv, "GPRTbgq:1Dm:d")) != EOF)
switch (c) {
case 'G': /* GIF output format. */
requested_fmt = FMT_GIF;
@ -179,9 +224,6 @@ main (int argc, char **argv)
case 'b': /* Enable cross-block smoothing. */
cinfo.do_block_smoothing = TRUE;
break;
case 'd': /* Debugging. */
e_methods.trace_level++;
break;
case 'g': /* Force grayscale output. */
cinfo.out_color_space = CS_GRAYSCALE;
break;
@ -195,12 +237,28 @@ main (int argc, char **argv)
}
cinfo.quantize_colors = TRUE;
break;
case '2': /* Use two-pass quantization. */
cinfo.two_pass_quantize = TRUE;
case '1': /* Use fast one-pass quantization. */
cinfo.two_pass_quantize = FALSE;
break;
case 'D': /* Suppress dithering in color quantization. */
cinfo.use_dithering = FALSE;
break;
case 'm': /* Maximum memory in Kb (or Mb with 'm'). */
{ long lval;
char ch = 'x';
if (optarg == NULL)
usage(argv[0]);
if (sscanf(optarg, "%ld%c", &lval, &ch) < 1)
usage(argv[0]);
if (ch == 'm' || ch == 'M')
lval *= 1000L;
e_methods.max_memory_to_use = lval * 1000L;
}
break;
case 'd': /* Debugging. */
e_methods.trace_level++;
break;
case '?':
default:
usage(argv[0]);
@ -222,11 +280,11 @@ main (int argc, char **argv)
}
if ((cinfo.input_file = fopen(argv[optind], READ_BINARY)) == NULL) {
fprintf(stderr, "%s: can't open %s\n", argv[0], argv[optind]);
exit(2);
exit(EXIT_FAILURE);
}
if ((cinfo.output_file = fopen(argv[optind+1], WRITE_BINARY)) == NULL) {
fprintf(stderr, "%s: can't open %s\n", argv[0], argv[optind+1]);
exit(2);
exit(EXIT_FAILURE);
}
#else /* not TWO_FILE_COMMANDLINE -- use Unix style */
@ -241,7 +299,7 @@ main (int argc, char **argv)
if (optind < argc) {
if ((cinfo.input_file = fopen(argv[optind], READ_BINARY)) == NULL) {
fprintf(stderr, "%s: can't open %s\n", argv[0], argv[optind]);
exit(2);
exit(EXIT_FAILURE);
}
}
@ -259,13 +317,7 @@ main (int argc, char **argv)
/* Do it to it! */
jpeg_decompress(&cinfo);
/* Release memory. */
j_d_free_defaults(&cinfo, TRUE);
#ifdef MEM_STATS
if (e_methods.trace_level > 0) /* Optional memory-usage statistics */
j_mem_stats();
#endif
/* All done. */
exit(0);
exit(EXIT_SUCCESS);
return 0; /* suppress no-return-value warnings */
}

View File

@ -1,7 +1,7 @@
/*
* jdmaster.c
*
* Copyright (C) 1991, Thomas G. Lane.
* Copyright (C) 1991, 1992, 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.
*
@ -49,9 +49,15 @@ d_initial_method_selection (decompress_info_ptr cinfo)
/* Gamma and color space conversion */
jseldcolor(cinfo);
/* Color quantization */
/* Color quantization selection rules */
#ifdef QUANT_1PASS_SUPPORTED
#ifndef QUANT_2PASS_SUPPORTED
#ifdef QUANT_2PASS_SUPPORTED
/* We have both, check for conditions in which 1-pass should be used */
if (cinfo->num_components != 3 || cinfo->jpeg_color_space != CS_YCbCr)
cinfo->two_pass_quantize = FALSE; /* 2-pass only handles YCbCr input */
if (cinfo->out_color_space == CS_GRAYSCALE)
cinfo->two_pass_quantize = FALSE; /* Should use 1-pass for grayscale out */
#else /* not QUANT_2PASS_SUPPORTED */
cinfo->two_pass_quantize = FALSE; /* only have 1-pass */
#endif
#else /* not QUANT_1PASS_SUPPORTED */
@ -121,16 +127,9 @@ initial_setup (decompress_info_ptr cinfo)
GLOBAL void
jpeg_decompress (decompress_info_ptr cinfo)
{
short i;
/* Initialize pointers as needed to mark stuff unallocated. */
cinfo->comp_info = NULL;
for (i = 0; i < NUM_QUANT_TBLS; i++)
cinfo->quant_tbl_ptrs[i] = NULL;
for (i = 0; i < NUM_HUFF_TBLS; i++) {
cinfo->dc_huff_tbl_ptrs[i] = NULL;
cinfo->ac_huff_tbl_ptrs[i] = NULL;
}
/* Init pass counts to 0 --- total_passes is adjusted in method selection */
cinfo->total_passes = 0;
cinfo->completed_passes = 0;
/* Read the JPEG file header markers; everything up through the first SOS
* marker is read now. NOTE: the user interface must have initialized the
@ -151,30 +150,24 @@ jpeg_decompress (decompress_info_ptr cinfo)
d_initial_method_selection(cinfo);
/* Initialize the output file & other modules as needed */
/* (color_quant and entropy_decoder are inited by pipeline controller) */
/* (modules needing per-scan init are called by pipeline controller) */
(*cinfo->methods->output_init) (cinfo);
(*cinfo->methods->colorout_init) (cinfo);
if (cinfo->quantize_colors)
(*cinfo->methods->color_quant_init) (cinfo);
/* And let the pipeline controller do the rest. */
(*cinfo->methods->d_pipeline_controller) (cinfo);
/* Finish output file, release working storage, etc */
if (cinfo->quantize_colors)
(*cinfo->methods->color_quant_term) (cinfo);
(*cinfo->methods->colorout_term) (cinfo);
(*cinfo->methods->output_term) (cinfo);
(*cinfo->methods->read_file_trailer) (cinfo);
/* Release allocated storage for tables */
#define FREE(ptr) if ((ptr) != NULL) \
(*cinfo->emethods->free_small) ((void *) ptr)
FREE(cinfo->comp_info);
for (i = 0; i < NUM_QUANT_TBLS; i++)
FREE(cinfo->quant_tbl_ptrs[i]);
for (i = 0; i < NUM_HUFF_TBLS; i++) {
FREE(cinfo->dc_huff_tbl_ptrs[i]);
FREE(cinfo->ac_huff_tbl_ptrs[i]);
}
(*cinfo->emethods->free_all) ();
/* My, that was easy, wasn't it? */
}

81
jdmcu.c
View File

@ -1,12 +1,12 @@
/*
* jdmcu.c
*
* Copyright (C) 1991, Thomas G. Lane.
* Copyright (C) 1991, 1992, 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 MCU disassembly routines and quantization descaling.
* These routines are invoked via the disassemble_MCU and
* These routines are invoked via the disassemble_MCU, reverse_DCT, and
* disassemble_init/term methods.
*/
@ -35,10 +35,11 @@ static const short ZAG[DCTSIZE2] = {
LOCAL void
qdescale_zig (JBLOCK input, JBLOCKROW outputptr, QUANT_TBL_PTR quanttbl)
{
const short * zagptr = ZAG;
short i;
for (i = 0; i < DCTSIZE2; i++) {
(*outputptr)[ZAG[i]] = (*input++) * (*quanttbl++);
for (i = DCTSIZE2-1; i >= 0; i--) {
(*outputptr)[*zagptr++] = (*input++) * (*quanttbl++);
}
}
@ -107,6 +108,77 @@ disassemble_interleaved_MCU (decompress_info_ptr cinfo,
}
/*
* Perform inverse DCT on each block in an MCU row's worth of data;
* output the results into a sample array starting at row start_row.
* NB: start_row can only be nonzero when dealing with a single-component
* scan; otherwise we'd have to pass different offsets for different
* components, since the heights of interleaved MCU rows can vary.
* But the pipeline controller logic is such that this is not necessary.
*/
METHODDEF void
reverse_DCT (decompress_info_ptr cinfo,
JBLOCKIMAGE coeff_data, JSAMPIMAGE output_data, int start_row)
{
DCTBLOCK block;
JBLOCKROW browptr;
JSAMPARRAY srowptr;
long blocksperrow, bi;
short numrows, ri;
short ci;
for (ci = 0; ci < cinfo->comps_in_scan; ci++) {
/* calculate size of an MCU row in this component */
blocksperrow = cinfo->cur_comp_info[ci]->subsampled_width / DCTSIZE;
numrows = cinfo->cur_comp_info[ci]->MCU_height;
/* iterate through all blocks in MCU row */
for (ri = 0; ri < numrows; ri++) {
browptr = coeff_data[ci][ri];
srowptr = output_data[ci] + (ri * DCTSIZE + start_row);
for (bi = 0; bi < blocksperrow; bi++) {
/* copy the data into a local DCTBLOCK. This allows for change of
* representation (if DCTELEM != JCOEF). On 80x86 machines it also
* brings the data back from FAR storage to NEAR storage.
*/
{ register JCOEFPTR elemptr = browptr[bi];
register DCTELEM *localblkptr = block;
register short elem = DCTSIZE2;
while (--elem >= 0)
*localblkptr++ = (DCTELEM) *elemptr++;
}
j_rev_dct(block); /* perform inverse DCT */
/* output the data into the sample array.
* Note change from signed to unsigned representation:
* DCT calculation works with values +-CENTERJSAMPLE,
* but sample arrays always hold 0..MAXJSAMPLE.
* Have to do explicit range-limiting because of quantization errors
* and so forth in the DCT/IDCT phase.
*/
{ register JSAMPROW elemptr;
register DCTELEM *localblkptr = block;
register short elemr, elemc;
register DCTELEM temp;
for (elemr = 0; elemr < DCTSIZE; elemr++) {
elemptr = srowptr[elemr] + (bi * DCTSIZE);
for (elemc = 0; elemc < DCTSIZE; elemc++) {
temp = (*localblkptr++) + CENTERJSAMPLE;
if (temp < 0) temp = 0;
else if (temp > MAXJSAMPLE) temp = MAXJSAMPLE;
*elemptr++ = (JSAMPLE) temp;
}
}
}
}
}
}
}
/*
* Initialize for processing a scan.
*/
@ -141,6 +213,7 @@ jseldmcu (decompress_info_ptr cinfo)
cinfo->methods->disassemble_MCU = disassemble_noninterleaved_MCU;
else
cinfo->methods->disassemble_MCU = disassemble_interleaved_MCU;
cinfo->methods->reverse_DCT = reverse_DCT;
cinfo->methods->disassemble_init = disassemble_init;
cinfo->methods->disassemble_term = disassemble_term;
}

684
jdpipe.c
View File

@ -1,33 +1,38 @@
/*
* jdpipe.c
*
* Copyright (C) 1991, Thomas G. Lane.
* Copyright (C) 1991, 1992, 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 decompression pipeline controllers.
* These routines are invoked via the d_pipeline_controller method.
*
* There are four basic pipeline controllers, one for each combination of:
* single-scan JPEG file (single component or fully interleaved)
* vs. multiple-scan JPEG file (noninterleaved or partially interleaved).
* There are two basic pipeline controllers. The simpler one handles a
* single-scan JPEG file (single component or fully interleaved) with no
* color quantization or 1-pass quantization. In this case, the file can
* be processed in one top-to-bottom pass. The more complex controller is
* used when 2-pass color quantization is requested and/or the JPEG file
* has multiple scans (noninterleaved or partially interleaved). In this
* case, the entire image must be buffered up in a "big" array.
*
* 2-pass color quantization
* vs. no color quantization or 1-pass quantization.
*
* Note that these conditions determine the needs for "big" images:
* multiple scans imply a big image for recombining the color components;
* 2-pass color quantization needs a big image for saving the data for pass 2.
*
* All but the simplest controller (single-scan, no 2-pass quantization) can be
* compiled out through configuration options, if you need to make a minimal
* implementation. You should leave in multiple-scan support if at all
* possible, so that you can handle all legal JPEG files.
* If you need to make a minimal implementation, the more complex controller
* can be compiled out by disabling the appropriate configuration options.
* We don't recommend this, since then you can't handle all legal JPEG files.
*/
#include "jinclude.h"
#ifdef MULTISCAN_FILES_SUPPORTED /* wish we could assume ANSI's defined() */
#define NEED_COMPLEX_CONTROLLER
#else
#ifdef QUANT_2PASS_SUPPORTED
#define NEED_COMPLEX_CONTROLLER
#endif
#endif
/*
* About the data structures:
*
@ -62,15 +67,19 @@
* These variables are logically local to the pipeline controller,
* but we make them static so that scan_big_image can use them
* without having to pass them through the quantization routines.
* If you don't support 2-pass quantization, you could make them locals.
*/
static int rows_in_mem; /* # of sample rows in full-size buffers */
/* Full-size image array holding desubsampled, color-converted data. */
static big_sarray_ptr *fullsize_cnvt_image;
static JSAMPIMAGE fullsize_cnvt_ptrs; /* workspace for access_big_sarray() results */
/* Work buffer for color quantization output (full size, only 1 component). */
static JSAMPARRAY quantize_out;
/* Work buffer for data being passed to output module. */
/* This has color_out_comps components if not quantizing, */
/* but only one component when quantizing. */
static JSAMPIMAGE output_workspace;
#ifdef NEED_COMPLEX_CONTROLLER
/* Full-size image array holding desubsampled, but not color-processed data. */
static big_sarray_ptr *fullsize_image;
static JSAMPIMAGE fullsize_ptrs; /* workspace for access_big_sarray() result */
#endif
/*
@ -154,74 +163,6 @@ noninterleaved_scan_setup (decompress_info_ptr cinfo)
}
LOCAL void
reverse_DCT (decompress_info_ptr cinfo,
JBLOCKIMAGE coeff_data, JSAMPIMAGE output_data,
int start_row)
/* Perform inverse DCT on each block in an MCU row's worth of data; */
/* output the results into a sample array starting at row start_row. */
/* NB: start_row can only be nonzero when dealing with a single-component */
/* scan; otherwise we'd have to provide for different offsets for different */
/* components, since the heights of interleaved MCU rows can vary. */
{
DCTBLOCK block;
JBLOCKROW browptr;
JSAMPARRAY srowptr;
long blocksperrow, bi;
short numrows, ri;
short ci;
for (ci = 0; ci < cinfo->comps_in_scan; ci++) {
/* calc size of an MCU row in this component */
blocksperrow = cinfo->cur_comp_info[ci]->subsampled_width / DCTSIZE;
numrows = cinfo->cur_comp_info[ci]->MCU_height;
/* iterate through all blocks in MCU row */
for (ri = 0; ri < numrows; ri++) {
browptr = coeff_data[ci][ri];
srowptr = output_data[ci] + (ri * DCTSIZE + start_row);
for (bi = 0; bi < blocksperrow; bi++) {
/* copy the data into a local DCTBLOCK. This allows for change of
* representation (if DCTELEM != JCOEF). On 80x86 machines it also
* brings the data back from FAR storage to NEAR storage.
*/
{ register JCOEFPTR elemptr = browptr[bi];
register DCTELEM *localblkptr = block;
register short elem = DCTSIZE2;
while (--elem >= 0)
*localblkptr++ = (DCTELEM) *elemptr++;
}
j_rev_dct(block); /* perform inverse DCT */
/* output the data into the sample array.
* Note change from signed to unsigned representation:
* DCT calculation works with values +-CENTERJSAMPLE,
* but sample arrays always hold 0..MAXJSAMPLE.
* Have to do explicit range-limiting because of quantization errors
* and so forth in the DCT/IDCT phase.
*/
{ register JSAMPROW elemptr;
register DCTELEM *localblkptr = block;
register short elemr, elemc;
register DCTELEM temp;
for (elemr = 0; elemr < DCTSIZE; elemr++) {
elemptr = srowptr[elemr] + (bi * DCTSIZE);
for (elemc = 0; elemc < DCTSIZE; elemc++) {
temp = (*localblkptr++) + CENTERJSAMPLE;
if (temp < 0) temp = 0;
else if (temp > MAXJSAMPLE) temp = MAXJSAMPLE;
*elemptr++ = (JSAMPLE) temp;
}
}
}
}
}
}
}
LOCAL JSAMPIMAGE
alloc_sampimage (decompress_info_ptr cinfo,
@ -240,19 +181,22 @@ alloc_sampimage (decompress_info_ptr cinfo,
}
#if 0 /* this routine not currently needed */
LOCAL void
free_sampimage (decompress_info_ptr cinfo, JSAMPIMAGE image,
int num_comps, long num_rows)
free_sampimage (decompress_info_ptr cinfo, JSAMPIMAGE image, int num_comps)
/* Release a sample image created by alloc_sampimage */
{
int ci;
for (ci = 0; ci < num_comps; ci++) {
(*cinfo->emethods->free_small_sarray) (image[ci], num_rows);
(*cinfo->emethods->free_small_sarray) (image[ci]);
}
(*cinfo->emethods->free_small) ((void *) image);
}
#endif
LOCAL JBLOCKIMAGE
alloc_MCU_row (decompress_info_ptr cinfo)
@ -272,6 +216,8 @@ alloc_MCU_row (decompress_info_ptr cinfo)
}
#ifdef NEED_COMPLEX_CONTROLLER /* not used by simple controller */
LOCAL void
free_MCU_row (decompress_info_ptr cinfo, JBLOCKIMAGE image)
/* Release a coefficient block array created by alloc_MCU_row */
@ -279,12 +225,13 @@ free_MCU_row (decompress_info_ptr cinfo, JBLOCKIMAGE image)
int ci;
for (ci = 0; ci < cinfo->comps_in_scan; ci++) {
(*cinfo->emethods->free_small_barray)
(image[ci], (long) cinfo->cur_comp_info[ci]->MCU_height);
(*cinfo->emethods->free_small_barray) (image[ci]);
}
(*cinfo->emethods->free_small) ((void *) image);
}
#endif
LOCAL void
alloc_sampling_buffer (decompress_info_ptr cinfo, JSAMPIMAGE subsampled_data[2])
@ -321,17 +268,17 @@ alloc_sampling_buffer (decompress_info_ptr cinfo, JSAMPIMAGE subsampled_data[2])
}
#ifdef NEED_COMPLEX_CONTROLLER /* not used by simple controller */
LOCAL void
free_sampling_buffer (decompress_info_ptr cinfo, JSAMPIMAGE subsampled_data[2])
/* Release a sampling buffer created by alloc_sampling_buffer */
{
short ci, vs;
short ci;
for (ci = 0; ci < cinfo->comps_in_scan; ci++) {
vs = cinfo->cur_comp_info[ci]->v_samp_factor; /* row group height */
/* Free the real storage */
(*cinfo->emethods->free_small_sarray)
(subsampled_data[0][ci], (long) (vs * (DCTSIZE+2)));
(*cinfo->emethods->free_small_sarray) (subsampled_data[0][ci]);
/* Free the scrambled-order pointers */
(*cinfo->emethods->free_small) ((void *) subsampled_data[1][ci]);
}
@ -341,6 +288,8 @@ free_sampling_buffer (decompress_info_ptr cinfo, JSAMPIMAGE subsampled_data[2])
(*cinfo->emethods->free_small) ((void *) subsampled_data[1]);
}
#endif
LOCAL void
duplicate_row (JSAMPARRAY image_data,
@ -409,82 +358,62 @@ expand (decompress_info_ptr cinfo,
LOCAL void
emit_1pass (decompress_info_ptr cinfo, int num_rows,
JSAMPIMAGE fullsize_data, JSAMPIMAGE color_data)
/* Do color conversion and output of num_rows full-size rows. */
/* This is not used for 2-pass color quantization. */
emit_1pass (decompress_info_ptr cinfo, int num_rows, JSAMPIMAGE fullsize_data,
JSAMPARRAY dummy)
/* Do color processing and output of num_rows full-size rows. */
/* This is not used when doing 2-pass color quantization. */
/* The dummy argument simply lets this be called via scan_big_image. */
{
(*cinfo->methods->color_convert) (cinfo, num_rows,
fullsize_data, color_data);
if (cinfo->quantize_colors) {
(*cinfo->methods->color_quantize) (cinfo, num_rows,
color_data, quantize_out);
(*cinfo->methods->put_pixel_rows) (cinfo, num_rows,
&quantize_out);
(*cinfo->methods->color_quantize) (cinfo, num_rows, fullsize_data,
output_workspace[0]);
} else {
(*cinfo->methods->put_pixel_rows) (cinfo, num_rows,
color_data);
(*cinfo->methods->color_convert) (cinfo, num_rows, cinfo->image_width,
fullsize_data, output_workspace);
}
(*cinfo->methods->put_pixel_rows) (cinfo, num_rows, output_workspace);
}
/*
* Support routines for 2-pass color quantization.
* Support routines for complex controller.
*/
#ifdef QUANT_2PASS_SUPPORTED
LOCAL void
emit_2pass (decompress_info_ptr cinfo, long top_row, int num_rows,
JSAMPIMAGE fullsize_data)
/* Do color conversion and output data to the quantization buffer image. */
/* This is used only with 2-pass color quantization. */
{
short ci;
/* Realign the big buffers */
for (ci = 0; ci < cinfo->num_components; ci++) {
fullsize_cnvt_ptrs[ci] = (*cinfo->emethods->access_big_sarray)
(fullsize_cnvt_image[ci], top_row, TRUE);
}
/* Do colorspace conversion */
(*cinfo->methods->color_convert) (cinfo, num_rows,
fullsize_data, fullsize_cnvt_ptrs);
/* Let quantizer get first-pass peek at the data. */
/* (Quantizer could change data if it wants to.) */
(*cinfo->methods->color_quant_prescan) (cinfo, num_rows, fullsize_cnvt_ptrs);
}
#ifdef NEED_COMPLEX_CONTROLLER
METHODDEF void
scan_big_image (decompress_info_ptr cinfo, quantize_method_ptr quantize_method)
/* This is the "iterator" routine used by the quantizer. */
/* Apply quantize_method to entire image stored in fullsize_image[]. */
/* This is the "iterator" routine used by the 2-pass color quantizer. */
/* We also use it directly in some cases. */
{
long pixel_rows_output;
short ci;
for (pixel_rows_output = 0; pixel_rows_output < cinfo->image_height;
pixel_rows_output += rows_in_mem) {
(*cinfo->methods->progress_monitor) (cinfo, pixel_rows_output,
cinfo->image_height);
/* Realign the big buffers */
for (ci = 0; ci < cinfo->num_components; ci++) {
fullsize_cnvt_ptrs[ci] = (*cinfo->emethods->access_big_sarray)
(fullsize_cnvt_image[ci], pixel_rows_output, FALSE);
fullsize_ptrs[ci] = (*cinfo->emethods->access_big_sarray)
(fullsize_image[ci], pixel_rows_output, FALSE);
}
/* Let the quantizer have its way with the data.
* Note that quantize_out is simply workspace for the quantizer;
* Note that output_workspace is simply workspace for the quantizer;
* when it's ready to output, it must call put_pixel_rows itself.
*/
(*quantize_method) (cinfo,
(int) MIN(rows_in_mem,
(int) MIN((long) rows_in_mem,
cinfo->image_height - pixel_rows_output),
fullsize_cnvt_ptrs, quantize_out);
fullsize_ptrs, output_workspace[0]);
}
cinfo->completed_passes++;
}
#endif /* QUANT_2PASS_SUPPORTED */
#endif /* NEED_COMPLEX_CONTROLLER */
/*
@ -587,7 +516,7 @@ get_smoothed_row (decompress_info_ptr cinfo, JBLOCKIMAGE coeff_data,
*/
METHODDEF void
single_dcontroller (decompress_info_ptr cinfo)
simple_dcontroller (decompress_info_ptr cinfo)
{
long fullsize_width; /* # of samples per row in full-size buffers */
long cur_mcu_row; /* counts # of MCU rows processed */
@ -604,14 +533,14 @@ single_dcontroller (decompress_info_ptr cinfo)
JSAMPIMAGE subsampled_data[2];
/* Work buffer for desubsampled data */
JSAMPIMAGE fullsize_data;
/* Work buffer for color conversion output (full size) */
JSAMPIMAGE color_data;
int whichss, ri;
short i;
/* Initialize for 1-pass color quantization, if needed */
if (cinfo->quantize_colors)
(*cinfo->methods->color_quant_init) (cinfo);
/* Compute dimensions of full-size pixel buffers */
/* Note these are the same whether interleaved or not. */
rows_in_mem = cinfo->max_v_samp_factor * DCTSIZE;
fullsize_width = jround_up(cinfo->image_width,
(long) (cinfo->max_h_samp_factor * DCTSIZE));
/* Prepare for single scan containing all components */
if (cinfo->comps_in_scan == 1) {
@ -623,12 +552,7 @@ single_dcontroller (decompress_info_ptr cinfo)
/* in an interleaved scan, one MCU row provides Vk block rows */
mcu_rows_per_loop = 1;
}
/* Compute dimensions of full-size pixel buffers */
/* Note these are the same whether interleaved or not. */
rows_in_mem = cinfo->max_v_samp_factor * DCTSIZE;
fullsize_width = jround_up(cinfo->image_width,
(long) (cinfo->max_h_samp_factor * DCTSIZE));
cinfo->total_passes++;
/* Allocate working memory: */
/* coeff_data holds a single MCU row of coefficient blocks */
@ -646,13 +570,9 @@ single_dcontroller (decompress_info_ptr cinfo)
/* fullsize_data is sample data after unsubsampling */
fullsize_data = alloc_sampimage(cinfo, (int) cinfo->num_components,
(long) rows_in_mem, fullsize_width);
/* color_data is the result of the colorspace conversion step */
color_data = alloc_sampimage(cinfo, (int) cinfo->color_out_comps,
(long) rows_in_mem, fullsize_width);
/* if quantizing colors, also need a one-component output area for that. */
if (cinfo->quantize_colors)
quantize_out = (*cinfo->emethods->alloc_small_sarray)
(fullsize_width, (long) rows_in_mem);
/* output_workspace is the color-processed data */
output_workspace = alloc_sampimage(cinfo, (int) cinfo->final_out_comps,
(long) rows_in_mem, fullsize_width);
/* Tell the memory manager to instantiate big arrays.
* We don't need any big arrays in this controller,
@ -662,7 +582,8 @@ single_dcontroller (decompress_info_ptr cinfo)
((long) 0, /* no more small sarrays */
(long) 0, /* no more small barrays */
(long) 0); /* no more "medium" objects */
/* NB: quantizer must get any such objects at color_quant_init time */
/* NB: if quantizer needs any "medium" size objects, it must get them */
/* at color_quant_init time */
/* Initialize to read scan data */
@ -677,6 +598,9 @@ single_dcontroller (decompress_info_ptr cinfo)
for (cur_mcu_row = 0; cur_mcu_row < cinfo->MCU_rows_in_scan;
cur_mcu_row += mcu_rows_per_loop) {
(*cinfo->methods->progress_monitor) (cinfo, cur_mcu_row,
cinfo->MCU_rows_in_scan);
whichss ^= 1; /* switch to other subsample buffer */
/* Obtain v_samp_factor block rows of each component in the scan. */
@ -696,8 +620,9 @@ single_dcontroller (decompress_info_ptr cinfo)
#endif
(*cinfo->methods->disassemble_MCU) (cinfo, coeff_data);
reverse_DCT(cinfo, coeff_data, subsampled_data[whichss],
ri * DCTSIZE);
(*cinfo->methods->reverse_DCT) (cinfo, coeff_data,
subsampled_data[whichss],
ri * DCTSIZE);
} else {
/* Need to pad out with copies of the last subsampled row. */
/* This can only happen if there is just one component. */
@ -716,7 +641,7 @@ single_dcontroller (decompress_info_ptr cinfo)
(short) DCTSIZE, (short) (DCTSIZE+1), (short) 0,
(short) (DCTSIZE-1));
/* and dump the previous set's expanded data */
emit_1pass (cinfo, rows_in_mem, fullsize_data, color_data);
emit_1pass (cinfo, rows_in_mem, fullsize_data, NULL);
pixel_rows_output += rows_in_mem;
/* Expand first row group of this set */
expand(cinfo, subsampled_data[whichss], fullsize_data, fullsize_width,
@ -743,273 +668,47 @@ single_dcontroller (decompress_info_ptr cinfo)
(short) (DCTSIZE-1));
/* and dump the remaining data (may be less than full height) */
emit_1pass (cinfo, (int) (cinfo->image_height - pixel_rows_output),
fullsize_data, color_data);
fullsize_data, NULL);
/* Clean up after the scan */
(*cinfo->methods->disassemble_term) (cinfo);
(*cinfo->methods->unsubsample_term) (cinfo);
(*cinfo->methods->entropy_decoder_term) (cinfo);
(*cinfo->methods->read_scan_trailer) (cinfo);
cinfo->completed_passes++;
/* Verify that we've seen the whole input file */
if ((*cinfo->methods->read_scan_header) (cinfo))
ERREXIT(cinfo->emethods, "Didn't expect more than one scan");
/* Release working memory */
free_MCU_row(cinfo, coeff_data);
#ifdef BLOCK_SMOOTHING_SUPPORTED
if (cinfo->do_block_smoothing) {
free_MCU_row(cinfo, bsmooth[0]);
free_MCU_row(cinfo, bsmooth[1]);
free_MCU_row(cinfo, bsmooth[2]);
}
#endif
free_sampling_buffer(cinfo, subsampled_data);
free_sampimage(cinfo, fullsize_data, (int) cinfo->num_components,
(long) rows_in_mem);
free_sampimage(cinfo, color_data, (int) cinfo->color_out_comps,
(long) rows_in_mem);
if (cinfo->quantize_colors)
(*cinfo->emethods->free_small_sarray)
(quantize_out, (long) rows_in_mem);
/* Close up shop */
if (cinfo->quantize_colors)
(*cinfo->methods->color_quant_term) (cinfo);
/* (no work -- we let free_all release what's needful) */
}
/*
* Decompression pipeline controller used for single-scan files
* with 2-pass color quantization.
*/
#ifdef QUANT_2PASS_SUPPORTED
METHODDEF void
single_2quant_dcontroller (decompress_info_ptr cinfo)
{
long fullsize_width; /* # of samples per row in full-size buffers */
long cur_mcu_row; /* counts # of MCU rows processed */
long pixel_rows_output; /* # of pixel rows actually emitted */
int mcu_rows_per_loop; /* # of MCU rows processed per outer loop */
/* Work buffer for dequantized coefficients (IDCT input) */
JBLOCKIMAGE coeff_data;
/* Work buffer for cross-block smoothing input */
#ifdef BLOCK_SMOOTHING_SUPPORTED
JBLOCKIMAGE bsmooth[3]; /* this is optional */
int whichb;
#endif
/* Work buffer for subsampled image data (see comments at head of file) */
JSAMPIMAGE subsampled_data[2];
/* Work buffer for desubsampled data */
JSAMPIMAGE fullsize_data;
int whichss, ri;
short ci, i;
/* Initialize for 2-pass color quantization */
(*cinfo->methods->color_quant_init) (cinfo);
/* Prepare for single scan containing all components */
if (cinfo->comps_in_scan == 1) {
noninterleaved_scan_setup(cinfo);
/* Need to read Vk MCU rows to obtain Vk block rows */
mcu_rows_per_loop = cinfo->cur_comp_info[0]->v_samp_factor;
} else {
interleaved_scan_setup(cinfo);
/* in an interleaved scan, one MCU row provides Vk block rows */
mcu_rows_per_loop = 1;
}
/* Compute dimensions of full-size pixel buffers */
/* Note these are the same whether interleaved or not. */
rows_in_mem = cinfo->max_v_samp_factor * DCTSIZE;
fullsize_width = jround_up(cinfo->image_width,
(long) (cinfo->max_h_samp_factor * DCTSIZE));
/* Allocate working memory: */
/* coeff_data holds a single MCU row of coefficient blocks */
coeff_data = alloc_MCU_row(cinfo);
/* if doing cross-block smoothing, need extra space for its input */
#ifdef BLOCK_SMOOTHING_SUPPORTED
if (cinfo->do_block_smoothing) {
bsmooth[0] = alloc_MCU_row(cinfo);
bsmooth[1] = alloc_MCU_row(cinfo);
bsmooth[2] = alloc_MCU_row(cinfo);
}
#endif
/* subsampled_data is sample data before unsubsampling */
alloc_sampling_buffer(cinfo, subsampled_data);
/* fullsize_data is sample data after unsubsampling */
fullsize_data = alloc_sampimage(cinfo, (int) cinfo->num_components,
(long) rows_in_mem, fullsize_width);
/* Also need a one-component output area for color quantizer. */
quantize_out = (*cinfo->emethods->alloc_small_sarray)
(fullsize_width, (long) rows_in_mem);
/* Get a big image for quantizer input: desubsampled, color-converted data */
fullsize_cnvt_image = (big_sarray_ptr *) (*cinfo->emethods->alloc_small)
(cinfo->num_components * SIZEOF(big_sarray_ptr));
for (ci = 0; ci < cinfo->num_components; ci++) {
fullsize_cnvt_image[ci] = (*cinfo->emethods->request_big_sarray)
(fullsize_width,
jround_up(cinfo->image_height, (long) rows_in_mem),
(long) rows_in_mem);
}
/* Also get an area for pointers to currently accessible chunks */
fullsize_cnvt_ptrs = (JSAMPIMAGE) (*cinfo->emethods->alloc_small)
(cinfo->num_components * SIZEOF(JSAMPARRAY));
/* Tell the memory manager to instantiate big arrays */
(*cinfo->emethods->alloc_big_arrays)
((long) 0, /* no more small sarrays */
(long) 0, /* no more small barrays */
(long) 0); /* no more "medium" objects */
/* NB: quantizer must get any such objects at color_quant_init time */
/* Initialize to read scan data */
(*cinfo->methods->entropy_decoder_init) (cinfo);
(*cinfo->methods->unsubsample_init) (cinfo);
(*cinfo->methods->disassemble_init) (cinfo);
/* Loop over scan's data: rows_in_mem pixel rows are processed per loop */
pixel_rows_output = 0;
whichss = 1; /* arrange to start with subsampled_data[0] */
for (cur_mcu_row = 0; cur_mcu_row < cinfo->MCU_rows_in_scan;
cur_mcu_row += mcu_rows_per_loop) {
whichss ^= 1; /* switch to other subsample buffer */
/* Obtain v_samp_factor block rows of each component in the scan. */
/* This is a single MCU row if interleaved, multiple MCU rows if not. */
/* In the noninterleaved case there might be fewer than v_samp_factor */
/* block rows remaining; if so, pad with copies of the last pixel row */
/* so that unsubsampling doesn't have to treat it as a special case. */
for (ri = 0; ri < mcu_rows_per_loop; ri++) {
if (cur_mcu_row + ri < cinfo->MCU_rows_in_scan) {
/* OK to actually read an MCU row. */
#ifdef BLOCK_SMOOTHING_SUPPORTED
if (cinfo->do_block_smoothing)
get_smoothed_row(cinfo, coeff_data,
bsmooth, &whichb, cur_mcu_row + ri);
else
#endif
(*cinfo->methods->disassemble_MCU) (cinfo, coeff_data);
reverse_DCT(cinfo, coeff_data, subsampled_data[whichss],
ri * DCTSIZE);
} else {
/* Need to pad out with copies of the last subsampled row. */
/* This can only happen if there is just one component. */
duplicate_row(subsampled_data[whichss][0],
cinfo->cur_comp_info[0]->subsampled_width,
ri * DCTSIZE - 1, DCTSIZE);
}
}
/* Unsubsample the data */
/* First time through is a special case */
if (cur_mcu_row) {
/* Expand last row group of previous set */
expand(cinfo, subsampled_data[whichss], fullsize_data, fullsize_width,
(short) DCTSIZE, (short) (DCTSIZE+1), (short) 0,
(short) (DCTSIZE-1));
/* and dump the previous set's expanded data */
emit_2pass (cinfo, pixel_rows_output, rows_in_mem, fullsize_data);
pixel_rows_output += rows_in_mem;
/* Expand first row group of this set */
expand(cinfo, subsampled_data[whichss], fullsize_data, fullsize_width,
(short) (DCTSIZE+1), (short) 0, (short) 1,
(short) 0);
} else {
/* Expand first row group with dummy above-context */
expand(cinfo, subsampled_data[whichss], fullsize_data, fullsize_width,
(short) (-1), (short) 0, (short) 1,
(short) 0);
}
/* Expand second through next-to-last row groups of this set */
for (i = 1; i <= DCTSIZE-2; i++) {
expand(cinfo, subsampled_data[whichss], fullsize_data, fullsize_width,
(short) (i-1), (short) i, (short) (i+1),
(short) i);
}
} /* end of outer loop */
/* Expand the last row group with dummy below-context */
/* Note whichss points to last buffer side used */
expand(cinfo, subsampled_data[whichss], fullsize_data, fullsize_width,
(short) (DCTSIZE-2), (short) (DCTSIZE-1), (short) (-1),
(short) (DCTSIZE-1));
/* and dump the remaining data (may be less than full height) */
emit_2pass (cinfo, pixel_rows_output,
(int) (cinfo->image_height - pixel_rows_output),
fullsize_data);
/* Clean up after the scan */
(*cinfo->methods->disassemble_term) (cinfo);
(*cinfo->methods->unsubsample_term) (cinfo);
(*cinfo->methods->entropy_decoder_term) (cinfo);
(*cinfo->methods->read_scan_trailer) (cinfo);
/* Verify that we've seen the whole input file */
if ((*cinfo->methods->read_scan_header) (cinfo))
ERREXIT(cinfo->emethods, "Didn't expect more than one scan");
/* Now that we've collected the data, let the color quantizer do its thing */
(*cinfo->methods->color_quant_doit) (cinfo, scan_big_image);
/* Release working memory */
free_MCU_row(cinfo, coeff_data);
#ifdef BLOCK_SMOOTHING_SUPPORTED
if (cinfo->do_block_smoothing) {
free_MCU_row(cinfo, bsmooth[0]);
free_MCU_row(cinfo, bsmooth[1]);
free_MCU_row(cinfo, bsmooth[2]);
}
#endif
free_sampling_buffer(cinfo, subsampled_data);
free_sampimage(cinfo, fullsize_data, (int) cinfo->num_components,
(long) rows_in_mem);
(*cinfo->emethods->free_small_sarray)
(quantize_out, (long) rows_in_mem);
for (ci = 0; ci < cinfo->num_components; ci++) {
(*cinfo->emethods->free_big_sarray) (fullsize_cnvt_image[ci]);
}
(*cinfo->emethods->free_small) ((void *) fullsize_cnvt_image);
(*cinfo->emethods->free_small) ((void *) fullsize_cnvt_ptrs);
/* Close up shop */
(*cinfo->methods->color_quant_term) (cinfo);
}
#endif /* QUANT_2PASS_SUPPORTED */
/*
* Decompression pipeline controller used for multiple-scan files
* without 2-pass color quantization.
* and/or 2-pass color quantization.
*
* The current implementation places the "big" buffer at the stage of
* desubsampled data. Buffering subsampled data instead would reduce the
* size of temp files (by about a factor of 2 in typical cases). However,
* the unsubsampling logic is dependent on the assumption that unsubsampling
* occurs during a scan, so it's much easier to do the enlargement as the
* JPEG file is read. This also simplifies life for the memory manager,
* which would otherwise have to deal with overlapping access_big_sarray()
* requests.
*
* At present it appears that most JPEG files will be single-scan, so
* it doesn't seem worthwhile to try to make this implementation smarter.
* desubsampled, non-color-processed data. This is the only place that
* makes sense when doing 2-pass quantization. For processing multiple-scan
* files without 2-pass quantization, it would be possible to develop another
* controller that buffers the subsampled data instead, thus reducing the size
* of the temp files (by about a factor of 2 in typical cases). However,
* our present unsubsampling logic is dependent on the assumption that
* unsubsampling occurs during a scan, so it's much easier to do the
* enlargement as the JPEG file is read. This also simplifies life for the
* memory manager, which would otherwise have to deal with overlapping
* access_big_sarray() requests.
* At present it appears that most JPEG files will be single-scan,
* so it doesn't seem worthwhile to worry about this optimization.
*/
#ifdef MULTISCAN_FILES_SUPPORTED
#ifdef NEED_COMPLEX_CONTROLLER
METHODDEF void
multi_dcontroller (decompress_info_ptr cinfo)
complex_dcontroller (decompress_info_ptr cinfo)
{
long fullsize_width; /* # of samples per row in full-size buffers */
long cur_mcu_row; /* counts # of MCU rows processed */
@ -1024,17 +723,9 @@ multi_dcontroller (decompress_info_ptr cinfo)
#endif
/* Work buffer for subsampled image data (see comments at head of file) */
JSAMPIMAGE subsampled_data[2];
/* Full-image buffer holding desubsampled, but not color-converted, data */
big_sarray_ptr *fullsize_image;
JSAMPIMAGE fullsize_ptrs; /* workspace for access_big_sarray() results */
/* Work buffer for color conversion output (full size) */
JSAMPIMAGE color_data;
int whichss, ri;
short ci, i;
/* Initialize for 1-pass color quantization, if needed */
if (cinfo->quantize_colors)
(*cinfo->methods->color_quant_init) (cinfo);
boolean single_scan;
/* Compute dimensions of full-size pixel buffers */
/* Note these are the same whether interleaved or not. */
@ -1043,13 +734,9 @@ multi_dcontroller (decompress_info_ptr cinfo)
(long) (cinfo->max_h_samp_factor * DCTSIZE));
/* Allocate all working memory that doesn't depend on scan info */
/* color_data is the result of the colorspace conversion step */
color_data = alloc_sampimage(cinfo, (int) cinfo->color_out_comps,
(long) rows_in_mem, fullsize_width);
/* if quantizing colors, also need a one-component output area for that. */
if (cinfo->quantize_colors)
quantize_out = (*cinfo->emethods->alloc_small_sarray)
(fullsize_width, (long) rows_in_mem);
/* output_workspace is the color-processed data */
output_workspace = alloc_sampimage(cinfo, (int) cinfo->final_out_comps,
(long) rows_in_mem, fullsize_width);
/* Get a big image: fullsize_image is sample data after unsubsampling. */
fullsize_image = (big_sarray_ptr *) (*cinfo->emethods->alloc_small)
@ -1076,9 +763,34 @@ multi_dcontroller (decompress_info_ptr cinfo)
* cinfo->num_components /* max components per scan */
* (cinfo->do_block_smoothing ? 4 : 1)),/* how many of these we need */
/* no extra "medium"-object space */
/* NB: quantizer must get any such objects at color_quant_init time */
(long) 0);
/* NB: if quantizer needs any "medium" size objects, it must get them */
/* at color_quant_init time */
/* If file is single-scan, we can do color quantization prescan on-the-fly
* during the scan (we must be doing 2-pass quantization, else this method
* would not have been selected). If it is multiple scans, we have to make
* a separate pass after we've collected all the components. (We could save
* some I/O by doing CQ prescan during the last scan, but the extra logic
* doesn't seem worth the trouble.)
*/
single_scan = (cinfo->comps_in_scan == cinfo->num_components);
/* Account for passes needed (color quantizer adds its passes separately).
* If multiscan file, we guess that each component has its own scan,
* and increment completed_passes by the number of components in the scan.
*/
if (single_scan)
cinfo->total_passes++; /* the single scan */
else {
cinfo->total_passes += cinfo->num_components; /* guessed # of scans */
if (cinfo->two_pass_quantize)
cinfo->total_passes++; /* account for separate CQ prescan pass */
}
if (! cinfo->two_pass_quantize)
cinfo->total_passes++; /* count output pass unless quantizer does it */
/* Loop over scans in file */
@ -1109,7 +821,7 @@ multi_dcontroller (decompress_info_ptr cinfo)
/* subsampled_data is sample data before unsubsampling */
alloc_sampling_buffer(cinfo, subsampled_data);
/* line up the big buffers */
/* line up the big buffers for components in this scan */
for (ci = 0; ci < cinfo->comps_in_scan; ci++) {
fullsize_ptrs[ci] = (*cinfo->emethods->access_big_sarray)
(fullsize_image[cinfo->cur_comp_info[ci]->component_index],
@ -1129,6 +841,9 @@ multi_dcontroller (decompress_info_ptr cinfo)
for (cur_mcu_row = 0; cur_mcu_row < cinfo->MCU_rows_in_scan;
cur_mcu_row += mcu_rows_per_loop) {
(*cinfo->methods->progress_monitor) (cinfo, cur_mcu_row,
cinfo->MCU_rows_in_scan);
whichss ^= 1; /* switch to other subsample buffer */
/* Obtain v_samp_factor block rows of each component in the scan. */
@ -1148,8 +863,9 @@ multi_dcontroller (decompress_info_ptr cinfo)
#endif
(*cinfo->methods->disassemble_MCU) (cinfo, coeff_data);
reverse_DCT(cinfo, coeff_data, subsampled_data[whichss],
ri * DCTSIZE);
(*cinfo->methods->reverse_DCT) (cinfo, coeff_data,
subsampled_data[whichss],
ri * DCTSIZE);
} else {
/* Need to pad out with copies of the last subsampled row. */
/* This can only happen if there is just one component. */
@ -1167,6 +883,11 @@ multi_dcontroller (decompress_info_ptr cinfo)
expand(cinfo, subsampled_data[whichss], fullsize_ptrs, fullsize_width,
(short) DCTSIZE, (short) (DCTSIZE+1), (short) 0,
(short) (DCTSIZE-1));
/* If single scan, can do color quantization prescan on-the-fly */
if (single_scan)
(*cinfo->methods->color_quant_prescan) (cinfo, rows_in_mem,
fullsize_ptrs,
output_workspace[0]);
/* Realign the big buffers */
pixel_rows_output += rows_in_mem;
for (ci = 0; ci < cinfo->comps_in_scan; ci++) {
@ -1190,19 +911,28 @@ multi_dcontroller (decompress_info_ptr cinfo)
(short) (i-1), (short) i, (short) (i+1),
(short) i);
}
} /* end of outer loop */
} /* end of loop over scan's data */
/* Expand the last row group with dummy below-context */
/* Note whichss points to last buffer side used */
expand(cinfo, subsampled_data[whichss], fullsize_ptrs, fullsize_width,
(short) (DCTSIZE-2), (short) (DCTSIZE-1), (short) (-1),
(short) (DCTSIZE-1));
/* If single scan, finish on-the-fly color quantization prescan */
if (single_scan)
(*cinfo->methods->color_quant_prescan) (cinfo,
(int) (cinfo->image_height - pixel_rows_output),
fullsize_ptrs, output_workspace[0]);
/* Clean up after the scan */
(*cinfo->methods->disassemble_term) (cinfo);
(*cinfo->methods->unsubsample_term) (cinfo);
(*cinfo->methods->entropy_decoder_term) (cinfo);
(*cinfo->methods->read_scan_trailer) (cinfo);
if (single_scan)
cinfo->completed_passes++;
else
cinfo->completed_passes += cinfo->comps_in_scan;
/* Release scan-local working memory */
free_MCU_row(cinfo, coeff_data);
@ -1216,61 +946,32 @@ multi_dcontroller (decompress_info_ptr cinfo)
free_sampling_buffer(cinfo, subsampled_data);
/* Repeat if there is another scan */
} while ((*cinfo->methods->read_scan_header) (cinfo));
} while ((!single_scan) && (*cinfo->methods->read_scan_header) (cinfo));
/* Now that we've collected all the data, color convert & output it. */
for (pixel_rows_output = 0; pixel_rows_output < cinfo->image_height;
pixel_rows_output += rows_in_mem) {
/* realign the big buffers */
for (ci = 0; ci < cinfo->num_components; ci++) {
fullsize_ptrs[ci] = (*cinfo->emethods->access_big_sarray)
(fullsize_image[ci], pixel_rows_output, FALSE);
}
emit_1pass (cinfo,
(int) MIN((long) rows_in_mem,
cinfo->image_height - pixel_rows_output),
fullsize_ptrs, color_data);
if (single_scan) {
/* If we expected just one scan, make SURE there's just one */
if ((*cinfo->methods->read_scan_header) (cinfo))
ERREXIT(cinfo->emethods, "Didn't expect more than one scan");
/* We did the CQ prescan on-the-fly, so we are all set. */
} else {
/* For multiple-scan file, do the CQ prescan as a separate pass. */
/* The main reason why prescan is passed the output_workspace is */
/* so that we can use scan_big_image to call it... */
if (cinfo->two_pass_quantize)
scan_big_image(cinfo, cinfo->methods->color_quant_prescan);
}
/* Now that we've collected the data, do color processing and output */
if (cinfo->two_pass_quantize)
(*cinfo->methods->color_quant_doit) (cinfo, scan_big_image);
else
scan_big_image(cinfo, emit_1pass);
/* Release working memory */
free_sampimage(cinfo, color_data, (int) cinfo->color_out_comps,
(long) rows_in_mem);
if (cinfo->quantize_colors)
(*cinfo->emethods->free_small_sarray)
(quantize_out, (long) rows_in_mem);
for (ci = 0; ci < cinfo->num_components; ci++) {
(*cinfo->emethods->free_big_sarray) (fullsize_image[ci]);
}
(*cinfo->emethods->free_small) ((void *) fullsize_image);
(*cinfo->emethods->free_small) ((void *) fullsize_ptrs);
/* Close up shop */
if (cinfo->quantize_colors)
(*cinfo->methods->color_quant_term) (cinfo);
/* (no work -- we let free_all release what's needful) */
}
#endif /* MULTISCAN_FILES_SUPPORTED */
/*
* Decompression pipeline controller used for multiple-scan files
* with 2-pass color quantization.
*/
#ifdef MULTISCAN_FILES_SUPPORTED
#ifdef QUANT_2PASS_SUPPORTED
METHODDEF void
multi_2quant_dcontroller (decompress_info_ptr cinfo)
{
ERREXIT(cinfo->emethods, "Not implemented yet");
}
#endif /* QUANT_2PASS_SUPPORTED */
#endif /* MULTISCAN_FILES_SUPPORTED */
#endif /* NEED_COMPLEX_CONTROLLER */
/*
@ -1288,21 +989,18 @@ jseldpipeline (decompress_info_ptr cinfo)
if (cinfo->comps_in_scan == cinfo->num_components) {
/* It's a single-scan file */
#ifdef QUANT_2PASS_SUPPORTED
if (cinfo->two_pass_quantize)
cinfo->methods->d_pipeline_controller = single_2quant_dcontroller;
else
if (cinfo->two_pass_quantize) {
#ifdef NEED_COMPLEX_CONTROLLER
cinfo->methods->d_pipeline_controller = complex_dcontroller;
#else
ERREXIT(cinfo->emethods, "2-pass quantization support was not compiled");
#endif
cinfo->methods->d_pipeline_controller = single_dcontroller;
} else
cinfo->methods->d_pipeline_controller = simple_dcontroller;
} else {
/* It's a multiple-scan file */
#ifdef MULTISCAN_FILES_SUPPORTED
#ifdef QUANT_2PASS_SUPPORTED
if (cinfo->two_pass_quantize)
cinfo->methods->d_pipeline_controller = multi_2quant_dcontroller;
else
#endif
cinfo->methods->d_pipeline_controller = multi_dcontroller;
#ifdef NEED_COMPLEX_CONTROLLER
cinfo->methods->d_pipeline_controller = complex_dcontroller;
#else
ERREXIT(cinfo->emethods, "Multiple-scan support was not compiled");
#endif

View File

@ -1,7 +1,7 @@
/*
* jdsample.c
*
* Copyright (C) 1991, Thomas G. Lane.
* Copyright (C) 1991, 1992, 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.
*
@ -26,30 +26,33 @@ unsubsample_init (decompress_info_ptr cinfo)
/*
* Un-subsample pixel values of a single component.
* This version only handles integral sampling ratios.
* This version handles any integral sampling ratios.
* This is not used for typical JPEG files, so it need not be fast.
*/
METHODDEF void
unsubsample (decompress_info_ptr cinfo, int which_component,
long input_cols, int input_rows,
long output_cols, int output_rows,
JSAMPARRAY above, JSAMPARRAY input_data, JSAMPARRAY below,
JSAMPARRAY output_data)
int_unsubsample (decompress_info_ptr cinfo, int which_component,
long input_cols, int input_rows,
long output_cols, int output_rows,
JSAMPARRAY above, JSAMPARRAY input_data, JSAMPARRAY below,
JSAMPARRAY output_data)
{
jpeg_component_info * compptr = cinfo->cur_comp_info[which_component];
short h_expand, v_expand, h, v;
register JSAMPROW inptr, outptr;
register JSAMPLE invalue;
register short h_expand, h;
short v_expand, v;
int inrow, outrow;
long incol;
JSAMPROW inptr, outptr;
JSAMPLE invalue;
register long incol;
/* TEMP FOR DEBUGGING PIPELINE CONTROLLER */
#ifdef DEBUG /* for debugging pipeline controller */
if (input_rows != compptr->v_samp_factor ||
output_rows != cinfo->max_v_samp_factor ||
(input_cols % compptr->h_samp_factor) != 0 ||
(output_cols % cinfo->max_h_samp_factor) != 0 ||
output_cols*compptr->h_samp_factor != input_cols*cinfo->max_h_samp_factor)
ERREXIT(cinfo->emethods, "Bogus unsubsample parameters");
#endif
h_expand = cinfo->max_h_samp_factor / compptr->h_samp_factor;
v_expand = cinfo->max_v_samp_factor / compptr->v_samp_factor;
@ -70,6 +73,85 @@ unsubsample (decompress_info_ptr cinfo, int which_component,
}
/*
* Un-subsample pixel values of a single component.
* This version handles the extremely common case of
* horizontal expansion by 2 and any integral vertical expansion.
*/
METHODDEF void
h2_unsubsample (decompress_info_ptr cinfo, int which_component,
long input_cols, int input_rows,
long output_cols, int output_rows,
JSAMPARRAY above, JSAMPARRAY input_data, JSAMPARRAY below,
JSAMPARRAY output_data)
{
jpeg_component_info * compptr = cinfo->cur_comp_info[which_component];
register JSAMPROW inptr, outptr;
register JSAMPLE invalue;
short v_expand, v;
int inrow, outrow;
register long incol;
#ifdef DEBUG /* for debugging pipeline controller */
if (input_rows != compptr->v_samp_factor ||
output_rows != cinfo->max_v_samp_factor ||
(input_cols % compptr->h_samp_factor) != 0 ||
(output_cols % cinfo->max_h_samp_factor) != 0 ||
output_cols*compptr->h_samp_factor != input_cols*cinfo->max_h_samp_factor)
ERREXIT(cinfo->emethods, "Bogus unsubsample parameters");
#endif
v_expand = cinfo->max_v_samp_factor / compptr->v_samp_factor;
/* The subsampled image width will always be a multiple of DCTSIZE,
* so we can unroll the inner loop.
*/
outrow = 0;
for (inrow = 0; inrow < input_rows; inrow++) {
for (v = 0; v < v_expand; v++) {
inptr = input_data[inrow];
outptr = output_data[outrow++];
#if DCTSIZE == 8
for (incol = 0; incol < input_cols; incol += DCTSIZE) {
invalue = GETJSAMPLE(*inptr++);
*outptr++ = invalue;
*outptr++ = invalue;
invalue = GETJSAMPLE(*inptr++);
*outptr++ = invalue;
*outptr++ = invalue;
invalue = GETJSAMPLE(*inptr++);
*outptr++ = invalue;
*outptr++ = invalue;
invalue = GETJSAMPLE(*inptr++);
*outptr++ = invalue;
*outptr++ = invalue;
invalue = GETJSAMPLE(*inptr++);
*outptr++ = invalue;
*outptr++ = invalue;
invalue = GETJSAMPLE(*inptr++);
*outptr++ = invalue;
*outptr++ = invalue;
invalue = GETJSAMPLE(*inptr++);
*outptr++ = invalue;
*outptr++ = invalue;
invalue = GETJSAMPLE(*inptr++);
*outptr++ = invalue;
*outptr++ = invalue;
}
#else /* nonstandard DCTSIZE */
for (incol = 0; incol < input_cols; incol++) {
invalue = GETJSAMPLE(*inptr++);
*outptr++ = invalue;
*outptr++ = invalue;
}
#endif
}
}
}
/*
* Un-subsample pixel values of a single component.
* This version handles the special case of a full-size component.
@ -82,8 +164,10 @@ fullsize_unsubsample (decompress_info_ptr cinfo, int which_component,
JSAMPARRAY above, JSAMPARRAY input_data, JSAMPARRAY below,
JSAMPARRAY output_data)
{
if (input_cols != output_cols || input_rows != output_rows) /* DEBUG */
#ifdef DEBUG /* for debugging pipeline controller */
if (input_cols != output_cols || input_rows != output_rows)
ERREXIT(cinfo->emethods, "Pipeline controller messed up");
#endif
jcopy_sample_rows(input_data, 0, output_data, 0, output_rows, output_cols);
}
@ -121,9 +205,12 @@ jselunsubsample (decompress_info_ptr cinfo)
if (compptr->h_samp_factor == cinfo->max_h_samp_factor &&
compptr->v_samp_factor == cinfo->max_v_samp_factor)
cinfo->methods->unsubsample[ci] = fullsize_unsubsample;
else if (compptr->h_samp_factor * 2 == cinfo->max_h_samp_factor &&
(cinfo->max_v_samp_factor % compptr->v_samp_factor) == 0)
cinfo->methods->unsubsample[ci] = h2_unsubsample;
else if ((cinfo->max_h_samp_factor % compptr->h_samp_factor) == 0 &&
(cinfo->max_v_samp_factor % compptr->v_samp_factor) == 0)
cinfo->methods->unsubsample[ci] = unsubsample;
cinfo->methods->unsubsample[ci] = int_unsubsample;
else
ERREXIT(cinfo->emethods, "Fractional subsampling not implemented yet");
}

View File

@ -1,7 +1,7 @@
/*
* jerror.c
*
* Copyright (C) 1991, Thomas G. Lane.
* Copyright (C) 1991, 1992, 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.
*
@ -13,9 +13,9 @@
* The error_exit() routine should not return to its caller. Within a
* larger application, you might want to have it do a longjmp() to return
* control to the outer user interface routine. This should work since
* the portable JPEG code doesn't use setjmp/longjmp. However, this won't
* release allocated memory or close temp files --- some bookkeeping would
* need to be added to the memory manager module to make that work.
* the portable JPEG code doesn't use setjmp/longjmp. You should make sure
* that free_all is called either within error_exit or after the return to
* the outer-level routine.
*
* These routines are used by both the compression and decompression code.
*/
@ -25,8 +25,12 @@
#include <stdlib.h> /* to declare exit() */
#endif
#ifndef EXIT_FAILURE /* define exit() codes if not provided */
#define EXIT_FAILURE 1
#endif
static external_methods_ptr methods; /* saved for access to message_parm */
static external_methods_ptr methods; /* saved for access to message_parm, free_all */
METHODDEF void
@ -45,7 +49,8 @@ METHODDEF void
error_exit (const char *msgtext)
{
trace_message(msgtext);
exit(1);
(*methods->free_all) (); /* clean up memory allocation */
exit(EXIT_FAILURE);
}
@ -58,7 +63,7 @@ error_exit (const char *msgtext)
GLOBAL void
jselerror (external_methods_ptr emethods)
{
methods = emethods; /* save struct addr for msg parm access */
methods = emethods; /* save struct addr for later access */
emethods->error_exit = error_exit;
emethods->trace_message = trace_message;

166
jfwddct.c
View File

@ -1,7 +1,7 @@
/*
* jfwddct.c
*
* Copyright (C) 1991, Thomas G. Lane.
* Copyright (C) 1991, 1992, 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.
*
@ -16,25 +16,12 @@
#include "jinclude.h"
/* We assume that right shift corresponds to signed division by 2 with
* rounding towards minus infinity. This is correct for typical "arithmetic
* shift" instructions that shift in copies of the sign bit. But some
* C compilers implement >> with an unsigned shift. For these machines you
* must define RIGHT_SHIFT_IS_UNSIGNED.
* RIGHT_SHIFT provides a signed right shift of an INT32 quantity.
* It is only applied with constant shift counts.
/*
* This routine is specialized to the case DCTSIZE = 8.
*/
#ifdef RIGHT_SHIFT_IS_UNSIGNED
#define SHIFT_TEMPS INT32 shift_temp;
#define RIGHT_SHIFT(x,shft) \
((shift_temp = (x)) < 0 ? \
(shift_temp >> (shft)) | ((~0) << (32-(shft))) : \
(shift_temp >> (shft)))
#else
#define SHIFT_TEMPS
#define RIGHT_SHIFT(x,shft) ((x) >> (shft))
#if DCTSIZE != 8
Sorry, this code only copes with 8x8 DCTs. /* deliberate syntax err */
#endif
@ -138,74 +125,6 @@
#define OCOS_5_16 OSIN_3_16
/*
* Perform a 1-dimensional DCT.
* Note that this code is specialized to the case DCTSIZE = 8.
*/
INLINE
LOCAL void
fast_dct_8 (DCTELEM *in, int stride)
{
/* many tmps have nonoverlapping lifetime -- flashy register colourers
* should be able to do this lot very well
*/
INT32 in0, in1, in2, in3, in4, in5, in6, in7;
INT32 tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7;
INT32 tmp10, tmp11, tmp12, tmp13;
INT32 tmp14, tmp15, tmp16, tmp17;
INT32 tmp25, tmp26;
SHIFT_TEMPS
in0 = in[ 0];
in1 = in[stride ];
in2 = in[stride*2];
in3 = in[stride*3];
in4 = in[stride*4];
in5 = in[stride*5];
in6 = in[stride*6];
in7 = in[stride*7];
tmp0 = in7 + in0;
tmp1 = in6 + in1;
tmp2 = in5 + in2;
tmp3 = in4 + in3;
tmp4 = in3 - in4;
tmp5 = in2 - in5;
tmp6 = in1 - in6;
tmp7 = in0 - in7;
tmp10 = tmp3 + tmp0;
tmp11 = tmp2 + tmp1;
tmp12 = tmp1 - tmp2;
tmp13 = tmp0 - tmp3;
in[ 0] = (DCTELEM) UNFIXH((tmp10 + tmp11) * SIN_1_4);
in[stride*4] = (DCTELEM) UNFIXH((tmp10 - tmp11) * COS_1_4);
in[stride*2] = (DCTELEM) UNFIXH(tmp13*COS_1_8 + tmp12*SIN_1_8);
in[stride*6] = (DCTELEM) UNFIXH(tmp13*SIN_1_8 - tmp12*COS_1_8);
tmp16 = UNFIXO((tmp6 + tmp5) * SIN_1_4);
tmp15 = UNFIXO((tmp6 - tmp5) * COS_1_4);
OVERSHIFT(tmp4);
OVERSHIFT(tmp7);
/* tmp4, tmp7, tmp15, tmp16 are overscaled by OVERSCALE */
tmp14 = tmp4 + tmp15;
tmp25 = tmp4 - tmp15;
tmp26 = tmp7 - tmp16;
tmp17 = tmp7 + tmp16;
in[stride ] = (DCTELEM) UNFIXH(tmp17*OCOS_1_16 + tmp14*OSIN_1_16);
in[stride*7] = (DCTELEM) UNFIXH(tmp17*OCOS_7_16 - tmp14*OSIN_7_16);
in[stride*5] = (DCTELEM) UNFIXH(tmp26*OCOS_5_16 + tmp25*OSIN_5_16);
in[stride*3] = (DCTELEM) UNFIXH(tmp26*OCOS_3_16 - tmp25*OSIN_3_16);
}
/*
* Perform the forward DCT on one block of samples.
*
@ -216,11 +135,74 @@ fast_dct_8 (DCTELEM *in, int stride)
GLOBAL void
j_fwd_dct (DCTBLOCK data)
{
int i;
for (i = 0; i < DCTSIZE; i++)
fast_dct_8(data+i*DCTSIZE, 1);
int pass, rowctr;
register DCTELEM *inptr, *outptr;
DCTBLOCK workspace;
for (i = 0; i < DCTSIZE; i++)
fast_dct_8(data+i, DCTSIZE);
/* Each iteration of the inner loop performs one 8-point 1-D DCT.
* It reads from a *row* of the input matrix and stores into a *column*
* of the output matrix. In the first pass, we read from the data[] array
* and store into the local workspace[]. In the second pass, we read from
* the workspace[] array and store into data[], thus performing the
* equivalent of a columnar DCT pass with no variable array indexing.
*/
inptr = data; /* initialize pointers for first pass */
outptr = workspace;
for (pass = 1; pass >= 0; pass--) {
for (rowctr = DCTSIZE-1; rowctr >= 0; rowctr--) {
/* many tmps have nonoverlapping lifetime -- flashy register colourers
* should be able to do this lot very well
*/
INT32 tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7;
INT32 tmp10, tmp11, tmp12, tmp13;
INT32 tmp14, tmp15, tmp16, tmp17;
INT32 tmp25, tmp26;
SHIFT_TEMPS
tmp0 = inptr[7] + inptr[0];
tmp1 = inptr[6] + inptr[1];
tmp2 = inptr[5] + inptr[2];
tmp3 = inptr[4] + inptr[3];
tmp4 = inptr[3] - inptr[4];
tmp5 = inptr[2] - inptr[5];
tmp6 = inptr[1] - inptr[6];
tmp7 = inptr[0] - inptr[7];
tmp10 = tmp3 + tmp0;
tmp11 = tmp2 + tmp1;
tmp12 = tmp1 - tmp2;
tmp13 = tmp0 - tmp3;
outptr[ 0] = (DCTELEM) UNFIXH((tmp10 + tmp11) * SIN_1_4);
outptr[DCTSIZE*4] = (DCTELEM) UNFIXH((tmp10 - tmp11) * COS_1_4);
outptr[DCTSIZE*2] = (DCTELEM) UNFIXH(tmp13*COS_1_8 + tmp12*SIN_1_8);
outptr[DCTSIZE*6] = (DCTELEM) UNFIXH(tmp13*SIN_1_8 - tmp12*COS_1_8);
tmp16 = UNFIXO((tmp6 + tmp5) * SIN_1_4);
tmp15 = UNFIXO((tmp6 - tmp5) * COS_1_4);
OVERSHIFT(tmp4);
OVERSHIFT(tmp7);
/* tmp4, tmp7, tmp15, tmp16 are overscaled by OVERSCALE */
tmp14 = tmp4 + tmp15;
tmp25 = tmp4 - tmp15;
tmp26 = tmp7 - tmp16;
tmp17 = tmp7 + tmp16;
outptr[DCTSIZE ] = (DCTELEM) UNFIXH(tmp17*OCOS_1_16 + tmp14*OSIN_1_16);
outptr[DCTSIZE*7] = (DCTELEM) UNFIXH(tmp17*OCOS_7_16 - tmp14*OSIN_7_16);
outptr[DCTSIZE*5] = (DCTELEM) UNFIXH(tmp26*OCOS_5_16 + tmp25*OSIN_5_16);
outptr[DCTSIZE*3] = (DCTELEM) UNFIXH(tmp26*OCOS_3_16 - tmp25*OSIN_3_16);
inptr += DCTSIZE; /* advance inptr to next row */
outptr++; /* advance outptr to next column */
}
/* end of pass; in case it was pass 1, set up for pass 2 */
inptr = workspace;
outptr = data;
}
}

View File

@ -1,7 +1,7 @@
/*
* jinclude.h
*
* Copyright (C) 1991, Thomas G. Lane.
* Copyright (C) 1991, 1992, 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.
*
@ -31,7 +31,7 @@
* Note that the core portable-JPEG files do not actually do any I/O
* using the stdio library; only the user interface, error handler,
* and file reading/writing modules invoke any stdio functions.
* (Well, we did cheat a bit in jvirtmem.c, but only if MEM_STATS is defined.)
* (Well, we did cheat a bit in jmemmgr.c, but only if MEM_STATS is defined.)
*/
#include <stdio.h>
@ -67,9 +67,9 @@
* CAUTION: argument order is different from underlying functions!
*/
#define FREAD(file,buf,sizeofbuf) \
#define JFREAD(file,buf,sizeofbuf) \
((size_t) fread((void *) (buf), (size_t) 1, (size_t) (sizeofbuf), (file)))
#define FWRITE(file,buf,sizeofbuf) \
#define JFWRITE(file,buf,sizeofbuf) \
((size_t) fwrite((const void *) (buf), (size_t) 1, (size_t) (sizeofbuf), (file)))
/*

157
jmemansi.c Normal file
View File

@ -0,0 +1,157 @@
/*
* jmemansi.c (jmemsys.c)
*
* Copyright (C) 1992, 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 provides a simple generic implementation of the system-
* dependent portion of the JPEG memory manager. This implementation
* assumes that you have the ANSI-standard library routine tmpfile().
* Also, the problem of determining the amount of memory available
* is shoved onto the user.
*/
#include "jinclude.h"
#include "jmemsys.h"
#ifdef INCLUDES_ARE_ANSI
#include <stdlib.h> /* to declare malloc(), free() */
#else
extern void * malloc PP((size_t size));
extern void free PP((void *ptr));
#endif
#ifndef SEEK_SET /* pre-ANSI systems may not define this; */
#define SEEK_SET 0 /* if not, assume 0 is correct */
#endif
static external_methods_ptr methods; /* saved for access to error_exit */
static long total_used; /* total memory requested so far */
/*
* Memory allocation and freeing are controlled by the regular library
* routines malloc() and free().
*/
GLOBAL void *
jget_small (size_t sizeofobject)
{
total_used += sizeofobject;
return (void *) malloc(sizeofobject);
}
GLOBAL void
jfree_small (void * object)
{
free(object);
}
/*
* We assume NEED_FAR_POINTERS is not defined and so the separate entry points
* jget_large, jfree_large are not needed.
*/
/*
* This routine computes the total memory space available for allocation.
* It's impossible to do this in a portable way; our current solution is
* to make the user tell us (with a default value set at compile time).
* If you can actually get the available space, it's a good idea to subtract
* a slop factor of 5% or so.
*/
#ifndef DEFAULT_MAX_MEM /* so can override from makefile */
#define DEFAULT_MAX_MEM 1000000L /* default: one megabyte */
#endif
GLOBAL long
jmem_available (long min_bytes_needed, long max_bytes_needed)
{
return methods->max_memory_to_use - total_used;
}
/*
* Backing store (temporary file) management.
* Backing store objects are only used when the value returned by
* jmem_available is less than the total space needed. You can dispense
* with these routines if you have plenty of virtual memory; see jmemnobs.c.
*/
METHODDEF void
read_backing_store (backing_store_ptr info, void FAR * buffer_address,
long file_offset, long byte_count)
{
if (fseek(info->temp_file, file_offset, SEEK_SET))
ERREXIT(methods, "fseek failed on temporary file");
if (JFREAD(info->temp_file, buffer_address, byte_count)
!= (size_t) byte_count)
ERREXIT(methods, "fread failed on temporary file");
}
METHODDEF void
write_backing_store (backing_store_ptr info, void FAR * buffer_address,
long file_offset, long byte_count)
{
if (fseek(info->temp_file, file_offset, SEEK_SET))
ERREXIT(methods, "fseek failed on temporary file");
if (JFWRITE(info->temp_file, buffer_address, byte_count)
!= (size_t) byte_count)
ERREXIT(methods, "fwrite failed on temporary file --- out of disk space?");
}
METHODDEF void
close_backing_store (backing_store_ptr info)
{
fclose(info->temp_file);
/* Since this implementation uses tmpfile() to create the file,
* no explicit file deletion is needed.
*/
}
/*
* Initial opening of a backing-store object.
*
* This version uses tmpfile(), which constructs a suitable file name
* behind the scenes. We don't have to use temp_name[] at all;
* indeed, we can't even find out the actual name of the temp file.
*/
GLOBAL void
jopen_backing_store (backing_store_ptr info, long total_bytes_needed)
{
if ((info->temp_file = tmpfile()) == NULL)
ERREXIT(methods, "Failed to create temporary file");
info->read_backing_store = read_backing_store;
info->write_backing_store = write_backing_store;
info->close_backing_store = close_backing_store;
}
/*
* These routines take care of any system-dependent initialization and
* cleanup required. Keep in mind that jmem_term may be called more than
* once.
*/
GLOBAL void
jmem_init (external_methods_ptr emethods)
{
methods = emethods; /* save struct addr for error exit access */
emethods->max_memory_to_use = DEFAULT_MAX_MEM;
total_used = 0;
}
GLOBAL void
jmem_term (void)
{
/* no work */
}

608
jmemdos.c Normal file
View File

@ -0,0 +1,608 @@
/*
* jmemdos.c (jmemsys.c)
*
* Copyright (C) 1992, 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 provides an MS-DOS-compatible implementation of the system-
* dependent portion of the JPEG memory manager. Temporary data can be
* stored in extended or expanded memory as well as in regular DOS files.
*
* If you use this file, you must be sure that NEED_FAR_POINTERS is defined
* if you compile in a small-data memory model; it should NOT be defined if
* you use a large-data memory model. This file is not recommended if you
* are using a flat-memory-space 386 environment such as DJGCC or Watcom C.
*
* Based on code contributed by Ge' Weijers.
*/
/*
* If you have both extended and expanded memory, you may want to change the
* order in which they are tried in jopen_backing_store. On a 286 machine
* expanded memory is usually faster, since extended memory access involves
* an expensive protected-mode-and-back switch. On 386 and better, extended
* memory is usually faster. As distributed, the code tries extended memory
* first (what? not everyone has a 386? :-).
*
* You can disable use of extended/expanded memory entirely by altering these
* definitions or overriding them from the Makefile (eg, -DEMS_SUPPORTED=0).
*/
#ifndef XMS_SUPPORTED
#define XMS_SUPPORTED 1
#endif
#ifndef EMS_SUPPORTED
#define EMS_SUPPORTED 1
#endif
#include "jinclude.h"
#include "jmemsys.h"
#ifdef INCLUDES_ARE_ANSI
#include <stdlib.h> /* to declare malloc(), free() */
#else
extern void * malloc PP((size_t size));
extern void free PP((void *ptr));
#endif
#ifdef NEED_FAR_POINTERS
#ifdef __TURBOC__
/* These definitions work for Borland C (Turbo C) */
#include <alloc.h> /* need farmalloc(), farfree() */
#define far_malloc(x) farmalloc(x)
#define far_free(x) farfree(x)
#else
/* These definitions work for Microsoft C and compatible compilers */
#include <malloc.h> /* need _fmalloc(), _ffree() */
#define far_malloc(x) _fmalloc(x)
#define far_free(x) _ffree(x)
#endif
#endif
#ifdef DONT_USE_B_MODE /* define mode parameters for fopen() */
#define READ_BINARY "r"
#else
#define READ_BINARY "rb"
#endif
/*
* Declarations for assembly-language support routines (see jmemdosa.asm).
*
* The functions are declared "far" as are all pointer arguments;
* this ensures the assembly source code will work regardless of the
* compiler memory model. We assume "short" is 16 bits, "long" is 32.
*/
typedef void far * XMSDRIVER; /* actually a pointer to code */
typedef struct { /* registers for calling XMS driver */
unsigned short ax, dx, bx;
void far * ds_si;
} XMScontext;
typedef struct { /* registers for calling EMS driver */
unsigned short ax, dx, bx;
void far * ds_si;
} EMScontext;
EXTERN short far jdos_open PP((short far * handle, char far * filename));
EXTERN short far jdos_close PP((short handle));
EXTERN short far jdos_seek PP((short handle, long offset));
EXTERN short far jdos_read PP((short handle, void far * buffer,
unsigned short count));
EXTERN short far jdos_write PP((short handle, void far * buffer,
unsigned short count));
EXTERN void far jxms_getdriver PP((XMSDRIVER far *));
EXTERN void far jxms_calldriver PP((XMSDRIVER, XMScontext far *));
EXTERN short far jems_available PP((void));
EXTERN void far jems_calldriver PP((EMScontext far *));
static external_methods_ptr methods; /* saved for access to error_exit */
static long total_used; /* total FAR memory requested so far */
/*
* Selection of a file name for a temporary file.
* This is highly system-dependent, and you may want to customize it.
*/
static int next_file_num; /* to distinguish among several temp files */
LOCAL void
select_file_name (char * fname)
{
const char * env;
char * ptr;
FILE * tfile;
/* Keep generating file names till we find one that's not in use */
for (;;) {
/* Get temp directory name from environment TMP or TEMP variable;
* if none, use "."
*/
if ((env = (const char *) getenv("TMP")) == NULL)
if ((env = (const char *) getenv("TEMP")) == NULL)
env = ".";
if (*env == '\0') /* null string means "." */
env = ".";
ptr = fname; /* copy name to fname */
while (*env != '\0')
*ptr++ = *env++;
if (ptr[-1] != '\\' && ptr[-1] != '/')
*ptr++ = '\\'; /* append backslash if not in env variable */
/* Append a suitable file name */
next_file_num++; /* advance counter */
sprintf(ptr, "JPG%03d.TMP", next_file_num);
/* Probe to see if file name is already in use */
if ((tfile = fopen(fname, READ_BINARY)) == NULL)
break;
fclose(tfile); /* oops, it's there; close tfile & try again */
}
}
/*
* Near-memory allocation and freeing are controlled by the regular library
* routines malloc() and free().
*/
GLOBAL void *
jget_small (size_t sizeofobject)
{
/* near data space is NOT counted in total_used */
#ifndef NEED_FAR_POINTERS
total_used += sizeofobject;
#endif
return (void *) malloc(sizeofobject);
}
GLOBAL void
jfree_small (void * object)
{
free(object);
}
/*
* Far-memory allocation and freeing
*/
#ifdef NEED_FAR_POINTERS
GLOBAL void FAR *
jget_large (size_t sizeofobject)
{
total_used += sizeofobject;
return (void FAR *) far_malloc(sizeofobject);
}
GLOBAL void
jfree_large (void FAR * object)
{
far_free(object);
}
#endif
/*
* This routine computes the total memory space available for allocation.
* It's impossible to do this in a portable way; our current solution is
* to make the user tell us (with a default value set at compile time).
* If you can actually get the available space, it's a good idea to subtract
* a slop factor of 5% or so.
*/
#ifndef DEFAULT_MAX_MEM /* so can override from makefile */
#define DEFAULT_MAX_MEM 300000L /* for total usage about 450K */
#endif
GLOBAL long
jmem_available (long min_bytes_needed, long max_bytes_needed)
{
return methods->max_memory_to_use - total_used;
}
/*
* Backing store (temporary file) management.
* Backing store objects are only used when the value returned by
* jmem_available is less than the total space needed. You can dispense
* with these routines if you have plenty of virtual memory; see jmemnobs.c.
*/
/*
* For MS-DOS we support three types of backing storage:
* 1. Conventional DOS files. We access these by direct DOS calls rather
* than via the stdio package. This provides a bit better performance,
* but the real reason is that the buffers to be read or written are FAR.
* The stdio library for small-data memory models can't cope with that.
* 2. Extended memory, accessed per the XMS V2.0 specification.
* 3. Expanded memory, accessed per the LIM/EMS 4.0 specification.
* You'll need copies of those specs to make sense of the related code.
* The specs are available by Internet FTP from SIMTEL20 and its various
* mirror sites; see microsoft/xms20.arc and info/limems41.zip.
*/
/*
* Access methods for a DOS file.
*/
METHODDEF void
read_file_store (backing_store_ptr info, void FAR * buffer_address,
long file_offset, long byte_count)
{
if (jdos_seek(info->handle.file_handle, file_offset))
ERREXIT(methods, "seek failed on temporary file");
/* Since MAX_ALLOC_CHUNK is less than 64K, byte_count will be too. */
if (byte_count > 65535L) /* safety check */
ERREXIT(methods, "MAX_ALLOC_CHUNK should be less than 64K");
if (jdos_read(info->handle.file_handle, buffer_address,
(unsigned short) byte_count))
ERREXIT(methods, "read failed on temporary file");
}
METHODDEF void
write_file_store (backing_store_ptr info, void FAR * buffer_address,
long file_offset, long byte_count)
{
if (jdos_seek(info->handle.file_handle, file_offset))
ERREXIT(methods, "seek failed on temporary file");
/* Since MAX_ALLOC_CHUNK is less than 64K, byte_count will be too. */
if (byte_count > 65535L) /* safety check */
ERREXIT(methods, "MAX_ALLOC_CHUNK should be less than 64K");
if (jdos_write(info->handle.file_handle, buffer_address,
(unsigned short) byte_count))
ERREXIT(methods, "write failed on temporary file --- out of disk space?");
}
METHODDEF void
close_file_store (backing_store_ptr info)
{
jdos_close(info->handle.file_handle); /* close the file */
remove(info->temp_name); /* delete the file */
/* If your system doesn't have remove(), try unlink() instead.
* remove() is the ANSI-standard name for this function, but
* unlink() was more common in pre-ANSI systems.
*/
TRACEMS1(methods, 1, "Closed DOS file %d", info->handle.file_handle);
}
LOCAL boolean
open_file_store (backing_store_ptr info, long total_bytes_needed)
{
short handle;
char tracemsg[TEMP_NAME_LENGTH+40];
select_file_name(info->temp_name);
if (jdos_open((short far *) & handle, (char far *) info->temp_name))
return FALSE;
info->handle.file_handle = handle;
info->read_backing_store = read_file_store;
info->write_backing_store = write_file_store;
info->close_backing_store = close_file_store;
/* hack to get around TRACEMS' inability to handle string parameters */
sprintf(tracemsg, "Opened DOS file %d %s", handle, info->temp_name);
TRACEMS(methods, 1, tracemsg);
return TRUE; /* succeeded */
}
/*
* Access methods for extended memory.
*/
#if XMS_SUPPORTED
static XMSDRIVER xms_driver; /* saved address of XMS driver */
typedef union { /* either long offset or real-mode pointer */
long offset;
void far * ptr;
} XMSPTR;
typedef struct { /* XMS move specification structure */
long length;
XMSH src_handle;
XMSPTR src;
XMSH dst_handle;
XMSPTR dst;
} XMSspec;
#define ODD(X) (((X) & 1L) != 0)
METHODDEF void
read_xms_store (backing_store_ptr info, void FAR * buffer_address,
long file_offset, long byte_count)
{
XMScontext ctx;
XMSspec spec;
char endbuffer[2];
/* The XMS driver can't cope with an odd length, so handle the last byte
* specially if byte_count is odd. We don't expect this to be common.
*/
spec.length = byte_count & (~ 1L);
spec.src_handle = info->handle.xms_handle;
spec.src.offset = file_offset;
spec.dst_handle = 0;
spec.dst.ptr = buffer_address;
ctx.ds_si = (void far *) & spec;
ctx.ax = 0x0b00; /* EMB move */
jxms_calldriver(xms_driver, (XMScontext far *) & ctx);
if (ctx.ax != 1)
ERREXIT(methods, "read from extended memory failed");
if (ODD(byte_count)) {
read_xms_store(info, (void FAR *) endbuffer,
file_offset + byte_count - 1L, 2L);
((char FAR *) buffer_address)[byte_count - 1L] = endbuffer[0];
}
}
METHODDEF void
write_xms_store (backing_store_ptr info, void FAR * buffer_address,
long file_offset, long byte_count)
{
XMScontext ctx;
XMSspec spec;
char endbuffer[2];
/* The XMS driver can't cope with an odd length, so handle the last byte
* specially if byte_count is odd. We don't expect this to be common.
*/
spec.length = byte_count & (~ 1L);
spec.src_handle = 0;
spec.src.ptr = buffer_address;
spec.dst_handle = info->handle.xms_handle;
spec.dst.offset = file_offset;
ctx.ds_si = (void far *) & spec;
ctx.ax = 0x0b00; /* EMB move */
jxms_calldriver(xms_driver, (XMScontext far *) & ctx);
if (ctx.ax != 1)
ERREXIT(methods, "write to extended memory failed");
if (ODD(byte_count)) {
read_xms_store(info, (void FAR *) endbuffer,
file_offset + byte_count - 1L, 2L);
endbuffer[0] = ((char FAR *) buffer_address)[byte_count - 1L];
write_xms_store(info, (void FAR *) endbuffer,
file_offset + byte_count - 1L, 2L);
}
}
METHODDEF void
close_xms_store (backing_store_ptr info)
{
XMScontext ctx;
ctx.dx = info->handle.xms_handle;
ctx.ax = 0x0a00;
jxms_calldriver(xms_driver, (XMScontext far *) & ctx);
TRACEMS1(methods, 1, "Freed XMS handle %u", info->handle.xms_handle);
/* we ignore any error return from the driver */
}
LOCAL boolean
open_xms_store (backing_store_ptr info, long total_bytes_needed)
{
XMScontext ctx;
/* Get address of XMS driver */
jxms_getdriver((XMSDRIVER far *) & xms_driver);
if (xms_driver == NULL)
return FALSE; /* no driver to be had */
/* Get version number, must be >= 2.00 */
ctx.ax = 0x0000;
jxms_calldriver(xms_driver, (XMScontext far *) & ctx);
if (ctx.ax < (unsigned short) 0x0200)
return FALSE;
/* Try to get space (expressed in kilobytes) */
ctx.dx = (unsigned short) ((total_bytes_needed + 1023L) >> 10);
ctx.ax = 0x0900;
jxms_calldriver(xms_driver, (XMScontext far *) & ctx);
if (ctx.ax != 1)
return FALSE;
/* Succeeded, save the handle and away we go */
info->handle.xms_handle = ctx.dx;
info->read_backing_store = read_xms_store;
info->write_backing_store = write_xms_store;
info->close_backing_store = close_xms_store;
TRACEMS1(methods, 1, "Obtained XMS handle %u", ctx.dx);
return TRUE; /* succeeded */
}
#endif /* XMS_SUPPORTED */
/*
* Access methods for expanded memory.
*/
#if EMS_SUPPORTED
typedef union { /* either offset/page or real-mode pointer */
struct { unsigned short offset, page; } ems;
void far * ptr;
} EMSPTR;
typedef struct { /* EMS move specification structure */
long length;
char src_type; /* 1 = EMS, 0 = conventional memory */
EMSH src_handle; /* use 0 if conventional memory */
EMSPTR src;
char dst_type;
EMSH dst_handle;
EMSPTR dst;
} EMSspec;
#define EMSPAGESIZE 16384L /* gospel, see the EMS specs */
#define HIBYTE(W) (((W) >> 8) & 0xFF)
#define LOBYTE(W) ((W) & 0xFF)
METHODDEF void
read_ems_store (backing_store_ptr info, void FAR * buffer_address,
long file_offset, long byte_count)
{
EMScontext ctx;
EMSspec spec;
spec.length = byte_count;
spec.src_type = 1;
spec.src_handle = info->handle.ems_handle;
spec.src.ems.page = (unsigned short) (file_offset / EMSPAGESIZE);
spec.src.ems.offset = (unsigned short) (file_offset % EMSPAGESIZE);
spec.dst_type = 0;
spec.dst_handle = 0;
spec.dst.ptr = buffer_address;
ctx.ds_si = (void far *) & spec;
ctx.ax = 0x5700; /* move memory region */
jems_calldriver((EMScontext far *) & ctx);
if (HIBYTE(ctx.ax) != 0)
ERREXIT(methods, "read from expanded memory failed");
}
METHODDEF void
write_ems_store (backing_store_ptr info, void FAR * buffer_address,
long file_offset, long byte_count)
{
EMScontext ctx;
EMSspec spec;
spec.length = byte_count;
spec.src_type = 0;
spec.src_handle = 0;
spec.src.ptr = buffer_address;
spec.dst_type = 1;
spec.dst_handle = info->handle.ems_handle;
spec.dst.ems.page = (unsigned short) (file_offset / EMSPAGESIZE);
spec.dst.ems.offset = (unsigned short) (file_offset % EMSPAGESIZE);
ctx.ds_si = (void far *) & spec;
ctx.ax = 0x5700; /* move memory region */
jems_calldriver((EMScontext far *) & ctx);
if (HIBYTE(ctx.ax) != 0)
ERREXIT(methods, "write to expanded memory failed");
}
METHODDEF void
close_ems_store (backing_store_ptr info)
{
EMScontext ctx;
ctx.ax = 0x4500;
ctx.dx = info->handle.ems_handle;
jems_calldriver((EMScontext far *) & ctx);
TRACEMS1(methods, 1, "Freed EMS handle %u", info->handle.ems_handle);
/* we ignore any error return from the driver */
}
LOCAL boolean
open_ems_store (backing_store_ptr info, long total_bytes_needed)
{
EMScontext ctx;
/* Is EMS driver there? */
if (! jems_available())
return FALSE;
/* Get status, make sure EMS is OK */
ctx.ax = 0x4000;
jems_calldriver((EMScontext far *) & ctx);
if (HIBYTE(ctx.ax) != 0)
return FALSE;
/* Get version, must be >= 4.0 */
ctx.ax = 0x4600;
jems_calldriver((EMScontext far *) & ctx);
if (HIBYTE(ctx.ax) != 0 || LOBYTE(ctx.ax) < 0x40)
return FALSE;
/* Try to allocate requested space */
ctx.ax = 0x4300;
ctx.bx = (unsigned short) ((total_bytes_needed + EMSPAGESIZE-1L) / EMSPAGESIZE);
jems_calldriver((EMScontext far *) & ctx);
if (HIBYTE(ctx.ax) != 0)
return FALSE;
/* Succeeded, save the handle and away we go */
info->handle.ems_handle = ctx.dx;
info->read_backing_store = read_ems_store;
info->write_backing_store = write_ems_store;
info->close_backing_store = close_ems_store;
TRACEMS1(methods, 1, "Obtained EMS handle %u", ctx.dx);
return TRUE; /* succeeded */
}
#endif /* EMS_SUPPORTED */
/*
* Initial opening of a backing-store object.
*/
GLOBAL void
jopen_backing_store (backing_store_ptr info, long total_bytes_needed)
{
/* Try extended memory, then expanded memory, then regular file. */
#if XMS_SUPPORTED
if (open_xms_store(info, total_bytes_needed))
return;
#endif
#if EMS_SUPPORTED
if (open_ems_store(info, total_bytes_needed))
return;
#endif
if (open_file_store(info, total_bytes_needed))
return;
ERREXIT(methods, "Failed to create temporary file");
}
/*
* These routines take care of any system-dependent initialization and
* cleanup required. Keep in mind that jmem_term may be called more than
* once.
*/
GLOBAL void
jmem_init (external_methods_ptr emethods)
{
methods = emethods; /* save struct addr for error exit access */
emethods->max_memory_to_use = DEFAULT_MAX_MEM;
total_used = 0;
next_file_num = 0;
}
GLOBAL void
jmem_term (void)
{
/* no work */
}

135
jmemdos.h Normal file
View File

@ -0,0 +1,135 @@
/*
* jmemdos.h (jmemsys.h)
*
* Copyright (C) 1992, 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 include file defines the interface between the system-independent
* and system-dependent portions of the JPEG memory manager. (The system-
* independent portion is jmemmgr.c; there are several different versions
* of the system-dependent portion, and of this file for that matter.)
*
* This version is suitable for MS-DOS (80x86) implementations.
*/
/*
* These two functions are used to allocate and release small chunks of
* memory (typically the total amount requested through jget_small is
* no more than 20Kb or so). Behavior should be the same as for the
* standard library functions malloc and free; in particular, jget_small
* returns NULL on failure. On most systems, these ARE malloc and free.
* On an 80x86 machine using small-data memory model, these manage near heap.
*/
EXTERN void * jget_small PP((size_t sizeofobject));
EXTERN void jfree_small PP((void * object));
/*
* These two functions are used to allocate and release large chunks of
* memory (up to the total free space designated by jmem_available).
* The interface is the same as above, except that on an 80x86 machine,
* far pointers are used. On other systems these ARE the same as above.
*/
#ifdef NEED_FAR_POINTERS /* typically not needed except on 80x86 */
EXTERN void FAR * jget_large PP((size_t sizeofobject));
EXTERN void jfree_large PP((void FAR * object));
#else
#define jget_large(sizeofobject) jget_small(sizeofobject)
#define jfree_large(object) jfree_small(object)
#endif
/*
* The macro MAX_ALLOC_CHUNK designates the maximum number of bytes that may
* be requested in a single call on jget_large (and jget_small for that
* matter, but that case should never come into play). This macro is needed
* to model the 64Kb-segment-size limit of far addressing on 80x86 machines.
* On machines with flat address spaces, any large constant may be used here.
*/
#define MAX_ALLOC_CHUNK 65400L
/*
* This routine computes the total space available for allocation by
* jget_large. If more space than this is needed, backing store will be used.
* NOTE: any memory already allocated must not be counted.
*
* There is a minimum space requirement, corresponding to the minimum
* feasible buffer sizes; jmemmgr.c will request that much space even if
* jmem_available returns zero. The maximum space needed, enough to hold
* all working storage in memory, is also passed in case it is useful.
*
* It is OK for jmem_available to underestimate the space available (that'll
* just lead to more backing-store access than is really necessary).
* However, an overestimate will lead to failure. Hence it's wise to subtract
* a slop factor from the true available space, especially if jget_small space
* comes from the same pool. 5% should be enough.
*
* On machines with lots of virtual memory, any large constant may be returned.
* Conversely, zero may be returned to always use the minimum amount of memory.
*/
EXTERN long jmem_available PP((long min_bytes_needed, long max_bytes_needed));
/*
* This structure holds whatever state is needed to access a single
* backing-store object. The read/write/close method pointers are called
* by jmemmgr.c to manipulate the backing-store object; all other fields
* are private to the system-dependent backing store routines.
*/
#define TEMP_NAME_LENGTH 64 /* max length of a temporary file's name */
typedef unsigned short XMSH; /* type of extended-memory handles */
typedef unsigned short EMSH; /* type of expanded-memory handles */
typedef union {
short file_handle; /* DOS file handle if it's a temp file */
XMSH xms_handle; /* handle if it's a chunk of XMS */
EMSH ems_handle; /* handle if it's a chunk of EMS */
} handle_union;
typedef struct backing_store_struct * backing_store_ptr;
typedef struct backing_store_struct {
/* Methods for reading/writing/closing this backing-store object */
METHOD(void, read_backing_store, (backing_store_ptr info,
void FAR * buffer_address,
long file_offset, long byte_count));
METHOD(void, write_backing_store, (backing_store_ptr info,
void FAR * buffer_address,
long file_offset, long byte_count));
METHOD(void, close_backing_store, (backing_store_ptr info));
/* Private fields for system-dependent backing-store management */
/* For the MS-DOS environment, we need: */
handle_union handle; /* reference to backing-store storage object */
char temp_name[TEMP_NAME_LENGTH]; /* name if it's a file */
} backing_store_info;
/*
* Initial opening of a backing-store object. This must fill in the
* read/write/close pointers in the object. The read/write routines
* may take an error exit if the specified maximum file size is exceeded.
* (If jmem_available always returns a large value, this routine can just
* take an error exit.)
*/
EXTERN void jopen_backing_store PP((backing_store_ptr info,
long total_bytes_needed));
/*
* These routines take care of any system-dependent initialization and
* cleanup required. The system methods struct address should be saved
* by jmem_init in case an error exit must be taken. jmem_term may assume
* that all requested memory has been freed and that all opened backing-
* store objects have been closed.
* NB: jmem_term may be called more than once, and must behave reasonably
* if that happens.
*/
EXTERN void jmem_init PP((external_methods_ptr emethods));
EXTERN void jmem_term PP((void));

379
jmemdosa.asm Normal file
View File

@ -0,0 +1,379 @@
;
; jmemdosa.asm
;
; Copyright (C) 1992, 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 low-level interface routines to support the MS-DOS
; backing store manager (jmemdos.c). Routines are provided to access disk
; files through direct DOS calls, and to access XMS and EMS drivers.
;
; This file should assemble with Microsoft's MASM or any compatible
; assembler (including Borland's Turbo Assembler). If you haven't got
; a compatible assembler, better fall back to jmemansi.c or jmemname.c.
;
; To minimize dependence on the C compiler's register usage conventions,
; we save and restore all 8086 registers, even though most compilers only
; require SI,DI,DS to be preserved. Also, we use only 16-bit-wide return
; values, which everybody returns in AX.
;
; Based on code contributed by Ge' Weijers.
;
JMEMDOSA_TXT segment byte public 'CODE'
assume cs:JMEMDOSA_TXT
public _jdos_open
public _jdos_close
public _jdos_seek
public _jdos_read
public _jdos_write
public _jxms_getdriver
public _jxms_calldriver
public _jems_available
public _jems_calldriver
;
; short far jdos_open (short far * handle, char far * filename)
;
; Create and open a temporary file
;
_jdos_open proc far
push bp ; linkage
mov bp,sp
push si ; save all registers for safety
push di
push bx
push cx
push dx
push es
push ds
mov cx,0 ; normal file attributes
lds dx,dword ptr [bp+10] ; get filename pointer
mov ah,3ch ; create file
int 21h
jc open_err ; if failed, return error code
lds bx,dword ptr [bp+6] ; get handle pointer
mov word ptr [bx],ax ; save the handle
xor ax,ax ; return zero for OK
open_err: pop ds ; restore registers and exit
pop es
pop dx
pop cx
pop bx
pop di
pop si
pop bp
ret
_jdos_open endp
;
; short far jdos_close (short handle)
;
; Close the file handle
;
_jdos_close proc far
push bp ; linkage
mov bp,sp
push si ; save all registers for safety
push di
push bx
push cx
push dx
push es
push ds
mov bx,word ptr [bp+6] ; file handle
mov ah,3eh ; close file
int 21h
jc close_err ; if failed, return error code
xor ax,ax ; return zero for OK
close_err: pop ds ; restore registers and exit
pop es
pop dx
pop cx
pop bx
pop di
pop si
pop bp
ret
_jdos_close endp
;
; short far jdos_seek (short handle, long offset)
;
; Set file position
;
_jdos_seek proc far
push bp ; linkage
mov bp,sp
push si ; save all registers for safety
push di
push bx
push cx
push dx
push es
push ds
mov bx,word ptr [bp+6] ; file handle
mov dx,word ptr [bp+8] ; LS offset
mov cx,word ptr [bp+10] ; MS offset
mov ax,4200h ; absolute seek
int 21h
jc seek_err ; if failed, return error code
xor ax,ax ; return zero for OK
seek_err: pop ds ; restore registers and exit
pop es
pop dx
pop cx
pop bx
pop di
pop si
pop bp
ret
_jdos_seek endp
;
; short far jdos_read (short handle, void far * buffer, unsigned short count)
;
; Read from file
;
_jdos_read proc far
push bp ; linkage
mov bp,sp
push si ; save all registers for safety
push di
push bx
push cx
push dx
push es
push ds
mov bx,word ptr [bp+6] ; file handle
lds dx,dword ptr [bp+8] ; buffer address
mov cx,word ptr [bp+12] ; number of bytes
mov ah,3fh ; read file
int 21h
jc read_err ; if failed, return error code
cmp ax,word ptr [bp+12] ; make sure all bytes were read
je read_ok
mov ax,1 ; else return 1 for not OK
jmp short read_err
read_ok: xor ax,ax ; return zero for OK
read_err: pop ds ; restore registers and exit
pop es
pop dx
pop cx
pop bx
pop di
pop si
pop bp
ret
_jdos_read endp
;
; short far jdos_write (short handle, void far * buffer, unsigned short count)
;
; Write to file
;
_jdos_write proc far
push bp ; linkage
mov bp,sp
push si ; save all registers for safety
push di
push bx
push cx
push dx
push es
push ds
mov bx,word ptr [bp+6] ; file handle
lds dx,dword ptr [bp+8] ; buffer address
mov cx,word ptr [bp+12] ; number of bytes
mov ah,40h ; write file
int 21h
jc write_err ; if failed, return error code
cmp ax,word ptr [bp+12] ; make sure all bytes written
je write_ok
mov ax,1 ; else return 1 for not OK
jmp short write_err
write_ok: xor ax,ax ; return zero for OK
write_err: pop ds ; restore registers and exit
pop es
pop dx
pop cx
pop bx
pop di
pop si
pop bp
ret
_jdos_write endp
;
; void far jxms_getdriver (XMSDRIVER far *)
;
; Get the address of the XMS driver, or NULL if not available
;
_jxms_getdriver proc far
push bp ; linkage
mov bp,sp
push si ; save all registers for safety
push di
push bx
push cx
push dx
push es
push ds
mov ax,4300h ; call multiplex interrupt with
int 2fh ; a magic cookie, hex 4300
cmp al,80h ; AL should contain hex 80
je xmsavail
xor dx,dx ; no XMS driver available
xor ax,ax ; return a nil pointer
jmp short xmsavail_done
xmsavail: mov ax,4310h ; fetch driver address with
int 2fh ; another magic cookie
mov dx,es ; copy address to dx:ax
mov ax,bx
xmsavail_done: les bx,dword ptr [bp+6] ; get pointer to return value
mov word ptr es:[bx],ax
mov word ptr es:[bx+2],dx
pop ds ; restore registers and exit
pop es
pop dx
pop cx
pop bx
pop di
pop si
pop bp
ret
_jxms_getdriver endp
;
; void far jxms_calldriver (XMSDRIVER, XMScontext far *)
;
; The XMScontext structure contains values for the AX,DX,BX,SI,DS registers.
; These are loaded, the XMS call is performed, and the new values of the
; AX,DX,BX registers are written back to the context structure.
;
_jxms_calldriver proc far
push bp ; linkage
mov bp,sp
push si ; save all registers for safety
push di
push bx
push cx
push dx
push es
push ds
les bx,dword ptr [bp+10] ; get XMScontext pointer
mov ax,word ptr es:[bx] ; load registers
mov dx,word ptr es:[bx+2]
mov si,word ptr es:[bx+6]
mov ds,word ptr es:[bx+8]
mov bx,word ptr es:[bx+4]
call dword ptr [bp+6] ; call the driver
mov cx,bx ; save returned BX for a sec
les bx,dword ptr [bp+10] ; get XMScontext pointer
mov word ptr es:[bx],ax ; put back ax,dx,bx
mov word ptr es:[bx+2],dx
mov word ptr es:[bx+4],cx
pop ds ; restore registers and exit
pop es
pop dx
pop cx
pop bx
pop di
pop si
pop bp
ret
_jxms_calldriver endp
;
; short far jems_available (void)
;
; Have we got an EMS driver? (this comes straight from the EMS 4.0 specs)
;
_jems_available proc far
push si ; save all registers for safety
push di
push bx
push cx
push dx
push es
push ds
mov ax,3567h ; get interrupt vector 67h
int 21h
push cs
pop ds
mov di,000ah ; check offs 10 in returned seg
lea si,ASCII_device_name ; against literal string
mov cx,8
cld
repe cmpsb
jne no_ems
mov ax,1 ; match, it's there
jmp short avail_done
no_ems: xor ax,ax ; it's not there
avail_done: pop ds ; restore registers and exit
pop es
pop dx
pop cx
pop bx
pop di
pop si
ret
ASCII_device_name db "EMMXXXX0"
_jems_available endp
;
; void far jems_calldriver (EMScontext far *)
;
; The EMScontext structure contains values for the AX,DX,BX,SI,DS registers.
; These are loaded, the EMS trap is performed, and the new values of the
; AX,DX,BX registers are written back to the context structure.
;
_jems_calldriver proc far
push bp ; linkage
mov bp,sp
push si ; save all registers for safety
push di
push bx
push cx
push dx
push es
push ds
les bx,dword ptr [bp+6] ; get EMScontext pointer
mov ax,word ptr es:[bx] ; load registers
mov dx,word ptr es:[bx+2]
mov si,word ptr es:[bx+6]
mov ds,word ptr es:[bx+8]
mov bx,word ptr es:[bx+4]
int 67h ; call the EMS driver
mov cx,bx ; save returned BX for a sec
les bx,dword ptr [bp+6] ; get EMScontext pointer
mov word ptr es:[bx],ax ; put back ax,dx,bx
mov word ptr es:[bx+2],dx
mov word ptr es:[bx+4],cx
pop ds ; restore registers and exit
pop es
pop dx
pop cx
pop bx
pop di
pop si
pop bp
ret
_jems_calldriver endp
JMEMDOSA_TXT ends
end

1049
jmemmgr.c Normal file

File diff suppressed because it is too large Load Diff

248
jmemname.c Normal file
View File

@ -0,0 +1,248 @@
/*
* jmemname.c (jmemsys.c)
*
* Copyright (C) 1992, 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 provides a generic implementation of the system-dependent
* portion of the JPEG memory manager. This implementation assumes that
* you must explicitly construct a name for each temp file.
* Also, the problem of determining the amount of memory available
* is shoved onto the user.
*/
#include "jinclude.h"
#include "jmemsys.h"
#ifdef INCLUDES_ARE_ANSI
#include <stdlib.h> /* to declare malloc(), free() */
#else
extern void * malloc PP((size_t size));
extern void free PP((void *ptr));
#endif
#ifndef SEEK_SET /* pre-ANSI systems may not define this; */
#define SEEK_SET 0 /* if not, assume 0 is correct */
#endif
#ifdef DONT_USE_B_MODE /* define mode parameters for fopen() */
#define READ_BINARY "r"
#define RW_BINARY "w+"
#else
#define READ_BINARY "rb"
#define RW_BINARY "w+b"
#endif
static external_methods_ptr methods; /* saved for access to error_exit */
static long total_used; /* total memory requested so far */
/*
* Selection of a file name for a temporary file.
* This is system-dependent!
*
* The code as given is suitable for most Unix systems, and it is easily
* modified for most non-Unix systems. Some notes:
* 1. The temp file is created in the directory named by TEMP_DIRECTORY.
* The default value is /usr/tmp, which is the conventional place for
* creating large temp files on Unix. On other systems you'll probably
* want to change the file location. You can do this by editing the
* #define, or by defining TEMP_DIRECTORY in CFLAGS in the Makefile.
* For example, you might say
* CFLAGS= ... '-DTEMP_DIRECTORY="/tmp/"'
* Note that double quotes are needed in the text of the macro.
* With most make systems you have to put single quotes around the
* -D construct to preserve the double quotes.
* (Amiga SAS C has trouble with ":" and such in command-line options,
* so we've put in a special case for the preferred Amiga temp directory.)
*
* 2. If you need to change the file name as well as its location,
* you can override the TEMP_FILE_NAME macro. (Note that this is
* actually a printf format string; it must contain %s and %d.)
* Few people should need to do this.
*
* 3. mktemp() is used to ensure that multiple processes running
* simultaneously won't select the same file names. If your system
* doesn't have mktemp(), define NO_MKTEMP to do it the hard way.
*
* 4. You probably want to define NEED_SIGNAL_CATCHER so that jcmain/jdmain
* will cause the temp files to be removed if you stop the program early.
*/
#ifndef TEMP_DIRECTORY /* so can override from Makefile */
#ifdef AMIGA
#define TEMP_DIRECTORY "JPEGTMP:" /* recommended setting for Amiga */
#else
#define TEMP_DIRECTORY "/usr/tmp/" /* recommended setting for Unix */
#endif
#endif
static int next_file_num; /* to distinguish among several temp files */
#ifdef NO_MKTEMP
#ifndef TEMP_FILE_NAME /* so can override from Makefile */
#define TEMP_FILE_NAME "%sJPG%03d.TMP"
#endif
LOCAL void
select_file_name (char * fname)
{
FILE * tfile;
/* Keep generating file names till we find one that's not in use */
for (;;) {
next_file_num++; /* advance counter */
sprintf(fname, TEMP_FILE_NAME, TEMP_DIRECTORY, next_file_num);
if ((tfile = fopen(fname, READ_BINARY)) == NULL)
break;
fclose(tfile); /* oops, it's there; close tfile & try again */
}
}
#else /* ! NO_MKTEMP */
/* Note that mktemp() requires the initial filename to end in six X's */
#ifndef TEMP_FILE_NAME /* so can override from Makefile */
#define TEMP_FILE_NAME "%sJPG%dXXXXXX"
#endif
LOCAL void
select_file_name (char * fname)
{
next_file_num++; /* advance counter */
sprintf(fname, TEMP_FILE_NAME, TEMP_DIRECTORY, next_file_num);
mktemp(fname); /* make sure file name is unique */
/* mktemp replaces the trailing XXXXXX with a unique string of characters */
}
#endif /* NO_MKTEMP */
/*
* Memory allocation and freeing are controlled by the regular library
* routines malloc() and free().
*/
GLOBAL void *
jget_small (size_t sizeofobject)
{
total_used += sizeofobject;
return (void *) malloc(sizeofobject);
}
GLOBAL void
jfree_small (void * object)
{
free(object);
}
/*
* We assume NEED_FAR_POINTERS is not defined and so the separate entry points
* jget_large, jfree_large are not needed.
*/
/*
* This routine computes the total memory space available for allocation.
* It's impossible to do this in a portable way; our current solution is
* to make the user tell us (with a default value set at compile time).
* If you can actually get the available space, it's a good idea to subtract
* a slop factor of 5% or so.
*/
#ifndef DEFAULT_MAX_MEM /* so can override from makefile */
#define DEFAULT_MAX_MEM 1000000L /* default: one megabyte */
#endif
GLOBAL long
jmem_available (long min_bytes_needed, long max_bytes_needed)
{
return methods->max_memory_to_use - total_used;
}
/*
* Backing store (temporary file) management.
* Backing store objects are only used when the value returned by
* jmem_available is less than the total space needed. You can dispense
* with these routines if you have plenty of virtual memory; see jmemnobs.c.
*/
METHODDEF void
read_backing_store (backing_store_ptr info, void FAR * buffer_address,
long file_offset, long byte_count)
{
if (fseek(info->temp_file, file_offset, SEEK_SET))
ERREXIT(methods, "fseek failed on temporary file");
if (JFREAD(info->temp_file, buffer_address, byte_count)
!= (size_t) byte_count)
ERREXIT(methods, "fread failed on temporary file");
}
METHODDEF void
write_backing_store (backing_store_ptr info, void FAR * buffer_address,
long file_offset, long byte_count)
{
if (fseek(info->temp_file, file_offset, SEEK_SET))
ERREXIT(methods, "fseek failed on temporary file");
if (JFWRITE(info->temp_file, buffer_address, byte_count)
!= (size_t) byte_count)
ERREXIT(methods, "fwrite failed on temporary file --- out of disk space?");
}
METHODDEF void
close_backing_store (backing_store_ptr info)
{
fclose(info->temp_file); /* close the file */
unlink(info->temp_name); /* delete the file */
/* If your system doesn't have unlink(), use remove() instead.
* remove() is the ANSI-standard name for this function, but if
* your system was ANSI you'd be using jmemansi.c, right?
*/
}
GLOBAL void
jopen_backing_store (backing_store_ptr info, long total_bytes_needed)
{
char tracemsg[TEMP_NAME_LENGTH+40];
select_file_name(info->temp_name);
if ((info->temp_file = fopen(info->temp_name, RW_BINARY)) == NULL)
ERREXIT(methods, "Failed to create temporary file");
info->read_backing_store = read_backing_store;
info->write_backing_store = write_backing_store;
info->close_backing_store = close_backing_store;
/* hack to get around TRACEMS' inability to handle string parameters */
sprintf(tracemsg, "Using temp file %s", info->temp_name);
TRACEMS(methods, 1, tracemsg);
}
/*
* These routines take care of any system-dependent initialization and
* cleanup required. Keep in mind that jmem_term may be called more than
* once.
*/
GLOBAL void
jmem_init (external_methods_ptr emethods)
{
methods = emethods; /* save struct addr for error exit access */
emethods->max_memory_to_use = DEFAULT_MAX_MEM;
total_used = 0;
next_file_num = 0;
}
GLOBAL void
jmem_term (void)
{
/* no work */
}

96
jmemnobs.c Normal file
View File

@ -0,0 +1,96 @@
/*
* jmemnobs.c (jmemsys.c)
*
* Copyright (C) 1992, 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 provides a really simple implementation of the system-
* dependent portion of the JPEG memory manager. This implementation
* assumes that no backing-store files are needed: all required space
* can be obtained from malloc().
* This is very portable in the sense that it'll compile on almost anything,
* but you'd better have lots of main memory (or virtual memory) if you want
* to process big images.
* Note that the max_memory_to_use option is ignored by this implementation.
*/
#include "jinclude.h"
#include "jmemsys.h"
#ifdef INCLUDES_ARE_ANSI
#include <stdlib.h> /* to declare malloc(), free() */
#else
extern void * malloc PP((size_t size));
extern void free PP((void *ptr));
#endif
static external_methods_ptr methods; /* saved for access to error_exit */
/*
* Memory allocation and freeing are controlled by the regular library
* routines malloc() and free().
*/
GLOBAL void *
jget_small (size_t sizeofobject)
{
return (void *) malloc(sizeofobject);
}
GLOBAL void
jfree_small (void * object)
{
free(object);
}
/*
* We assume NEED_FAR_POINTERS is not defined and so the separate entry points
* jget_large, jfree_large are not needed.
*/
/*
* This routine computes the total memory space available for allocation.
* Here we always say, "we got all you want bud!"
*/
GLOBAL long
jmem_available (long min_bytes_needed, long max_bytes_needed)
{
return max_bytes_needed;
}
/*
* Backing store (temporary file) management.
* This should never be called and we just error out.
*/
GLOBAL void
jopen_backing_store (backing_store_ptr info, long total_bytes_needed)
{
ERREXIT(methods, "Backing store not supported");
}
/*
* These routines take care of any system-dependent initialization and
* cleanup required. Keep in mind that jmem_term may be called more than
* once.
*/
GLOBAL void
jmem_init (external_methods_ptr emethods)
{
methods = emethods; /* save struct addr for error exit access */
emethods->max_memory_to_use = 0;
}
GLOBAL void
jmem_term (void)
{
/* no work */
}

127
jmemsys.h Normal file
View File

@ -0,0 +1,127 @@
/*
* jmemsys.h
*
* Copyright (C) 1992, 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 include file defines the interface between the system-independent
* and system-dependent portions of the JPEG memory manager. (The system-
* independent portion is jmemmgr.c; there are several different versions
* of the system-dependent portion, and of this file for that matter.)
*
* This is a "generic" skeleton that may need to be modified for particular
* systems. It should be usable as-is on the majority of non-MSDOS machines.
*/
/*
* These two functions are used to allocate and release small chunks of
* memory (typically the total amount requested through jget_small is
* no more than 20Kb or so). Behavior should be the same as for the
* standard library functions malloc and free; in particular, jget_small
* returns NULL on failure. On most systems, these ARE malloc and free.
* On an 80x86 machine using small-data memory model, these manage near heap.
*/
EXTERN void * jget_small PP((size_t sizeofobject));
EXTERN void jfree_small PP((void * object));
/*
* These two functions are used to allocate and release large chunks of
* memory (up to the total free space designated by jmem_available).
* The interface is the same as above, except that on an 80x86 machine,
* far pointers are used. On other systems these ARE the same as above.
*/
#ifdef NEED_FAR_POINTERS /* typically not needed except on 80x86 */
EXTERN void FAR * jget_large PP((size_t sizeofobject));
EXTERN void jfree_large PP((void FAR * object));
#else
#define jget_large(sizeofobject) jget_small(sizeofobject)
#define jfree_large(object) jfree_small(object)
#endif
/*
* The macro MAX_ALLOC_CHUNK designates the maximum number of bytes that may
* be requested in a single call on jget_large (and jget_small for that
* matter, but that case should never come into play). This macro is needed
* to model the 64Kb-segment-size limit of far addressing on 80x86 machines.
* On machines with flat address spaces, any large constant may be used here.
*/
#define MAX_ALLOC_CHUNK 1000000000L
/*
* This routine computes the total space available for allocation by
* jget_large. If more space than this is needed, backing store will be used.
* NOTE: any memory already allocated must not be counted.
*
* There is a minimum space requirement, corresponding to the minimum
* feasible buffer sizes; jmemmgr.c will request that much space even if
* jmem_available returns zero. The maximum space needed, enough to hold
* all working storage in memory, is also passed in case it is useful.
*
* It is OK for jmem_available to underestimate the space available (that'll
* just lead to more backing-store access than is really necessary).
* However, an overestimate will lead to failure. Hence it's wise to subtract
* a slop factor from the true available space, especially if jget_small space
* comes from the same pool. 5% should be enough.
*
* On machines with lots of virtual memory, any large constant may be returned.
* Conversely, zero may be returned to always use the minimum amount of memory.
*/
EXTERN long jmem_available PP((long min_bytes_needed, long max_bytes_needed));
/*
* This structure holds whatever state is needed to access a single
* backing-store object. The read/write/close method pointers are called
* by jmemmgr.c to manipulate the backing-store object; all other fields
* are private to the system-dependent backing store routines.
*/
#define TEMP_NAME_LENGTH 64 /* max length of a temporary file's name */
typedef struct backing_store_struct * backing_store_ptr;
typedef struct backing_store_struct {
/* Methods for reading/writing/closing this backing-store object */
METHOD(void, read_backing_store, (backing_store_ptr info,
void FAR * buffer_address,
long file_offset, long byte_count));
METHOD(void, write_backing_store, (backing_store_ptr info,
void FAR * buffer_address,
long file_offset, long byte_count));
METHOD(void, close_backing_store, (backing_store_ptr info));
/* Private fields for system-dependent backing-store management */
/* For a typical implementation with temp files, we might need: */
FILE * temp_file; /* stdio reference to temp file */
char temp_name[TEMP_NAME_LENGTH]; /* name of temp file */
} backing_store_info;
/*
* Initial opening of a backing-store object. This must fill in the
* read/write/close pointers in the object. The read/write routines
* may take an error exit if the specified maximum file size is exceeded.
* (If jmem_available always returns a large value, this routine can just
* take an error exit.)
*/
EXTERN void jopen_backing_store PP((backing_store_ptr info,
long total_bytes_needed));
/*
* These routines take care of any system-dependent initialization and
* cleanup required. The system methods struct address should be saved
* by jmem_init in case an error exit must be taken. jmem_term may assume
* that all requested memory has been freed and that all opened backing-
* store objects have been closed.
* NB: jmem_term may be called more than once, and must behave reasonably
* if that happens.
*/
EXTERN void jmem_init PP((external_methods_ptr emethods));
EXTERN void jmem_term PP((void));

View File

@ -1,7 +1,7 @@
/*
* jpegdata.h
*
* Copyright (C) 1991, Thomas G. Lane.
* Copyright (C) 1991, 1992, 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.
*
@ -197,11 +197,13 @@ typedef struct { /* A Huffman coding table */
* coding and decoding. These fields should be considered private to the
* Huffman compression & decompression modules.
*/
/* encoding tables: */
UINT16 ehufco[256]; /* code for each symbol */
char ehufsi[256]; /* length of code for each symbol */
/* decoding tables: (element [0] of each array is unused) */
UINT16 mincode[17]; /* smallest code of length k */
INT32 maxcode[18]; /* largest code of length k (-1 if none) */
/* maxcode[17] is a sentinel to ensure huff_DECODE terminates */
/* (maxcode[17] is a sentinel to ensure huff_DECODE terminates) */
short valptr[17]; /* huffval[] index of 1st symbol of length k */
} HUFF_TBL;
@ -280,6 +282,13 @@ struct compress_info_struct {
short max_h_samp_factor; /* largest h_samp_factor */
short max_v_samp_factor; /* largest v_samp_factor */
/*
* These fields may be useful for progress monitoring
*/
int total_passes; /* number of passes expected */
int completed_passes; /* number of passes completed so far */
/*
* These fields are valid during any one scan
*/
@ -332,7 +341,7 @@ struct decompress_info_struct {
/* the following are ignored if not quantize_colors: */
boolean two_pass_quantize; /* use two-pass color quantization? */
boolean use_dithering; /* want color dithering? */
int desired_number_of_colors; /* number of colors to use */
int desired_number_of_colors; /* max number of colors to use */
boolean do_block_smoothing; /* T = apply cross-block smoothing */
boolean do_pixel_smoothing; /* T = apply post-subsampling smoothing */
@ -345,7 +354,8 @@ struct decompress_info_struct {
* JGETC macro, below.
* Note: the user interface is expected to allocate the input_buffer and
* initialize bytes_in_buffer to 0. Also, for JFIF/raw-JPEG input, the UI
* actually supplies the read_jpeg_data method.
* actually supplies the read_jpeg_data method. This is all handled by
* j_d_defaults in a typical implementation.
*/
char * input_buffer; /* start of buffer (private to input code) */
char * next_input_byte; /* => next byte to read from buffer */
@ -395,9 +405,26 @@ struct decompress_info_struct {
short color_out_comps; /* # of color components output by color_convert */
/* (need not match num_components) */
short final_out_comps; /* # of color components in output image */
short final_out_comps; /* # of color components sent to put_pixel_rows */
/* (1 when quantizing colors, else same as color_out_comps) */
/*
* When quantizing colors, the color quantizer leaves a pointer to the output
* colormap in these fields. The colormap is valid from the time put_color_map
* is called (must be before any put_pixel_rows calls) until shutdown (more
* specifically, until free_all is called to release memory).
*/
int actual_number_of_colors; /* actual number of entries */
JSAMPARRAY colormap; /* NULL if not valid */
/* map has color_out_comps rows * actual_number_of_colors columns */
/*
* These fields may be useful for progress monitoring
*/
int total_passes; /* number of passes expected */
int completed_passes; /* number of passes completed so far */
/*
* These fields are valid during any one scan
*/
@ -455,7 +482,7 @@ typedef struct big_barray_control * big_barray_ptr;
* and pseudo-ANSI compilers get confused. To keep one of these bozos happy,
* add -DINCOMPLETE_TYPES_BROKEN to CFLAGS in your Makefile. Then we will
* pseudo-define the structs as containing a single "dummy" field.
* The memory manager(s) #define AM_MEMORY_MANAGER before including this file,
* The memory managers #define AM_MEMORY_MANAGER before including this file,
* so that they can make their own definitions of the structs.
*/
@ -526,21 +553,14 @@ struct external_methods_struct {
/* error_exit if not successful. */
METHOD(void *, alloc_small, (size_t sizeofobject));
METHOD(void, free_small, (void *ptr));
#ifdef NEED_FAR_POINTERS /* routines for getting far-heap space */
METHOD(void FAR *, alloc_medium, (size_t sizeofobject));
METHOD(void, free_medium, (void FAR *ptr));
#else
#define alloc_medium alloc_small
#define free_medium free_small
#endif
METHOD(JSAMPARRAY, alloc_small_sarray, (long samplesperrow,
long numrows));
METHOD(void, free_small_sarray, (JSAMPARRAY ptr,
long numrows));
METHOD(void, free_small_sarray, (JSAMPARRAY ptr));
METHOD(JBLOCKARRAY, alloc_small_barray, (long blocksperrow,
long numrows));
METHOD(void, free_small_barray, (JBLOCKARRAY ptr,
long numrows));
METHOD(void, free_small_barray, (JBLOCKARRAY ptr));
METHOD(big_sarray_ptr, request_big_sarray, (long samplesperrow,
long numrows,
long unitheight));
@ -558,6 +578,9 @@ struct external_methods_struct {
boolean writable));
METHOD(void, free_big_sarray, (big_sarray_ptr ptr));
METHOD(void, free_big_barray, (big_barray_ptr ptr));
METHOD(void, free_all, (void));
long max_memory_to_use; /* maximum amount of memory to use */
};
/* Macros to simplify using the error and trace message stuff */
@ -616,12 +639,15 @@ struct external_methods_struct {
struct compress_methods_struct {
/* Hook for user interface to get control after input_init */
METHOD(void, c_ui_method_selection, (compress_info_ptr cinfo));
/* Hook for user interface to do progress monitoring */
METHOD(void, progress_monitor, (compress_info_ptr cinfo,
long loopcounter, long looplimit));
/* Input image reading & conversion to standard form */
METHOD(void, input_init, (compress_info_ptr cinfo));
METHOD(void, get_input_row, (compress_info_ptr cinfo,
JSAMPARRAY pixel_row));
METHOD(void, input_term, (compress_info_ptr cinfo));
/* Gamma and color space conversion */
/* Color space and gamma conversion */
METHOD(void, colorin_init, (compress_info_ptr cinfo));
METHOD(void, get_sample_rows, (compress_info_ptr cinfo,
int rows_to_read,
@ -675,11 +701,10 @@ struct compress_methods_struct {
struct decompress_methods_struct {
/* Hook for user interface to get control after reading file header */
METHOD(void, d_ui_method_selection, (decompress_info_ptr cinfo));
/* Hook for user interface to do progress monitoring */
METHOD(void, progress_monitor, (decompress_info_ptr cinfo,
long loopcounter, long looplimit));
/* JPEG file scanning */
/* Note: user interface supplies read_jpeg_data for JFIF/raw-JPEG
* reading. For file formats that require random access (eg, TIFF)
* the JPEG file header module will override the UI read_jpeg_data.
*/
METHOD(void, read_file_header, (decompress_info_ptr cinfo));
METHOD(boolean, read_scan_header, (decompress_info_ptr cinfo));
METHOD(int, read_jpeg_data, (decompress_info_ptr cinfo));
@ -691,9 +716,13 @@ struct decompress_methods_struct {
JBLOCK *MCU_data));
METHOD(void, entropy_decoder_term, (decompress_info_ptr cinfo));
/* MCU disassembly: fetch MCUs from entropy_decode, build coef array */
/* The reverse_DCT step is in the same module for symmetry reasons */
METHOD(void, disassemble_init, (decompress_info_ptr cinfo));
METHOD(void, disassemble_MCU, (decompress_info_ptr cinfo,
JBLOCKIMAGE image_data));
METHOD(void, reverse_DCT, (decompress_info_ptr cinfo,
JBLOCKIMAGE coeff_data,
JSAMPIMAGE output_data, int start_row));
METHOD(void, disassemble_term, (decompress_info_ptr cinfo));
/* Cross-block smoothing */
METHOD(void, smooth_coefficients, (decompress_info_ptr cinfo,
@ -707,10 +736,10 @@ struct decompress_methods_struct {
METHOD(void, unsubsample_init, (decompress_info_ptr cinfo));
unsubsample_ptr unsubsample[MAX_COMPS_IN_SCAN];
METHOD(void, unsubsample_term, (decompress_info_ptr cinfo));
/* Gamma and color space conversion */
/* Color space and gamma conversion */
METHOD(void, colorout_init, (decompress_info_ptr cinfo));
METHOD(void, color_convert, (decompress_info_ptr cinfo,
int num_rows,
int num_rows, long num_cols,
JSAMPIMAGE input_data,
JSAMPIMAGE output_data));
METHOD(void, colorout_term, (decompress_info_ptr cinfo));
@ -722,7 +751,8 @@ struct decompress_methods_struct {
JSAMPARRAY output_data));
METHOD(void, color_quant_prescan, (decompress_info_ptr cinfo,
int num_rows,
JSAMPIMAGE image_data));
JSAMPIMAGE image_data,
JSAMPARRAY workspace));
METHOD(void, color_quant_doit, (decompress_info_ptr cinfo,
quantize_caller_ptr source_method));
METHOD(void, color_quant_term, (decompress_info_ptr cinfo));
@ -761,7 +791,6 @@ EXTERN void j_c_defaults PP((compress_info_ptr cinfo, int quality,
EXTERN void j_monochrome_default PP((compress_info_ptr cinfo));
EXTERN void j_set_quality PP((compress_info_ptr cinfo, int quality,
boolean force_baseline));
EXTERN void j_c_free_defaults PP((compress_info_ptr cinfo));
/* main entry for decompression */
EXTERN void jpeg_decompress PP((decompress_info_ptr cinfo));
@ -769,8 +798,6 @@ EXTERN void jpeg_decompress PP((decompress_info_ptr cinfo));
/* default parameter setup for decompression */
EXTERN void j_d_defaults PP((decompress_info_ptr cinfo,
boolean standard_buffering));
EXTERN void j_d_free_defaults PP((decompress_info_ptr cinfo,
boolean standard_buffering));
/* forward DCT */
EXTERN void j_fwd_dct PP((DCTBLOCK data));
@ -822,13 +849,31 @@ EXTERN void jselwtarga PP((decompress_info_ptr cinfo)); /* jwrtarga.c */
/* method selection routines for system-dependent modules */
EXTERN void jselerror PP((external_methods_ptr emethods)); /* jerror.c */
EXTERN void jselvirtmem PP((external_methods_ptr emethods)); /* jvirtmem.c */
EXTERN void jselmemmgr PP((external_methods_ptr emethods)); /* jmemmgr.c */
/* debugging hook in jvirtmem.c */
#ifdef MEM_STATS
EXTERN void j_mem_stats PP((void));
/* We assume that right shift corresponds to signed division by 2 with
* rounding towards minus infinity. This is correct for typical "arithmetic
* shift" instructions that shift in copies of the sign bit. But some
* C compilers implement >> with an unsigned shift. For these machines you
* must define RIGHT_SHIFT_IS_UNSIGNED.
* RIGHT_SHIFT provides a proper signed right shift of an INT32 quantity.
* It is only applied with constant shift counts. SHIFT_TEMPS must be
* included in the variables of any routine using RIGHT_SHIFT.
*/
#ifdef RIGHT_SHIFT_IS_UNSIGNED
#define SHIFT_TEMPS INT32 shift_temp;
#define RIGHT_SHIFT(x,shft) \
((shift_temp = (x)) < 0 ? \
(shift_temp >> (shft)) | ((~((INT32) 0)) << (32-(shft))) : \
(shift_temp >> (shft)))
#else
#define SHIFT_TEMPS
#define RIGHT_SHIFT(x,shft) ((x) >> (shft))
#endif
/* Miscellaneous useful macros */
#undef MAX

506
jquant1.c
View File

@ -1,7 +1,7 @@
/*
* jquant1.c
*
* Copyright (C) 1991, Thomas G. Lane.
* Copyright (C) 1991, 1992, 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.
*
@ -16,45 +16,88 @@
/*
* This implementation is a fairly dumb, quick-and-dirty quantizer;
* it's here mostly so that we can start working on colormapped output formats.
* The main purpose of 1-pass quantization is to provide a fast, if not very
* high quality, colormapped output capability. A 2-pass quantizer usually
* gives better visual quality; however, for quantized grayscale output this
* quantizer is perfectly adequate. Dithering is highly recommended with this
* quantizer, though you can turn it off if you really want to.
*
* We quantize to a color map that is selected in advance of seeing the image;
* the map depends only on the requested number of colors (at least 8).
* The map consists of all combinations of Ncolors[j] color values for each
* component j; we choose Ncolors[] based on the requested # of colors.
* We always use 0 and MAXJSAMPLE in each color (hence the minimum 8 colors).
* Any additional color values are equally spaced between these limits.
* This implementation quantizes in the output colorspace. This has a couple
* of disadvantages: each pixel must be individually color-converted, and if
* the color conversion includes gamma correction then quantization is done in
* a nonlinear space, which is less desirable. The major advantage is that
* with the usual output color spaces (RGB, grayscale) an orthogonal grid of
* representative colors can be used, thus permitting the very simple and fast
* color lookup scheme used here. The standard JPEG colorspace (YCbCr) cannot
* be effectively handled this way, because only about a quarter of an
* orthogonal grid would fall within the gamut of realizable colors. Another
* advantage is that when the user wants quantized grayscale output from a
* color JPEG file, this quantizer can provide a high-quality result with no
* special hacking.
*
* The result almost always needs dithering to look decent.
* The gamma-correction problem could be eliminated by adjusting the grid
* spacing to counteract the gamma correction applied by color_convert.
* At this writing, gamma correction is not implemented by jdcolor, so
* nothing is done here.
*
* In 1-pass quantization the colormap must be chosen in advance of seeing the
* image. We use a map consisting of all combinations of Ncolors[i] color
* values for the i'th component. The Ncolors[] values are chosen so that
* their product, the total number of colors, is no more than that requested.
* (In most cases, the product will be somewhat less.)
*
* Since the colormap is orthogonal, the representative value for each color
* component can be determined without considering the other components;
* then these indexes can be combined into a colormap index by a standard
* N-dimensional-array-subscript calculation. Most of the arithmetic involved
* can be precalculated and stored in the lookup table colorindex[].
* colorindex[i][j] maps pixel value j in component i to the nearest
* representative value (grid plane) for that component; this index is
* multiplied by the array stride for component i, so that the
* index of the colormap entry closest to a given pixel value is just
* sum( colorindex[component-number][pixel-component-value] )
* Aside from being fast, this scheme allows for variable spacing between
* representative values with no additional lookup cost.
*/
#define MAX_COMPONENTS 4 /* max components I can handle */
static int total_colors; /* Number of distinct output colors */
static int Ncolors[MAX_COMPONENTS]; /* # of values alloced to each component */
/* total_colors is the product of the Ncolors[] values */
#define MAX_COMPONENTS 4 /* max components I can handle */
static JSAMPARRAY colormap; /* The actual color map */
/* colormap[i][j] = value of i'th color component for output pixel value j */
static JSAMPARRAY colorindex; /* Precomputed mapping for speed */
/* colorindex[i][j] = index of color closest to pixel value j in component i,
* premultiplied so that the correct mapped value for a pixel (r,g,b) is:
* colorindex[0][r] + colorindex[1][g] + colorindex[2][b]
* premultiplied as described above. Since colormap indexes must fit into
* JSAMPLEs, the entries of this array will too.
*/
static JSAMPARRAY input_buffer; /* color conversion workspace */
/* Since our input data is presented in the JPEG colorspace, we have to call
* color_convert to get it into the output colorspace. input_buffer is a
* one-row-high workspace for the result of color_convert.
*/
/* Declarations for Floyd-Steinberg dithering.
* Errors are accumulated into the arrays evenrowerrs[] and oddrowerrs[],
* each of which have #colors * (#columns + 2) entries (so that first/last
* pixels need not be special cases). These have resolutions of 1/16th of
* a pixel count. The error at a given pixel is propagated to its unprocessed
* neighbors using the standard F-S fractions,
*
* Errors are accumulated into the arrays evenrowerrs[] and oddrowerrs[].
* These have resolutions of 1/16th of a pixel count. The error at a given
* pixel is propagated to its unprocessed neighbors using the standard F-S
* fractions,
* ... (here) 7/16
* 3/16 5/16 1/16
* We work left-to-right on even rows, right-to-left on odd rows.
*
* In each of the xxxrowerrs[] arrays, indexing is [component#][position].
* We provide (#columns + 2) entries per component; the extra entry at each
* end saves us from special-casing the first and last pixels.
* In evenrowerrs[], the entries for a component are stored left-to-right, but
* in oddrowerrs[] they are stored right-to-left. This means we always
* process the current row's error entries in increasing order and the next
* row's error entries in decreasing order, regardless of whether we are
* working L-to-R or R-to-L in the pixel data!
*
* Note: on a wide image, we might not have enough room in a PC's near data
* segment to hold the error arrays; so they are allocated with alloc_medium.
*/
@ -67,10 +110,157 @@ typedef INT32 FSERROR; /* may need more than 16 bits? */
typedef FSERROR FAR *FSERRPTR; /* pointer to error array (in FAR storage!) */
static FSERRPTR evenrowerrs, oddrowerrs; /* current-row and next-row errors */
static FSERRPTR evenrowerrs[MAX_COMPONENTS]; /* errors for even rows */
static FSERRPTR oddrowerrs[MAX_COMPONENTS]; /* errors for odd rows */
static boolean on_odd_row; /* flag to remember which row we are on */
/*
* Policy-making subroutines for color_quant_init: these routines determine
* the colormap to be used. The rest of the module only assumes that the
* colormap is orthogonal.
*
* * select_ncolors decides how to divvy up the available colors
* among the components.
* * output_value defines the set of representative values for a component.
* * largest_input_value defines the mapping from input values to
* representative values for a component.
* Note that the latter two routines may impose different policies for
* different components, though this is not currently done.
*/
LOCAL int
select_ncolors (decompress_info_ptr cinfo, int Ncolors[])
/* Determine allocation of desired colors to components, */
/* and fill in Ncolors[] array to indicate choice. */
/* Return value is total number of colors (product of Ncolors[] values). */
{
int nc = cinfo->color_out_comps; /* number of color components */
int max_colors = cinfo->desired_number_of_colors;
int total_colors, iroot, i;
long temp;
boolean changed;
/* We can allocate at least the nc'th root of max_colors per component. */
/* Compute floor(nc'th root of max_colors). */
iroot = 1;
do {
iroot++;
temp = iroot; /* set temp = iroot ** nc */
for (i = 1; i < nc; i++)
temp *= iroot;
} while (temp <= (long) max_colors); /* repeat till iroot exceeds root */
iroot--; /* now iroot = floor(root) */
/* Must have at least 2 color values per component */
if (iroot < 2)
ERREXIT1(cinfo->emethods, "Cannot quantize to fewer than %d colors",
(int) temp);
if (cinfo->out_color_space == CS_RGB && nc == 3) {
/* We provide a special policy for quantizing in RGB space.
* If 256 colors are requested, we allocate 8 red, 8 green, 4 blue levels;
* this corresponds to the common 3/3/2-bit scheme. For other totals,
* the counts are set so that the number of colors allocated to each
* component are roughly in the proportion R 3, G 4, B 2.
* For low color counts, it's easier to hardwire the optimal choices
* than try to tweak the algorithm to generate them.
*/
if (max_colors == 256) {
Ncolors[0] = 8; Ncolors[1] = 8; Ncolors[2] = 4;
return 256;
}
if (max_colors < 12) {
/* Fixed mapping for 8 colors */
Ncolors[0] = Ncolors[1] = Ncolors[2] = 2;
} else if (max_colors < 18) {
/* Fixed mapping for 12 colors */
Ncolors[0] = 2; Ncolors[1] = 3; Ncolors[2] = 2;
} else if (max_colors < 24) {
/* Fixed mapping for 18 colors */
Ncolors[0] = 3; Ncolors[1] = 3; Ncolors[2] = 2;
} else if (max_colors < 27) {
/* Fixed mapping for 24 colors */
Ncolors[0] = 3; Ncolors[1] = 4; Ncolors[2] = 2;
} else if (max_colors < 36) {
/* Fixed mapping for 27 colors */
Ncolors[0] = 3; Ncolors[1] = 3; Ncolors[2] = 3;
} else {
/* these weights are readily derived with a little algebra */
Ncolors[0] = (iroot * 266) >> 8; /* R weight is 1.0400 */
Ncolors[1] = (iroot * 355) >> 8; /* G weight is 1.3867 */
Ncolors[2] = (iroot * 177) >> 8; /* B weight is 0.6934 */
}
total_colors = Ncolors[0] * Ncolors[1] * Ncolors[2];
/* The above computation produces "floor" values, so we may be able to
* increment the count for one or more components without exceeding
* max_colors. We try in the order B, G, R.
*/
do {
changed = FALSE;
for (i = 2; i >= 0; i--) {
/* calculate new total_colors if Ncolors[i] is incremented */
temp = total_colors / Ncolors[i];
temp *= Ncolors[i]+1; /* done in long arith to avoid oflo */
if (temp <= (long) max_colors) {
Ncolors[i]++; /* OK, apply the increment */
total_colors = (int) temp;
changed = TRUE;
}
}
} while (changed); /* loop until no increment is possible */
} else {
/* For any colorspace besides RGB, treat all the components equally. */
/* Initialize to iroot color values for each component */
total_colors = 1;
for (i = 0; i < nc; i++) {
Ncolors[i] = iroot;
total_colors *= iroot;
}
/* We may be able to increment the count for one or more components without
* exceeding max_colors, though we know not all can be incremented.
*/
for (i = 0; i < nc; i++) {
/* calculate new total_colors if Ncolors[i] is incremented */
temp = total_colors / Ncolors[i];
temp *= Ncolors[i]+1; /* done in long arith to avoid oflo */
if (temp > (long) max_colors)
break; /* won't fit, done */
Ncolors[i]++; /* OK, apply the increment */
total_colors = (int) temp;
}
}
return total_colors;
}
LOCAL int
output_value (decompress_info_ptr cinfo, int ci, int j, int maxj)
/* Return j'th output value, where j will range from 0 to maxj */
/* The output values must fall in 0..MAXJSAMPLE in increasing order */
{
/* We always provide values 0 and MAXJSAMPLE for each component;
* any additional values are equally spaced between these limits.
* (Forcing the upper and lower values to the limits ensures that
* dithering can't produce a color outside the selected gamut.)
*/
return (j * MAXJSAMPLE + maxj/2) / maxj;
}
LOCAL int
largest_input_value (decompress_info_ptr cinfo, int ci, int j, int maxj)
/* Return largest input value that should map to j'th output value */
/* Must have largest(j=0) >= 0, and largest(j=maxj) >= MAXJSAMPLE */
{
/* Breakpoints are halfway between values returned by output_value */
return ((2*j + 1) * MAXJSAMPLE + maxj) / (2*maxj);
}
/*
* Initialize for one-pass color quantization.
*/
@ -78,37 +268,22 @@ static boolean on_odd_row; /* flag to remember which row we are on */
METHODDEF void
color_quant_init (decompress_info_ptr cinfo)
{
int max_colors = cinfo->desired_number_of_colors;
int i,j,k, ntc, nci, blksize, blkdist, ptr, val;
int total_colors; /* Number of distinct output colors */
int Ncolors[MAX_COMPONENTS]; /* # of values alloced to each component */
int i,j,k, nci, blksize, blkdist, ptr, val;
if (cinfo->color_out_comps > MAX_COMPONENTS)
/* Make sure my internal arrays won't overflow */
if (cinfo->num_components > MAX_COMPONENTS ||
cinfo->color_out_comps > MAX_COMPONENTS)
ERREXIT1(cinfo->emethods, "Cannot quantize more than %d color components",
MAX_COMPONENTS);
if (max_colors > (MAXJSAMPLE+1))
/* Make sure colormap indexes can be represented by JSAMPLEs */
if (cinfo->desired_number_of_colors > (MAXJSAMPLE+1))
ERREXIT1(cinfo->emethods, "Cannot request more than %d quantized colors",
MAXJSAMPLE+1);
MAXJSAMPLE+1);
/* Initialize to 2 color values for each component */
total_colors = 1;
for (i = 0; i < cinfo->color_out_comps; i++) {
Ncolors[i] = 2;
total_colors *= 2;
}
if (total_colors > max_colors)
ERREXIT1(cinfo->emethods, "Cannot quantize to fewer than %d colors",
total_colors);
/* Increase the number of color values until requested limit is reached. */
/* Note that for standard RGB color space, we will have at least as many */
/* red values as green, and at least as many green values as blue. */
i = 0; /* component index to increase next */
/* test calculates ntc = new total_colors if Ncolors[i] is incremented */
while ((ntc = (total_colors / Ncolors[i]) * (Ncolors[i]+1)) <= max_colors) {
Ncolors[i]++; /* OK, apply the increment */
total_colors = ntc;
i++; /* advance to next component */
if (i >= cinfo->color_out_comps) i = 0;
}
/* Select number of colors for each component */
total_colors = select_ncolors(cinfo, Ncolors);
/* Report selected color counts */
if (cinfo->color_out_comps == 3)
@ -136,7 +311,7 @@ color_quant_init (decompress_info_ptr cinfo)
blksize = blkdist / nci;
for (j = 0; j < nci; j++) {
/* Compute j'th output value (out of nci) for component */
val = (j * MAXJSAMPLE + (nci-1)/2) / (nci-1);
val = output_value(cinfo, i, j, nci-1);
/* Fill in all colormap entries that have this value of this component */
for (ptr = j * blksize; ptr < total_colors; ptr += blkdist) {
/* fill in blksize entries beginning at ptr */
@ -147,31 +322,67 @@ color_quant_init (decompress_info_ptr cinfo)
blkdist = blksize; /* blksize of this color is blkdist of next */
/* fill in colorindex entries for i'th color component */
/* in loop, val = index of current output value, */
/* and k = largest j that maps to current val */
val = 0;
k = largest_input_value(cinfo, i, 0, nci-1);
for (j = 0; j <= MAXJSAMPLE; j++) {
/* compute index of color closest to pixel value j */
val = (j * (nci-1) + CENTERJSAMPLE) / MAXJSAMPLE;
while (j > k) /* advance val if past boundary */
k = largest_input_value(cinfo, i, ++val, nci-1);
/* premultiply so that no multiplication needed in main processing */
colorindex[i][j] = (JSAMPLE) (val * blksize);
}
}
/* Pass the colormap to the output module. Note that the output */
/* module is allowed to save this pointer and use the map during */
/* any put_pixel_rows call! */
/* Pass the colormap to the output module. */
/* NB: the output module may continue to use the colormap until shutdown. */
cinfo->colormap = colormap;
cinfo->actual_number_of_colors = total_colors;
(*cinfo->methods->put_color_map) (cinfo, total_colors, colormap);
/* Allocate workspace to hold one row of color-converted data */
input_buffer = (*cinfo->emethods->alloc_small_sarray)
(cinfo->image_width, (long) cinfo->color_out_comps);
/* Allocate Floyd-Steinberg workspace if necessary */
if (cinfo->use_dithering) {
size_t arraysize = (cinfo->image_width + 2L) * cinfo->color_out_comps
* SIZEOF(FSERROR);
size_t arraysize = (size_t) ((cinfo->image_width + 2L) * SIZEOF(FSERROR));
evenrowerrs = (FSERRPTR) (*cinfo->emethods->alloc_medium) (arraysize);
oddrowerrs = (FSERRPTR) (*cinfo->emethods->alloc_medium) (arraysize);
/* we only need to zero the forward contribution for current row. */
jzero_far((void FAR *) evenrowerrs, arraysize);
for (i = 0; i < cinfo->color_out_comps; i++) {
evenrowerrs[i] = (FSERRPTR) (*cinfo->emethods->alloc_medium) (arraysize);
oddrowerrs[i] = (FSERRPTR) (*cinfo->emethods->alloc_medium) (arraysize);
/* we only need to zero the forward contribution for current row. */
jzero_far((void FAR *) evenrowerrs[i], arraysize);
}
on_odd_row = FALSE;
}
}
/*
* Subroutines for color conversion methods.
*/
LOCAL void
do_color_conversion (decompress_info_ptr cinfo, JSAMPIMAGE input_data, int row)
/* Convert the indicated row of the input data into output colorspace */
/* in input_buffer. This requires a little trickery since color_convert */
/* expects to deal with 3-D arrays; fortunately we can fake it out */
/* at fairly low cost. */
{
short ci;
JSAMPARRAY input_hack[MAX_COMPONENTS];
JSAMPARRAY output_hack[MAX_COMPONENTS];
/* create JSAMPIMAGE pointing at specified row of input_data */
for (ci = 0; ci < cinfo->num_components; ci++)
input_hack[ci] = input_data[ci] + row;
/* Create JSAMPIMAGE pointing at input_buffer */
for (ci = 0; ci < cinfo->color_out_comps; ci++)
output_hack[ci] = &(input_buffer[ci]);
(*cinfo->methods->color_convert) (cinfo, 1, cinfo->image_width,
input_hack, output_hack);
}
@ -185,19 +396,22 @@ color_quantize (decompress_info_ptr cinfo, int num_rows,
/* General case, no dithering */
{
register int pixcode, ci;
register JSAMPROW ptrout;
register long col;
register int row;
register long widthm1 = cinfo->image_width - 1;
int row;
long width = cinfo->image_width;
register int nc = cinfo->color_out_comps;
for (row = 0; row < num_rows; row++) {
for (col = widthm1; col >= 0; col--) {
do_color_conversion(cinfo, input_data, row);
ptrout = output_data[row];
for (col = 0; col < width; col++) {
pixcode = 0;
for (ci = 0; ci < nc; ci++) {
pixcode += GETJSAMPLE(colorindex[ci]
[GETJSAMPLE(input_data[ci][row][col])]);
[GETJSAMPLE(input_buffer[ci][col])]);
}
output_data[row][col] = (JSAMPLE) pixcode;
*ptrout++ = (JSAMPLE) pixcode;
}
}
}
@ -211,13 +425,14 @@ color_quantize3 (decompress_info_ptr cinfo, int num_rows,
register int pixcode;
register JSAMPROW ptr0, ptr1, ptr2, ptrout;
register long col;
register int row;
register long width = cinfo->image_width;
int row;
long width = cinfo->image_width;
for (row = 0; row < num_rows; row++) {
ptr0 = input_data[0][row];
ptr1 = input_data[1][row];
ptr2 = input_data[2][row];
do_color_conversion(cinfo, input_data, row);
ptr0 = input_buffer[0];
ptr1 = input_buffer[1];
ptr2 = input_buffer[2];
ptrout = output_data[row];
for (col = width; col > 0; col--) {
pixcode = GETJSAMPLE(colorindex[0][GETJSAMPLE(*ptr0++)]);
@ -234,86 +449,79 @@ color_quantize_dither (decompress_info_ptr cinfo, int num_rows,
JSAMPIMAGE input_data, JSAMPARRAY output_data)
/* General case, with Floyd-Steinberg dithering */
{
register int pixcode, ci;
register FSERROR val;
FSERROR two_val;
register FSERRPTR thisrowerr, nextrowerr;
register long col;
register int row;
register long width = cinfo->image_width;
register int nc = cinfo->color_out_comps;
register JSAMPROW input_ptr;
register JSAMPROW output_ptr;
JSAMPROW colorindex_ci;
JSAMPROW colormap_ci;
register int pixcode;
int dir; /* 1 for left-to-right, -1 for right-to-left */
int ci;
int nc = cinfo->color_out_comps;
int row;
long col_counter;
long width = cinfo->image_width;
for (row = 0; row < num_rows; row++) {
if (on_odd_row) {
/* work right to left in this row */
thisrowerr = oddrowerrs + width*nc;
nextrowerr = evenrowerrs + width*nc;
for (ci = 0; ci < nc; ci++) /* need only initialize this one entry */
nextrowerr[ci] = 0;
for (col = width - 1; col >= 0; col--) {
/* select the output pixel value */
pixcode = 0;
for (ci = 0; ci < nc; ci++) {
/* compute pixel value + accumulated error */
val = (((FSERROR) GETJSAMPLE(input_data[ci][row][col])) << 4)
+ thisrowerr[ci];
if (val <= 0) val = 0; /* must watch for range overflow! */
else {
val += 8; /* divide by 16 with proper rounding */
val >>= 4;
if (val > MAXJSAMPLE) val = MAXJSAMPLE;
}
thisrowerr[ci] = val; /* save for error propagation */
pixcode += GETJSAMPLE(colorindex[ci][val]);
}
output_data[row][col] = (JSAMPLE) pixcode;
/* propagate error to adjacent pixels */
for (ci = 0; ci < nc; ci++) {
val = thisrowerr[ci] - (FSERROR) GETJSAMPLE(colormap[ci][pixcode]);
thisrowerr[ci-nc] += val * 7;
nextrowerr[ci+nc] += val * 3;
nextrowerr[ci ] += val * 5;
nextrowerr[ci-nc] = val; /* not +=, since not initialized yet */
}
thisrowerr -= nc; /* advance error ptrs to next pixel entry */
nextrowerr -= nc;
do_color_conversion(cinfo, input_data, row);
/* Initialize output values to 0 so can process components separately */
jzero_far((void FAR *) output_data[row],
(size_t) (width * SIZEOF(JSAMPLE)));
for (ci = 0; ci < nc; ci++) {
if (on_odd_row) {
/* work right to left in this row */
dir = -1;
input_ptr = input_buffer[ci] + (width-1);
output_ptr = output_data[row] + (width-1);
thisrowerr = oddrowerrs[ci] + 1;
nextrowerr = evenrowerrs[ci] + width;
} else {
/* work left to right in this row */
dir = 1;
input_ptr = input_buffer[ci];
output_ptr = output_data[row];
thisrowerr = evenrowerrs[ci] + 1;
nextrowerr = oddrowerrs[ci] + width;
}
on_odd_row = FALSE;
} else {
/* work left to right in this row */
thisrowerr = evenrowerrs + nc;
nextrowerr = oddrowerrs + nc;
for (ci = 0; ci < nc; ci++) /* need only initialize this one entry */
nextrowerr[ci] = 0;
for (col = 0; col < width; col++) {
/* select the output pixel value */
pixcode = 0;
for (ci = 0; ci < nc; ci++) {
/* compute pixel value + accumulated error */
val = (((FSERROR) GETJSAMPLE(input_data[ci][row][col])) << 4)
+ thisrowerr[ci];
if (val <= 0) val = 0; /* must watch for range overflow! */
else {
val += 8; /* divide by 16 with proper rounding */
val >>= 4;
if (val > MAXJSAMPLE) val = MAXJSAMPLE;
}
thisrowerr[ci] = val; /* save for error propagation */
pixcode += GETJSAMPLE(colorindex[ci][val]);
colorindex_ci = colorindex[ci];
colormap_ci = colormap[ci];
*nextrowerr = 0; /* need only initialize this one entry */
for (col_counter = width; col_counter > 0; col_counter--) {
/* Compute pixel value + accumulated error for this component */
val = (((FSERROR) GETJSAMPLE(*input_ptr)) << 4) + *thisrowerr;
if (val < 0) val = 0; /* must watch for range overflow! */
else {
val += 8; /* divide by 16 with proper rounding */
val >>= 4;
if (val > MAXJSAMPLE) val = MAXJSAMPLE;
}
output_data[row][col] = (JSAMPLE) pixcode;
/* propagate error to adjacent pixels */
for (ci = 0; ci < nc; ci++) {
val = thisrowerr[ci] - (FSERROR) GETJSAMPLE(colormap[ci][pixcode]);
thisrowerr[ci+nc] += val * 7;
nextrowerr[ci-nc] += val * 3;
nextrowerr[ci ] += val * 5;
nextrowerr[ci+nc] = val; /* not +=, since not initialized yet */
}
thisrowerr += nc; /* advance error ptrs to next pixel entry */
nextrowerr += nc;
/* Select output value, accumulate into output code for this pixel */
pixcode = GETJSAMPLE(*output_ptr);
pixcode += GETJSAMPLE(colorindex_ci[val]);
*output_ptr = (JSAMPLE) pixcode;
/* Compute actual representation error at this pixel */
/* Note: we can do this even though we don't yet have the final */
/* value of pixcode, because the colormap is orthogonal. */
val -= (FSERROR) GETJSAMPLE(colormap_ci[pixcode]);
/* Propagate error to (same component of) adjacent pixels */
/* Remember that nextrowerr entries are in reverse order! */
two_val = val * 2;
nextrowerr[-1] = val; /* not +=, since not initialized yet */
val += two_val; /* form error * 3 */
nextrowerr[ 1] += val;
val += two_val; /* form error * 5 */
nextrowerr[ 0] += val;
val += two_val; /* form error * 7 */
thisrowerr[ 1] += val;
input_ptr += dir; /* advance input ptr to next column */
output_ptr += dir; /* advance output ptr to next column */
thisrowerr++; /* cur-row error ptr advances to right */
nextrowerr--; /* next-row error ptr advances to left */
}
on_odd_row = TRUE;
}
on_odd_row = (on_odd_row ? FALSE : TRUE);
}
}
@ -325,15 +533,9 @@ color_quantize_dither (decompress_info_ptr cinfo, int num_rows,
METHODDEF void
color_quant_term (decompress_info_ptr cinfo)
{
/* We can't free the colormap until now, since output module may use it! */
(*cinfo->emethods->free_small_sarray)
(colormap, (long) cinfo->color_out_comps);
(*cinfo->emethods->free_small_sarray)
(colorindex, (long) cinfo->color_out_comps);
if (cinfo->use_dithering) {
(*cinfo->emethods->free_medium) ((void FAR *) evenrowerrs);
(*cinfo->emethods->free_medium) ((void FAR *) oddrowerrs);
}
/* no work (we let free_all release the workspace) */
/* Note that we *mustn't* free the colormap before free_all, */
/* since output module may use it! */
}
@ -344,7 +546,7 @@ color_quant_term (decompress_info_ptr cinfo)
METHODDEF void
color_quant_prescan (decompress_info_ptr cinfo, int num_rows,
JSAMPIMAGE image_data)
JSAMPIMAGE image_data, JSAMPARRAY workspace)
{
ERREXIT(cinfo->emethods, "Should not get here!");
}

1091
jquant2.c

File diff suppressed because it is too large Load Diff

View File

@ -1,7 +1,7 @@
/*
* jrdgif.c
*
* Copyright (C) 1991, Thomas G. Lane.
* Copyright (C) 1991, 1992, 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.
*
@ -62,7 +62,7 @@ static JSAMPARRAY colormap; /* the colormap to use */
#define INTERLACE 0x40 /* mask for bit signifying interlaced image */
#define COLORMAPFLAG 0x80 /* mask for bit signifying colormap presence */
#define ReadOK(file,buffer,len) (FREAD(file,buffer,len) == ((size_t) (len)))
#define ReadOK(file,buffer,len) (JFREAD(file,buffer,len) == ((size_t) (len)))
/* Static vars for GetCode and LZWReadByte */
@ -459,6 +459,7 @@ input_init (compress_info_ptr cinfo)
interlaced_image = (*cinfo->emethods->request_big_sarray)
((long) width, (long) height, 1L);
cinfo->methods->get_input_row = load_interlaced_image;
cinfo->total_passes++; /* count file reading as separate pass */
}
/* Return info about the image. */
@ -466,7 +467,7 @@ input_init (compress_info_ptr cinfo)
cinfo->in_color_space = CS_RGB;
cinfo->image_width = width;
cinfo->image_height = height;
cinfo->data_precision = 8;
cinfo->data_precision = 8; /* always, even if 12-bit JSAMPLEs */
}
@ -513,6 +514,7 @@ load_interlaced_image (compress_info_ptr cinfo, JSAMPARRAY pixel_row)
/* Read the interlaced image into the big array we've created. */
for (row = 0; row < cinfo->image_height; row++) {
(*cinfo->methods->progress_monitor) (cinfo, row, cinfo->image_height);
image_ptr = (*cinfo->emethods->access_big_sarray)
(interlaced_image, row, TRUE);
sptr = image_ptr[0];
@ -522,6 +524,7 @@ load_interlaced_image (compress_info_ptr cinfo, JSAMPARRAY pixel_row)
*sptr++ = (JSAMPLE) c;
}
}
cinfo->completed_passes++;
/* Replace method pointer so subsequent calls don't come here. */
cinfo->methods->get_input_row = get_interlaced_row;
@ -590,14 +593,7 @@ get_interlaced_row (compress_info_ptr cinfo, JSAMPARRAY pixel_row)
METHODDEF void
input_term (compress_info_ptr cinfo)
{
if (is_interlaced) {
(*cinfo->emethods->free_big_sarray) (interlaced_image);
}
(*cinfo->emethods->free_small_sarray)
(colormap, (long) NUMCOLORS);
(*cinfo->emethods->free_medium) ((void FAR *) symbol_head);
(*cinfo->emethods->free_medium) ((void FAR *) symbol_tail);
(*cinfo->emethods->free_medium) ((void FAR *) symbol_stack);
/* no work (we let free_all release the workspace) */
}

View File

@ -1,23 +1,25 @@
/*
* jrdjfif.c
*
* Copyright (C) 1991, Thomas G. Lane.
* Copyright (C) 1991, 1992, 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 routines to decode standard JPEG file headers/markers.
* This will handle baseline and JFIF-convention JPEG files.
* This code will handle "raw JPEG" and JFIF-convention JPEG files.
*
* You can also use this module to decode a raw-JPEG or JFIF-standard data
* stream that is embedded within a larger file. To do that, you must
* position the file to the JPEG SOI marker (0xFF/0xD8) that begins the
* data sequence to be decoded. If nothing better is possible, you can scan
* the file until you see the SOI marker, then use JUNGETC to push it back.
*
* This module relies on the JGETC macro and the read_jpeg_data method (which
* is provided by the user interface) to read from the JPEG data stream.
* Therefore, this module is NOT dependent on any particular assumption about
* the data source. This fact does not carry over to more complex JPEG file
* formats such as JPEG-in-TIFF; those format control modules may well need to
* assume stdio input.
*
* read_file_header assumes that reading begins at the JPEG SOI marker
* (although it will skip non-FF bytes looking for a JPEG marker).
* The user interface must position the data stream appropriately.
* Therefore, this module is not dependent on any particular assumption about
* the data source; it need not be a stdio stream at all. (This fact does
* NOT carry over to more complex JPEG file formats such as JPEG-in-TIFF;
* those format control modules may well need to assume stdio input.)
*
* These routines are invoked via the methods read_file_header,
* read_scan_header, read_jpeg_data, read_scan_trailer, and read_file_trailer.
@ -100,9 +102,9 @@ read_jpeg_data (decompress_info_ptr cinfo)
{
cinfo->next_input_byte = cinfo->input_buffer + MIN_UNGET;
cinfo->bytes_in_buffer = (int) FREAD(cinfo->input_file,
cinfo->next_input_byte,
JPEG_BUF_SIZE);
cinfo->bytes_in_buffer = (int) JFREAD(cinfo->input_file,
cinfo->next_input_byte,
JPEG_BUF_SIZE);
if (cinfo->bytes_in_buffer <= 0)
ERREXIT(cinfo->emethods, "Unexpected EOF in JPEG file");
@ -591,11 +593,15 @@ read_file_header (decompress_info_ptr cinfo)
{
int c;
/* Expect an SOI marker first */
if (next_marker(cinfo) == M_SOI)
get_soi(cinfo);
else
ERREXIT(cinfo->emethods, "File does not start with JPEG SOI marker");
/* Demand an SOI marker at the start of the file --- otherwise it's
* probably not a JPEG file at all. If the user interface wants to support
* nonstandard headers in front of the SOI, it must skip over them itself
* before calling jpeg_decompress().
*/
if (JGETC(cinfo) != 0xFF || JGETC(cinfo) != M_SOI)
ERREXIT(cinfo->emethods, "Not a JPEG file");
get_soi(cinfo); /* OK, process SOI */
/* Process markers until SOF */
c = process_tables(cinfo);

View File

@ -1,7 +1,7 @@
/*
* jrdppm.c
*
* Copyright (C) 1991, Thomas G. Lane.
* Copyright (C) 1991, 1992, 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.
*
@ -301,8 +301,7 @@ input_init (compress_info_ptr cinfo)
METHODDEF void
input_term (compress_info_ptr cinfo)
{
if (rescale != NULL)
(*cinfo->emethods->free_small) ((void *) rescale);
/* no work (we let free_all release the workspace) */
}

View File

@ -1,7 +1,7 @@
/*
* jrdrle.c
*
* Copyright (C) 1991, Thomas G. Lane.
* Copyright (C) 1991, 1992, 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.
*
@ -157,6 +157,8 @@ input_init (compress_info_ptr cinfo)
cinfo->input_components = 3;
break;
}
cinfo->total_passes++; /* count file reading as separate pass */
}
@ -282,6 +284,7 @@ load_image (compress_info_ptr cinfo, JSAMPARRAY pixel_row)
case GRAYSCALE:
case PSEUDOCOLOR:
for (row = 0; row < cinfo->image_height; row++) {
(*cinfo->methods->progress_monitor) (cinfo, row, cinfo->image_height);
/*
* Read a row of the image directly into our big array.
* Too bad this doesn't seem to return any indication of errors :-(.
@ -294,6 +297,7 @@ load_image (compress_info_ptr cinfo, JSAMPARRAY pixel_row)
case TRUECOLOR:
case DIRECTCOLOR:
for (row = 0; row < cinfo->image_height; row++) {
(*cinfo->methods->progress_monitor) (cinfo, row, cinfo->image_height);
/*
* Read a row of the image directly into our big arrays.
* Too bad this doesn't seem to return any indication of errors :-(.
@ -308,6 +312,7 @@ load_image (compress_info_ptr cinfo, JSAMPARRAY pixel_row)
}
break;
}
cinfo->completed_passes++;
/* Set up to call proper row-extraction routine in future */
switch (visual) {
@ -338,18 +343,7 @@ load_image (compress_info_ptr cinfo, JSAMPARRAY pixel_row)
METHODDEF void
input_term (compress_info_ptr cinfo)
{
switch (visual) {
case GRAYSCALE:
case PSEUDOCOLOR:
(*cinfo->emethods->free_big_sarray) (image);
break;
case TRUECOLOR:
case DIRECTCOLOR:
(*cinfo->emethods->free_big_sarray) (red_channel);
(*cinfo->emethods->free_big_sarray) (green_channel);
(*cinfo->emethods->free_big_sarray) (blue_channel);
break;
}
/* no work (we let free_all release the workspace) */
}

View File

@ -1,7 +1,7 @@
/*
* jrdtarga.c
*
* Copyright (C) 1991, Thomas G. Lane.
* Copyright (C) 1991, 1992, 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.
*
@ -41,7 +41,7 @@ typedef char U_CHAR;
#endif /* HAVE_UNSIGNED_CHAR */
#define ReadOK(file,buffer,len) (FREAD(file,buffer,len) == ((size_t) (len)))
#define ReadOK(file,buffer,len) (JFREAD(file,buffer,len) == ((size_t) (len)))
static JSAMPARRAY colormap; /* Targa colormap (converted to my format) */
@ -242,34 +242,14 @@ get_24bit_row (compress_info_ptr cinfo, JSAMPARRAY pixel_row)
}
}
METHODDEF void
get_32bit_row (compress_info_ptr cinfo, JSAMPARRAY pixel_row)
/* This version is for reading 32-bit pixels */
/* Attribute bits are ignored for now */
{
register JSAMPROW ptr0, ptr1, ptr2;
register long col;
/* NOTE: there seems to be considerable confusion over whether the order
* of the bytes in a 32-bit Targa file is A,B,G,R or B,G,R,A.
* On Lee Crocker's authority, we think the attribute byte comes first.
* Make ATTR_BYTE_FIRST be 0 if you have files in which it comes last.
/*
* Targa also defines a 32-bit pixel format with order B,G,R,A.
* We presently ignore the attribute byte, so the code for reading
* these pixels is identical to the 24-bit routine above.
* This works because the actual pixel length is only known to read_pixel.
*/
#ifndef ATTR_BYTE_FIRST /* so you can say -DATTR_BYTE_FIRST=0 in Makefile */
#define ATTR_BYTE_FIRST 1 /* must be 0 or 1 */
#endif
ptr0 = pixel_row[0];
ptr1 = pixel_row[1];
ptr2 = pixel_row[2];
for (col = cinfo->image_width; col > 0; col--) {
(*read_pixel) (cinfo); /* Load next pixel into tga_pixel */
/* convert ABGR (or BGRA) to RGB order */
*ptr0++ = (JSAMPLE) UCH(tga_pixel[2+ATTR_BYTE_FIRST]);
*ptr1++ = (JSAMPLE) UCH(tga_pixel[1+ATTR_BYTE_FIRST]);
*ptr2++ = (JSAMPLE) UCH(tga_pixel[0+ATTR_BYTE_FIRST]);
}
}
#define get_32bit_row get_24bit_row
/*
@ -314,10 +294,13 @@ preload_image (compress_info_ptr cinfo, JSAMPARRAY pixel_row)
/* Read the data into a virtual array in input-file row order */
for (row = 0; row < cinfo->image_height; row++) {
(*cinfo->methods->progress_monitor) (cinfo, row, cinfo->image_height);
image_ptr = (*cinfo->emethods->access_big_sarray)
(whole_image, row * cinfo->input_components, TRUE);
(*get_pixel_row) (cinfo, image_ptr);
}
cinfo->completed_passes++;
/* Set up to read from the virtual array in unscrambled order */
cinfo->methods->get_input_row = get_memory_row;
current_row = 0;
@ -421,6 +404,7 @@ input_init (compress_info_ptr cinfo)
((long) width, (long) height * components,
(long) components);
cinfo->methods->get_input_row = preload_image;
cinfo->total_passes++; /* count file reading as separate pass */
} else {
whole_image = NULL;
cinfo->methods->get_input_row = get_pixel_row;
@ -457,10 +441,7 @@ input_init (compress_info_ptr cinfo)
METHODDEF void
input_term (compress_info_ptr cinfo)
{
if (whole_image != NULL)
(*cinfo->emethods->free_big_sarray) (whole_image);
if (colormap != NULL)
(*cinfo->emethods->free_small_sarray) (colormap, 3L);
/* no work (we let free_all release the workspace) */
}

186
jrevdct.c
View File

@ -1,7 +1,7 @@
/*
* jrevdct.c
*
* Copyright (C) 1991, Thomas G. Lane.
* Copyright (C) 1991, 1992, 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.
*
@ -15,25 +15,12 @@
#include "jinclude.h"
/* We assume that right shift corresponds to signed division by 2 with
* rounding towards minus infinity. This is correct for typical "arithmetic
* shift" instructions that shift in copies of the sign bit. But some
* C compilers implement >> with an unsigned shift. For these machines you
* must define RIGHT_SHIFT_IS_UNSIGNED.
* RIGHT_SHIFT provides a signed right shift of an INT32 quantity.
* It is only applied with constant shift counts.
/*
* This routine is specialized to the case DCTSIZE = 8.
*/
#ifdef RIGHT_SHIFT_IS_UNSIGNED
#define SHIFT_TEMPS INT32 shift_temp;
#define RIGHT_SHIFT(x,shft) \
((shift_temp = (x)) < 0 ? \
(shift_temp >> (shft)) | ((~0) << (32-(shft))) : \
(shift_temp >> (shft)))
#else
#define SHIFT_TEMPS
#define RIGHT_SHIFT(x,shft) ((x) >> (shft))
#if DCTSIZE != 8
Sorry, this code only copes with 8x8 DCTs. /* deliberate syntax err */
#endif
@ -137,78 +124,6 @@
#define OCOS_5_16 OSIN_3_16
/*
* Perform a 1-dimensional inverse DCT.
* Note that this code is specialized to the case DCTSIZE = 8.
*/
INLINE
LOCAL void
fast_idct_8 (DCTELEM *in, int stride)
{
/* many tmps have nonoverlapping lifetime -- flashy register colourers
* should be able to do this lot very well
*/
INT32 in0, in1, in2, in3, in4, in5, in6, in7;
INT32 tmp10, tmp11, tmp12, tmp13;
INT32 tmp20, tmp21, tmp22, tmp23;
INT32 tmp30, tmp31;
INT32 tmp40, tmp41, tmp42, tmp43;
INT32 tmp50, tmp51, tmp52, tmp53;
SHIFT_TEMPS
in0 = in[ 0];
in1 = in[stride ];
in2 = in[stride*2];
in3 = in[stride*3];
in4 = in[stride*4];
in5 = in[stride*5];
in6 = in[stride*6];
in7 = in[stride*7];
/* These values are scaled by DCT_SCALE */
tmp10 = (in0 + in4) * COS_1_4;
tmp11 = (in0 - in4) * COS_1_4;
tmp12 = in2 * SIN_1_8 - in6 * COS_1_8;
tmp13 = in6 * SIN_1_8 + in2 * COS_1_8;
tmp20 = tmp10 + tmp13;
tmp21 = tmp11 + tmp12;
tmp22 = tmp11 - tmp12;
tmp23 = tmp10 - tmp13;
/* These values are scaled by OVERSCALE */
tmp30 = UNFIXO((in3 + in5) * COS_1_4);
tmp31 = UNFIXO((in3 - in5) * COS_1_4);
OVERSHIFT(in1);
OVERSHIFT(in7);
tmp40 = in1 + tmp30;
tmp41 = in7 + tmp31;
tmp42 = in1 - tmp30;
tmp43 = in7 - tmp31;
/* And these are scaled by DCT_SCALE */
tmp50 = tmp40 * OCOS_1_16 + tmp41 * OSIN_1_16;
tmp51 = tmp40 * OSIN_1_16 - tmp41 * OCOS_1_16;
tmp52 = tmp42 * OCOS_5_16 + tmp43 * OSIN_5_16;
tmp53 = tmp42 * OSIN_5_16 - tmp43 * OCOS_5_16;
in[ 0] = (DCTELEM) UNFIXH(tmp20 + tmp50);
in[stride ] = (DCTELEM) UNFIXH(tmp21 + tmp53);
in[stride*2] = (DCTELEM) UNFIXH(tmp22 + tmp52);
in[stride*3] = (DCTELEM) UNFIXH(tmp23 + tmp51);
in[stride*4] = (DCTELEM) UNFIXH(tmp23 - tmp51);
in[stride*5] = (DCTELEM) UNFIXH(tmp22 - tmp52);
in[stride*6] = (DCTELEM) UNFIXH(tmp21 - tmp53);
in[stride*7] = (DCTELEM) UNFIXH(tmp20 - tmp50);
}
/*
* Perform the inverse DCT on one block of coefficients.
*
@ -219,11 +134,88 @@ fast_idct_8 (DCTELEM *in, int stride)
GLOBAL void
j_rev_dct (DCTBLOCK data)
{
int i;
for (i = 0; i < DCTSIZE; i++)
fast_idct_8(data+i*DCTSIZE, 1);
for (i = 0; i < DCTSIZE; i++)
fast_idct_8(data+i, DCTSIZE);
int pass, rowctr;
register DCTELEM *inptr, *outptr;
DCTBLOCK workspace;
/* Each iteration of the inner loop performs one 8-point 1-D IDCT.
* It reads from a *row* of the input matrix and stores into a *column*
* of the output matrix. In the first pass, we read from the data[] array
* and store into the local workspace[]. In the second pass, we read from
* the workspace[] array and store into data[], thus performing the
* equivalent of a columnar IDCT pass with no variable array indexing.
*/
inptr = data; /* initialize pointers for first pass */
outptr = workspace;
for (pass = 1; pass >= 0; pass--) {
for (rowctr = DCTSIZE-1; rowctr >= 0; rowctr--) {
/* many tmps have nonoverlapping lifetime -- flashy register colourers
* should be able to do this lot very well
*/
INT32 in0, in1, in2, in3, in4, in5, in6, in7;
INT32 tmp10, tmp11, tmp12, tmp13;
INT32 tmp20, tmp21, tmp22, tmp23;
INT32 tmp30, tmp31;
INT32 tmp40, tmp41, tmp42, tmp43;
INT32 tmp50, tmp51, tmp52, tmp53;
SHIFT_TEMPS
in0 = inptr[0];
in1 = inptr[1];
in2 = inptr[2];
in3 = inptr[3];
in4 = inptr[4];
in5 = inptr[5];
in6 = inptr[6];
in7 = inptr[7];
/* These values are scaled by DCT_SCALE */
tmp10 = (in0 + in4) * COS_1_4;
tmp11 = (in0 - in4) * COS_1_4;
tmp12 = in2 * SIN_1_8 - in6 * COS_1_8;
tmp13 = in6 * SIN_1_8 + in2 * COS_1_8;
tmp20 = tmp10 + tmp13;
tmp21 = tmp11 + tmp12;
tmp22 = tmp11 - tmp12;
tmp23 = tmp10 - tmp13;
/* These values are scaled by OVERSCALE */
tmp30 = UNFIXO((in3 + in5) * COS_1_4);
tmp31 = UNFIXO((in3 - in5) * COS_1_4);
OVERSHIFT(in1);
OVERSHIFT(in7);
tmp40 = in1 + tmp30;
tmp41 = in7 + tmp31;
tmp42 = in1 - tmp30;
tmp43 = in7 - tmp31;
/* And these are scaled by DCT_SCALE */
tmp50 = tmp40 * OCOS_1_16 + tmp41 * OSIN_1_16;
tmp51 = tmp40 * OSIN_1_16 - tmp41 * OCOS_1_16;
tmp52 = tmp42 * OCOS_5_16 + tmp43 * OSIN_5_16;
tmp53 = tmp42 * OSIN_5_16 - tmp43 * OCOS_5_16;
outptr[ 0] = (DCTELEM) UNFIXH(tmp20 + tmp50);
outptr[DCTSIZE ] = (DCTELEM) UNFIXH(tmp21 + tmp53);
outptr[DCTSIZE*2] = (DCTELEM) UNFIXH(tmp22 + tmp52);
outptr[DCTSIZE*3] = (DCTELEM) UNFIXH(tmp23 + tmp51);
outptr[DCTSIZE*4] = (DCTELEM) UNFIXH(tmp23 - tmp51);
outptr[DCTSIZE*5] = (DCTELEM) UNFIXH(tmp22 - tmp52);
outptr[DCTSIZE*6] = (DCTELEM) UNFIXH(tmp21 - tmp53);
outptr[DCTSIZE*7] = (DCTELEM) UNFIXH(tmp20 - tmp50);
inptr += DCTSIZE; /* advance inptr to next row */
outptr++; /* advance outptr to next column */
}
/* end of pass; in case it was pass 1, set up for pass 2 */
inptr = workspace;
outptr = data;
}
}

View File

@ -1,7 +1,7 @@
/*
* jutils.c
*
* Copyright (C) 1991, Thomas G. Lane.
* Copyright (C) 1991, 1992, 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.
*
@ -40,7 +40,7 @@ jcopy_sample_rows (JSAMPARRAY input_array, int source_row,
#ifdef NEED_FAR_POINTERS
register long count;
#else
register size_t count = num_cols * SIZEOF(JSAMPLE);
register size_t count = (size_t) (num_cols * SIZEOF(JSAMPLE));
#endif
register int row;
@ -69,14 +69,12 @@ jcopy_block_row (JBLOCKROW input_row, JBLOCKROW output_row, long num_blocks)
*/
#ifdef NEED_FAR_POINTERS
register JCOEFPTR inptr, outptr;
register int i;
register long count;
for (count = num_blocks; count > 0; count--) {
inptr = *input_row++;
outptr = *output_row++;
for (i = DCTSIZE2; i > 0; i--)
*outptr++ = *inptr++;
inptr = (JCOEFPTR) input_row;
outptr = (JCOEFPTR) output_row;
for (count = num_blocks * DCTSIZE2; count > 0; count--) {
*outptr++ = *inptr++;
}
#else
memcpy((void *) output_row, (void *) input_row,

View File

@ -1,7 +1,7 @@
/*
* jversion.h
*
* Copyright (C) 1991, Thomas G. Lane.
* Copyright (C) 1991, 1992, 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.
*
@ -9,6 +9,6 @@
*/
#define JVERSION "2 13-Dec-91"
#define JVERSION "3 17-Mar-92"
#define JCOPYRIGHT "Copyright (C) 1991, Thomas G. Lane"
#define JCOPYRIGHT "Copyright (C) 1992, Thomas G. Lane"

View File

@ -1,614 +0,0 @@
/*
* jvirtmem.c
*
* Copyright (C) 1991, 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 provides the system-dependent memory allocation routines
* for the case where we can rely on virtual memory to handle large arrays.
*
* This includes some MS-DOS code just for trial purposes; "big" arrays will
* have to be handled with temp files on MS-DOS, so a real implementation of
* a DOS memory manager will probably be a separate file. (See additional
* comments about big arrays, below.)
*
* NB: allocation routines never return NULL.
* They should exit to error_exit if unsuccessful.
*/
#define AM_MEMORY_MANAGER /* we define big_Xarray_control structs */
#include "jinclude.h"
#ifdef INCLUDES_ARE_ANSI
#include <stdlib.h> /* to declare malloc(), free() */
#else
extern void * malloc PP((size_t size));
extern void free PP((void *ptr));
#endif
/* Insert system-specific definitions of far_malloc, far_free here. */
#ifndef NEED_FAR_POINTERS /* Generic for non-braindamaged CPUs */
#define far_malloc(x) malloc(x)
#define far_free(x) free(x)
#else /* NEED_FAR_POINTERS */
#ifdef __TURBOC__
/* These definitions work for Turbo C */
#include <alloc.h> /* need farmalloc(), farfree() */
#define far_malloc(x) farmalloc(x)
#define far_free(x) farfree(x)
#else
#ifdef MSDOS
/* These definitions work for Microsoft C and compatible compilers */
#include <malloc.h> /* need _fmalloc(), _ffree() */
#define far_malloc(x) _fmalloc(x)
#define far_free(x) _ffree(x)
#endif
#endif
#endif /* NEED_FAR_POINTERS */
/*
* When allocating 2-D arrays we can either ask malloc() for each row
* individually, or grab the whole space in one chunk. The latter is
* a lot faster on large arrays, but fails if malloc can't handle big
* requests, as is typically true on MS-DOS.
* We assume here that big malloc requests are safe whenever
* NEED_FAR_POINTERS is not defined, but you can change this if you are
* on a weird machine.
*/
#ifndef NEED_FAR_POINTERS
#define BIG_MALLOCS_OK /* safe to ask far_malloc for > 64Kb */
#endif
/*
* Some important notes:
* The array alloc/dealloc routines are not merely a convenience;
* on 80x86 machines the bottom-level pointers in an array are FAR
* and thus may not be allocatable by alloc_small.
*
* Also, it's not a good idea to try to merge the sarray and barray
* routines, even though they are textually almost the same, because
* samples are usually stored as bytes while coefficients are shorts.
* Thus, in machines where byte pointers have a different representation
* from word pointers, the resulting machine code could not be the same.
*/
static external_methods_ptr methods; /* saved for access to error_exit */
#ifdef MEM_STATS /* optional extra stuff for statistics */
#define MALLOC_OVERHEAD (SIZEOF(char *)) /* assumed overhead per request */
#define MALLOC_FAR_OVERHEAD (SIZEOF(char FAR *)) /* for "far" storage */
static long total_num_small = 0; /* total # of small objects alloced */
static long total_bytes_small = 0; /* total bytes requested */
static long cur_num_small = 0; /* # currently alloced */
static long max_num_small = 0; /* max simultaneously alloced */
#ifdef NEED_FAR_POINTERS
static long total_num_medium = 0; /* total # of medium objects alloced */
static long total_bytes_medium = 0; /* total bytes requested */
static long cur_num_medium = 0; /* # currently alloced */
static long max_num_medium = 0; /* max simultaneously alloced */
#endif
static long total_num_sarray = 0; /* total # of sarray objects alloced */
static long total_bytes_sarray = 0; /* total bytes requested */
static long cur_num_sarray = 0; /* # currently alloced */
static long max_num_sarray = 0; /* max simultaneously alloced */
static long total_num_barray = 0; /* total # of barray objects alloced */
static long total_bytes_barray = 0; /* total bytes requested */
static long cur_num_barray = 0; /* # currently alloced */
static long max_num_barray = 0; /* max simultaneously alloced */
GLOBAL void
j_mem_stats (void)
{
/* since this is only a debugging stub, we can cheat a little on the
* trace message mechanism... helps 'cuz trace can't handle longs.
*/
fprintf(stderr, "total_num_small = %ld\n", total_num_small);
fprintf(stderr, "total_bytes_small = %ld\n", total_bytes_small);
if (cur_num_small)
fprintf(stderr, "CUR_NUM_SMALL = %ld\n", cur_num_small);
fprintf(stderr, "max_num_small = %ld\n", max_num_small);
#ifdef NEED_FAR_POINTERS
fprintf(stderr, "total_num_medium = %ld\n", total_num_medium);
fprintf(stderr, "total_bytes_medium = %ld\n", total_bytes_medium);
if (cur_num_medium)
fprintf(stderr, "CUR_NUM_MEDIUM = %ld\n", cur_num_medium);
fprintf(stderr, "max_num_medium = %ld\n", max_num_medium);
#endif
fprintf(stderr, "total_num_sarray = %ld\n", total_num_sarray);
fprintf(stderr, "total_bytes_sarray = %ld\n", total_bytes_sarray);
if (cur_num_sarray)
fprintf(stderr, "CUR_NUM_SARRAY = %ld\n", cur_num_sarray);
fprintf(stderr, "max_num_sarray = %ld\n", max_num_sarray);
fprintf(stderr, "total_num_barray = %ld\n", total_num_barray);
fprintf(stderr, "total_bytes_barray = %ld\n", total_bytes_barray);
if (cur_num_barray)
fprintf(stderr, "CUR_NUM_BARRAY = %ld\n", cur_num_barray);
fprintf(stderr, "max_num_barray = %ld\n", max_num_barray);
}
#endif /* MEM_STATS */
LOCAL void
out_of_memory (int which)
/* Report an out-of-memory error and stop execution */
/* If we compiled MEM_STATS support, report alloc requests before dying */
{
#ifdef MEM_STATS
j_mem_stats();
#endif
ERREXIT1(methods, "Insufficient memory (case %d)", which);
}
METHODDEF void *
alloc_small (size_t sizeofobject)
/* Allocate a "small" (all-in-memory) object */
{
void * result;
#ifdef MEM_STATS
total_num_small++;
total_bytes_small += sizeofobject + MALLOC_OVERHEAD;
cur_num_small++;
if (cur_num_small > max_num_small) max_num_small = cur_num_small;
#endif
result = malloc(sizeofobject);
if (result == NULL)
out_of_memory(1);
return result;
}
METHODDEF void
free_small (void *ptr)
/* Free a "small" (all-in-memory) object */
{
free(ptr);
#ifdef MEM_STATS
cur_num_small--;
#endif
}
#ifdef NEED_FAR_POINTERS
METHODDEF void FAR *
alloc_medium (size_t sizeofobject)
/* Allocate a "medium" (all in memory, but in far heap) object */
{
void FAR * result;
#ifdef MEM_STATS
total_num_medium++;
total_bytes_medium += sizeofobject + MALLOC_FAR_OVERHEAD;
cur_num_medium++;
if (cur_num_medium > max_num_medium) max_num_medium = cur_num_medium;
#endif
result = far_malloc(sizeofobject);
if (result == NULL)
out_of_memory(2);
return result;
}
METHODDEF void
free_medium (void FAR *ptr)
/* Free a "medium" (all in memory, but in far heap) object */
{
far_free(ptr);
#ifdef MEM_STATS
cur_num_medium--;
#endif
}
#endif /* NEED_FAR_POINTERS */
METHODDEF JSAMPARRAY
alloc_small_sarray (long samplesperrow, long numrows)
/* Allocate a "small" (all-in-memory) 2-D sample array */
{
JSAMPARRAY result;
#ifdef BIG_MALLOCS_OK
JSAMPROW workspace;
#endif
long i;
#ifdef MEM_STATS
total_num_sarray++;
#ifdef BIG_MALLOCS_OK
total_bytes_sarray += numrows * samplesperrow * SIZEOF(JSAMPLE)
+ MALLOC_FAR_OVERHEAD;
#else
total_bytes_sarray += (samplesperrow * SIZEOF(JSAMPLE) + MALLOC_FAR_OVERHEAD)
* numrows;
#endif
cur_num_sarray++;
if (cur_num_sarray > max_num_sarray) max_num_sarray = cur_num_sarray;
#endif
/* Get space for row pointers; this is always "near" on 80x86 */
result = (JSAMPARRAY) alloc_small((size_t) (numrows * SIZEOF(JSAMPROW)));
/* Get the rows themselves; on 80x86 these are "far" */
#ifdef BIG_MALLOCS_OK
workspace = (JSAMPROW) far_malloc((size_t)
(numrows * samplesperrow * SIZEOF(JSAMPLE)));
if (workspace == NULL)
out_of_memory(3);
for (i = 0; i < numrows; i++) {
result[i] = workspace;
workspace += samplesperrow;
}
#else
for (i = 0; i < numrows; i++) {
result[i] = (JSAMPROW) far_malloc((size_t)
(samplesperrow * SIZEOF(JSAMPLE)));
if (result[i] == NULL)
out_of_memory(3);
}
#endif
return result;
}
METHODDEF void
free_small_sarray (JSAMPARRAY ptr, long numrows)
/* Free a "small" (all-in-memory) 2-D sample array */
{
/* Free the rows themselves; on 80x86 these are "far" */
#ifdef BIG_MALLOCS_OK
far_free((void FAR *) ptr[0]);
#else
long i;
for (i = 0; i < numrows; i++) {
far_free((void FAR *) ptr[i]);
}
#endif
/* Free space for row pointers; this is always "near" on 80x86 */
free_small((void *) ptr);
#ifdef MEM_STATS
cur_num_sarray--;
#endif
}
METHODDEF JBLOCKARRAY
alloc_small_barray (long blocksperrow, long numrows)
/* Allocate a "small" (all-in-memory) 2-D coefficient-block array */
{
JBLOCKARRAY result;
#ifdef BIG_MALLOCS_OK
JBLOCKROW workspace;
#endif
long i;
#ifdef MEM_STATS
total_num_barray++;
#ifdef BIG_MALLOCS_OK
total_bytes_barray += numrows * blocksperrow * SIZEOF(JBLOCK)
+ MALLOC_FAR_OVERHEAD;
#else
total_bytes_barray += (blocksperrow * SIZEOF(JBLOCK) + MALLOC_FAR_OVERHEAD)
* numrows;
#endif
cur_num_barray++;
if (cur_num_barray > max_num_barray) max_num_barray = cur_num_barray;
#endif
/* Get space for row pointers; this is always "near" on 80x86 */
result = (JBLOCKARRAY) alloc_small((size_t) (numrows * SIZEOF(JBLOCKROW)));
/* Get the rows themselves; on 80x86 these are "far" */
#ifdef BIG_MALLOCS_OK
workspace = (JBLOCKROW) far_malloc((size_t)
(numrows * blocksperrow * SIZEOF(JBLOCK)));
if (workspace == NULL)
out_of_memory(4);
for (i = 0; i < numrows; i++) {
result[i] = workspace;
workspace += blocksperrow;
}
#else
for (i = 0; i < numrows; i++) {
result[i] = (JBLOCKROW) far_malloc((size_t)
(blocksperrow * SIZEOF(JBLOCK)));
if (result[i] == NULL)
out_of_memory(4);
}
#endif
return result;
}
METHODDEF void
free_small_barray (JBLOCKARRAY ptr, long numrows)
/* Free a "small" (all-in-memory) 2-D coefficient-block array */
{
/* Free the rows themselves; on 80x86 these are "far" */
#ifdef BIG_MALLOCS_OK
far_free((void FAR *) ptr[0]);
#else
long i;
for (i = 0; i < numrows; i++) {
far_free((void FAR *) ptr[i]);
}
#endif
/* Free space for row pointers; this is always "near" on 80x86 */
free_small((void *) ptr);
#ifdef MEM_STATS
cur_num_barray--;
#endif
}
/*
* About "big" array management:
*
* To allow machines with limited memory to handle large images,
* all processing in the JPEG system is done a few pixel or block rows
* at a time. The above "small" array routines are only used to allocate
* strip buffers (as wide as the image, but just a few rows high).
* In some cases multiple passes must be made over the data. In these
* cases the "big" array routines are used. The array is still accessed
* a strip at a time, but the memory manager must save the whole array
* for repeated accesses. The intended implementation is that there is
* a strip buffer in memory (as high as is possible given the desired memory
* limit), plus a backing file that holds the rest of the array.
*
* The request_big_array routines are told the total size of the image (in case
* it is useful to know the total file size that will be needed). They are
* also given the unit height, which is the number of rows that will be
* accessed at once; the in-memory buffer should usually be made a multiple of
* this height for best efficiency.
*
* The request routines create control blocks (and may open backing files),
* but they don't create the in-memory buffers. This is postponed until
* alloc_big_arrays is called. At that time the total amount of space needed
* is known (approximately, anyway), so free memory can be divided up fairly.
*
* The access_big_array routines are responsible for making a specific strip
* area accessible (after reading or writing the backing file, if necessary).
* Note that the access routines are told whether the caller intends to modify
* the accessed strip; during a read-only pass this saves having to rewrite
* data to disk.
*
* The typical access pattern is one top-to-bottom pass to write the data,
* followed by one or more read-only top-to-bottom passes. However, other
* access patterns may occur while reading. For example, translation of image
* formats that use bottom-to-top scan order will require bottom-to-top read
* passes. The memory manager need not support multiple write passes nor
* funny write orders (meaning that rearranging rows must be handled while
* reading data out of the big array, not while putting it in).
*
* In current usage, the access requests are always for nonoverlapping strips;
* that is, successive access start_row numbers always differ by exactly the
* unitheight. This allows fairly simple buffer dump/reload logic if the
* in-memory buffer is made a multiple of the unitheight. It would be
* possible to keep subsampled rather than fullsize data in the "big" arrays,
* thus reducing temp file size, if we supported overlapping strip access
* (access requests differing by less than the unitheight). At the moment
* I don't believe this is worth the extra complexity.
*
* This particular implementation doesn't use temp files; the whole of a big
* array is allocated in (virtual) memory, and any swapping is done behind the
* scenes by the operating system.
*/
/* The control blocks for virtual arrays.
* These are pretty minimal in this implementation.
* Note: in this implementation we could realize big arrays
* at request time and make alloc_big_arrays a no-op;
* however, doing it separately keeps callers honest.
*/
struct big_sarray_control {
JSAMPARRAY mem_buffer; /* memory buffer (the whole thing, here) */
long rows_in_mem; /* Height of memory buffer */
long samplesperrow; /* Width of memory buffer */
long unitheight; /* # of rows accessed by access_big_sarray() */
big_sarray_ptr next; /* list link for unrealized arrays */
};
struct big_barray_control {
JBLOCKARRAY mem_buffer; /* memory buffer (the whole thing, here) */
long rows_in_mem; /* Height of memory buffer */
long blocksperrow; /* Width of memory buffer */
long unitheight; /* # of rows accessed by access_big_barray() */
big_barray_ptr next; /* list link for unrealized arrays */
};
/* Headers of lists of control blocks for unrealized big arrays */
static big_sarray_ptr unalloced_sarrays;
static big_barray_ptr unalloced_barrays;
METHODDEF big_sarray_ptr
request_big_sarray (long samplesperrow, long numrows, long unitheight)
/* Request a "big" (virtual-memory) 2-D sample array */
{
big_sarray_ptr result;
/* get control block */
result = (big_sarray_ptr) alloc_small(SIZEOF(struct big_sarray_control));
result->mem_buffer = NULL; /* lets access routine spot premature access */
result->rows_in_mem = numrows;
result->samplesperrow = samplesperrow;
result->unitheight = unitheight;
result->next = unalloced_sarrays; /* add to list of unallocated arrays */
unalloced_sarrays = result;
return result;
}
METHODDEF big_barray_ptr
request_big_barray (long blocksperrow, long numrows, long unitheight)
/* Request a "big" (virtual-memory) 2-D coefficient-block array */
{
big_barray_ptr result;
/* get control block */
result = (big_barray_ptr) alloc_small(SIZEOF(struct big_barray_control));
result->mem_buffer = NULL; /* lets access routine spot premature access */
result->rows_in_mem = numrows;
result->blocksperrow = blocksperrow;
result->unitheight = unitheight;
result->next = unalloced_barrays; /* add to list of unallocated arrays */
unalloced_barrays = result;
return result;
}
METHODDEF void
alloc_big_arrays (long extra_small_samples, long extra_small_blocks,
long extra_medium_space)
/* Allocate the in-memory buffers for any unrealized "big" arrays */
/* 'extra' values are upper bounds for total future small-array requests */
/* and far-heap requests */
{
/* In this implementation we just malloc the whole arrays */
/* and expect the system's virtual memory to worry about swapping them */
big_sarray_ptr sptr;
big_barray_ptr bptr;
for (sptr = unalloced_sarrays; sptr != NULL; sptr = sptr->next) {
sptr->mem_buffer = alloc_small_sarray(sptr->samplesperrow,
sptr->rows_in_mem);
}
for (bptr = unalloced_barrays; bptr != NULL; bptr = bptr->next) {
bptr->mem_buffer = alloc_small_barray(bptr->blocksperrow,
bptr->rows_in_mem);
}
unalloced_sarrays = NULL; /* reset for possible future cycles */
unalloced_barrays = NULL;
}
METHODDEF JSAMPARRAY
access_big_sarray (big_sarray_ptr ptr, long start_row, boolean writable)
/* Access the part of a "big" sample array starting at start_row */
/* and extending for ptr->unitheight rows. writable is true if */
/* caller intends to modify the accessed area. */
{
/* debugging check */
if (start_row < 0 || start_row+ptr->unitheight > ptr->rows_in_mem ||
ptr->mem_buffer == NULL)
ERREXIT(methods, "Bogus access_big_sarray request");
return ptr->mem_buffer + start_row;
}
METHODDEF JBLOCKARRAY
access_big_barray (big_barray_ptr ptr, long start_row, boolean writable)
/* Access the part of a "big" coefficient-block array starting at start_row */
/* and extending for ptr->unitheight rows. writable is true if */
/* caller intends to modify the accessed area. */
{
/* debugging check */
if (start_row < 0 || start_row+ptr->unitheight > ptr->rows_in_mem ||
ptr->mem_buffer == NULL)
ERREXIT(methods, "Bogus access_big_barray request");
return ptr->mem_buffer + start_row;
}
METHODDEF void
free_big_sarray (big_sarray_ptr ptr)
/* Free a "big" (virtual-memory) 2-D sample array */
{
free_small_sarray(ptr->mem_buffer, ptr->rows_in_mem);
free_small((void *) ptr); /* free the control block too */
}
METHODDEF void
free_big_barray (big_barray_ptr ptr)
/* Free a "big" (virtual-memory) 2-D coefficient-block array */
{
free_small_barray(ptr->mem_buffer, ptr->rows_in_mem);
free_small((void *) ptr); /* free the control block too */
}
/*
* The method selection routine for virtual memory systems.
* The system-dependent setup routine should call this routine
* to install the necessary method pointers in the supplied struct.
*/
GLOBAL void
jselvirtmem (external_methods_ptr emethods)
{
methods = emethods; /* save struct addr for error exit access */
emethods->alloc_small = alloc_small;
emethods->free_small = free_small;
#ifdef NEED_FAR_POINTERS
emethods->alloc_medium = alloc_medium;
emethods->free_medium = free_medium;
#endif
emethods->alloc_small_sarray = alloc_small_sarray;
emethods->free_small_sarray = free_small_sarray;
emethods->alloc_small_barray = alloc_small_barray;
emethods->free_small_barray = free_small_barray;
emethods->request_big_sarray = request_big_sarray;
emethods->request_big_barray = request_big_barray;
emethods->alloc_big_arrays = alloc_big_arrays;
emethods->access_big_sarray = access_big_sarray;
emethods->access_big_barray = access_big_barray;
emethods->free_big_sarray = free_big_sarray;
emethods->free_big_barray = free_big_barray;
unalloced_sarrays = NULL; /* make sure list headers are empty */
unalloced_barrays = NULL;
}

View File

@ -1,7 +1,7 @@
/*
* jwrgif.c
*
* Copyright (C) 1991, Thomas G. Lane.
* Copyright (C) 1991, 1992, 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.
*
@ -98,7 +98,7 @@ flush_packet (void)
{
if (bytesinpkt > 0) { /* never write zero-length packet */
packetbuf[0] = (char) bytesinpkt++;
if (FWRITE(dcinfo->output_file, packetbuf, bytesinpkt)
if (JFWRITE(dcinfo->output_file, packetbuf, bytesinpkt)
!= (size_t) bytesinpkt)
ERREXIT(dcinfo->emethods, "Output file write error");
bytesinpkt = 0;
@ -106,14 +106,12 @@ flush_packet (void)
}
LOCAL void
char_out (char c)
/* Add a character to current packet; flush to disk if necessary */
{
packetbuf[++bytesinpkt] = c;
if (bytesinpkt >= 255)
flush_packet();
}
#define CHAR_OUT(c) \
{ packetbuf[++bytesinpkt] = (char) (c); \
if (bytesinpkt >= 255) \
flush_packet(); \
}
/* Routine to convert variable-width codes into a byte stream */
@ -127,14 +125,11 @@ output (code_int code)
/* Emit a code of n_bits bits */
/* Uses cur_accum and cur_bits to reblock into 8-bit bytes */
{
if (cur_bits > 0)
cur_accum |= ((INT32) code << cur_bits);
else
cur_accum = code;
cur_accum |= ((INT32) code) << cur_bits;
cur_bits += n_bits;
while (cur_bits >= 8) {
char_out((char) (cur_accum & 0xFF));
CHAR_OUT(cur_accum & 0xFF);
cur_accum >>= 8;
cur_bits -= 8;
}
@ -270,7 +265,7 @@ compress_term (void)
output(EOFCode);
/* Flush the bit-packing buffer */
if (cur_bits > 0) {
char_out((char) (cur_accum & 0xFF));
CHAR_OUT(cur_accum & 0xFF);
}
/* Flush the packet buffer */
flush_packet();
@ -305,27 +300,15 @@ emit_header (int num_colors, JSAMPARRAY colormap)
/* If colormap==NULL, synthesize a gray-scale colormap */
{
int BitsPerPixel, ColorMapSize, InitCodeSize, FlagByte;
int cshift = dcinfo->data_precision - 8;
int i;
if (num_colors > 256)
ERREXIT(dcinfo->emethods, "GIF can only handle 256 colors");
/* Compute bits/pixel and related values */
if (num_colors <= 2)
BitsPerPixel = 1;
else if (num_colors <= 4)
BitsPerPixel = 2;
else if (num_colors <= 8)
BitsPerPixel = 3;
else if (num_colors <= 16)
BitsPerPixel = 4;
else if (num_colors <= 32)
BitsPerPixel = 5;
else if (num_colors <= 64)
BitsPerPixel = 6;
else if (num_colors <= 128)
BitsPerPixel = 7;
else
BitsPerPixel = 8;
BitsPerPixel = 1;
while (num_colors > (1 << BitsPerPixel))
BitsPerPixel++;
ColorMapSize = 1 << BitsPerPixel;
if (BitsPerPixel <= 1)
InitCodeSize = 2;
@ -335,7 +318,7 @@ emit_header (int num_colors, JSAMPARRAY colormap)
* Write the GIF header.
* Note that we generate a plain GIF87 header for maximum compatibility.
*/
(void) FWRITE(dcinfo->output_file, "GIF87a", 6);
(void) JFWRITE(dcinfo->output_file, "GIF87a", 6);
/* Write the Logical Screen Descriptor */
put_word((UINT16) dcinfo->image_width);
put_word((UINT16) dcinfo->image_height);
@ -346,17 +329,19 @@ emit_header (int num_colors, JSAMPARRAY colormap)
putc(0, dcinfo->output_file); /* Background color index */
putc(0, dcinfo->output_file); /* Reserved in GIF87 (aspect ratio in GIF89) */
/* Write the Global Color Map */
/* If the color map is more than 8 bits precision, */
/* we reduce it to 8 bits by shifting */
for (i=0; i < ColorMapSize; i++) {
if (i < num_colors) {
if (colormap != NULL) {
if (dcinfo->out_color_space == CS_RGB) {
/* Normal case: RGB color map */
putc(GETJSAMPLE(colormap[0][i]), dcinfo->output_file);
putc(GETJSAMPLE(colormap[1][i]), dcinfo->output_file);
putc(GETJSAMPLE(colormap[2][i]), dcinfo->output_file);
putc(GETJSAMPLE(colormap[0][i]) >> cshift, dcinfo->output_file);
putc(GETJSAMPLE(colormap[1][i]) >> cshift, dcinfo->output_file);
putc(GETJSAMPLE(colormap[2][i]) >> cshift, dcinfo->output_file);
} else {
/* Grayscale "color map": possible if quantizing grayscale image */
put_3bytes(GETJSAMPLE(colormap[0][i]));
put_3bytes(GETJSAMPLE(colormap[0][i]) >> cshift);
}
} else {
/* Create a gray-scale map of num_colors values, range 0..255 */
@ -463,9 +448,7 @@ output_term (decompress_info_ptr cinfo)
if (ferror(cinfo->output_file))
ERREXIT(cinfo->emethods, "Output file write error");
/* Free space */
(*cinfo->emethods->free_medium) ((void FAR *) hash_code);
(*cinfo->emethods->free_medium) ((void FAR *) hash_prefix);
(*cinfo->emethods->free_medium) ((void FAR *) hash_suffix);
/* no work (we let free_all release the workspace) */
}

View File

@ -1,7 +1,7 @@
/*
* jwrjfif.c
*
* Copyright (C) 1991, Thomas G. Lane.
* Copyright (C) 1991, 1992, 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.
*
@ -36,7 +36,7 @@
/* Write some bytes from a (char *) buffer */
#define WRITE_BYTES(cinfo,dataptr,datacount) \
{ if (FWRITE(cinfo->output_file, dataptr, datacount) \
{ if (JFWRITE(cinfo->output_file, dataptr, datacount) \
!= (size_t) (datacount)) \
ERREXIT(cinfo->emethods, "Output file write error"); }
@ -165,6 +165,9 @@ emit_dht (compress_info_ptr cinfo, int index, boolean is_ac)
} else {
htbl = cinfo->dc_huff_tbl_ptrs[index];
}
if (htbl == NULL)
ERREXIT1(cinfo->emethods, "Huffman table 0x%02x was not defined", index);
if (! htbl->sent_table) {
emit_marker(cinfo, M_DHT);

View File

@ -1,7 +1,7 @@
/*
* jwrppm.c
*
* Copyright (C) 1991, Thomas G. Lane.
* Copyright (C) 1991, 1992, 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.
*
@ -31,9 +31,6 @@
#endif
static JSAMPARRAY color_map; /* saves color map passed by quantizer */
/*
* Write the file header.
*/
@ -104,10 +101,11 @@ put_demapped_rows (decompress_info_ptr cinfo, int num_rows,
JSAMPIMAGE pixel_data)
{
register FILE * outfile = cinfo->output_file;
register JSAMPARRAY color_map = cinfo->colormap;
register JSAMPROW ptr;
register long col;
register long width = cinfo->image_width;
register int row;
long width = cinfo->image_width;
int row;
if (cinfo->out_color_space == CS_GRAYSCALE) {
for (row = 0; row < num_rows; row++) {
@ -141,7 +139,6 @@ put_demapped_rows (decompress_info_ptr cinfo, int num_rows,
METHODDEF void
put_color_map (decompress_info_ptr cinfo, int num_colors, JSAMPARRAY colormap)
{
color_map = colormap; /* save for use in output */
cinfo->methods->put_pixel_rows = put_demapped_rows;
}

View File

@ -1,7 +1,7 @@
/*
* jwrrle.c
*
* Copyright (C) 1991, Thomas G. Lane.
* Copyright (C) 1991, 1992, 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.
*
@ -87,6 +87,8 @@ output_init (decompress_info_ptr cinfo)
output_colormap = NULL; /* No output colormap as yet */
number_colors = 0;
cur_output_row = 0; /* Start filling virtual arrays at row 0 */
cinfo->total_passes++; /* count file writing as separate pass */
}
@ -192,12 +194,15 @@ output_term (decompress_info_ptr cinfo)
* and (b) we are not on a machine where FAR pointers differ from regular.
*/
for (row = cinfo->image_height-1; row >= 0; row--) {
(*cinfo->methods->progress_monitor) (cinfo, cinfo->image_height-row-1,
cinfo->image_height);
for (ci = 0; ci < cinfo->final_out_comps; ci++) {
output_rows[ci] = (rle_pixel *) *((*cinfo->emethods->access_big_sarray)
(channels[ci], row, FALSE));
}
rle_putrow(output_rows, (int) cinfo->image_width, &header);
}
cinfo->completed_passes++;
/* Emit file trailer */
rle_puteof(&header);
@ -206,11 +211,7 @@ output_term (decompress_info_ptr cinfo)
ERREXIT(cinfo->emethods, "Output file write error");
/* Release memory */
for (ci = 0; ci < cinfo->final_out_comps; ci++) {
(*cinfo->emethods->free_big_sarray) (channels[ci]);
}
if (output_colormap != NULL)
(*cinfo->emethods->free_small) ((void *) output_colormap);
/* no work (we let free_all release the workspace) */
}

View File

@ -1,7 +1,7 @@
/*
* jwrtarga.c
*
* Copyright (C) 1991, Thomas G. Lane.
* Copyright (C) 1991, 1992, 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.
*
@ -32,9 +32,6 @@
#endif
static JSAMPARRAY color_map; /* saves color map passed by quantizer */
LOCAL void
write_header (decompress_info_ptr cinfo, int num_colors)
/* Create and write a Targa header */
@ -70,7 +67,7 @@ write_header (decompress_info_ptr cinfo, int num_colors)
}
}
if (FWRITE(cinfo->output_file, targaheader, 18) != (size_t) 18)
if (JFWRITE(cinfo->output_file, targaheader, 18) != (size_t) 18)
ERREXIT(cinfo->emethods, "Could not write Targa header");
}
@ -148,10 +145,11 @@ put_demapped_rows (decompress_info_ptr cinfo, int num_rows,
JSAMPIMAGE pixel_data)
{
register FILE * outfile = cinfo->output_file;
register JSAMPARRAY color_map = cinfo->colormap;
register JSAMPROW ptr;
register long col;
register long width = cinfo->image_width;
register int row;
long width = cinfo->image_width;
int row;
for (row = 0; row < num_rows; row++) {
ptr = pixel_data[0][row];
@ -186,7 +184,6 @@ put_color_map (decompress_info_ptr cinfo, int num_colors, JSAMPARRAY colormap)
putc(GETJSAMPLE(colormap[0][i]), outfile);
}
} else {
color_map = colormap; /* save for use in output */
cinfo->methods->put_pixel_rows = put_demapped_rows;
}
}

View File

@ -1,6 +1,6 @@
L jcmain.mix jcmaster.mix jcdeflts.mix jcarith.mix jccolor.mix jcexpand.mix
L jchuff.mix jcmcu.mix jcpipe.mix jcsample.mix jfwddct.mix jwrjfif.mix
L jrdgif.mix jrdppm.mix jrdrle.mix jrdtarga.mix jutils.mix jvirtmem.mix
L jerror.mix
L jrdgif.mix jrdppm.mix jrdrle.mix jrdtarga.mix jutils.mix jerror.mix
L jmemmgr.mix jmemsys.mix jmemdosa.mix
fa;
b cjpeg,8K,48K,

View File

@ -15,8 +15,10 @@ jrdppm.obj +
jrdrle.obj +
jrdtarga.obj +
jutils.obj +
jvirtmem.obj +
jerror.obj
jerror.obj +
jmemmgr.obj +
jmemsys.obj +
jmemdosa.obj
cjpeg.exe /NOI
nul.map

View File

@ -1,4 +1,4 @@
jcmain.obj jcmaster.obj jcdeflts.obj jcarith.obj jccolor.obj jcexpand.obj
jchuff.obj jcmcu.obj jcpipe.obj jcsample.obj jfwddct.obj jwrjfif.obj
jrdgif.obj jrdppm.obj jrdrle.obj jrdtarga.obj jutils.obj jvirtmem.obj
jerror.obj
jrdgif.obj jrdppm.obj jrdrle.obj jrdtarga.obj jutils.obj jerror.obj
jmemmgr.obj jmemsys.obj jmemdosa.obj

View File

@ -1,6 +1,6 @@
L jdmain.mix jdmaster.mix jddeflts.mix jbsmooth.mix jdarith.mix jdcolor.mix
L jdhuff.mix jdmcu.mix jdpipe.mix jdsample.mix jquant1.mix jquant2.mix
L jrevdct.mix jrdjfif.mix jwrgif.mix jwrppm.mix jwrrle.mix jwrtarga.mix
L jutils.mix jvirtmem.mix jerror.mix
L jutils.mix jerror.mix jmemmgr.mix jmemsys.mix jmemdosa.mix
fa;
b djpeg,8K,48K,

View File

@ -17,8 +17,10 @@ jwrppm.obj +
jwrrle.obj +
jwrtarga.obj +
jutils.obj +
jvirtmem.obj +
jerror.obj
jerror.obj +
jmemmgr.obj +
jmemsys.obj +
jmemdosa.obj
djpeg.exe /NOI
nul.map

View File

@ -1,4 +1,4 @@
jdmain.obj jdmaster.obj jddeflts.obj jbsmooth.obj jdarith.obj jdcolor.obj
jdhuff.obj jdmcu.obj jdpipe.obj jdsample.obj jquant1.obj jquant2.obj
jrevdct.obj jrdjfif.obj jwrgif.obj jwrppm.obj jwrrle.obj jwrtarga.obj
jutils.obj jvirtmem.obj jerror.obj
jutils.obj jerror.obj jmemmgr.obj jmemsys.obj jmemdosa.obj

View File

@ -26,33 +26,42 @@ LDFLAGS=
LDLIBS=
# miscellaneous OS-dependent stuff
LN= $(CC) # linker
RM= rm -f # file deletion command
AR= ar rc # library (.a) file creation command
AR2= ranlib # second step in .a creation (use "touch" if not needed)
# linker
LN= $(CC)
# file deletion command
RM= rm -f
# library (.a) file creation command
AR= ar rc
# second step in .a creation (use "touch" if not needed)
AR2= ranlib
# source files (independently compilable files)
SOURCES= jbsmooth.c jcarith.c jccolor.c jcdeflts.c jcexpand.c jchuff.c \
jcmain.c jcmaster.c jcmcu.c jcpipe.c jcsample.c jdarith.c jdcolor.c \
jddeflts.c jdhuff.c jdmain.c jdmaster.c jdmcu.c jdpipe.c jdsample.c \
jerror.c jquant1.c jquant2.c jfwddct.c jrevdct.c jutils.c \
jvirtmem.c jrdjfif.c jrdgif.c jrdppm.c jrdrle.c jrdtarga.c \
jwrjfif.c jwrgif.c jwrppm.c jwrrle.c jwrtarga.c
jerror.c jquant1.c jquant2.c jfwddct.c jrevdct.c jutils.c jmemmgr.c \
jrdjfif.c jrdgif.c jrdppm.c jrdrle.c jrdtarga.c jwrjfif.c jwrgif.c \
jwrppm.c jwrrle.c jwrtarga.c
# virtual source files (not present in distribution file)
VIRTSOURCES= jmemsys.c
# system-dependent implementations of source files
SYSDEPFILES= jmemansi.c jmemname.c jmemnobs.c jmemdos.c jmemdos.h \
jmemdosa.asm
# files included by source files
INCLUDES= jinclude.h jconfig.h jpegdata.h jversion.h egetopt.c
INCLUDES= jinclude.h jconfig.h jpegdata.h jversion.h jmemsys.h egetopt.c
# documentation, test, and support files
DOCS= README SETUP USAGE CHANGELOG cjpeg.1 djpeg.1 architecture codingrules
MAKEFILES= makefile.ansi makefile.unix makefile.manx makefile.sas \
makefile.mc5 makefile.mc6 makcjpeg.lnk makdjpeg.lnk makefile.tc \
makefile.mc5 makefile.mc6 makcjpeg.lnk makdjpeg.lnk makefile.bcc \
makcjpeg.lst makdjpeg.lst makefile.pwc makcjpeg.cf makdjpeg.cf \
makljpeg.cf
OTHERFILES= ansi2knr.c config.c
TESTFILES= testorig.jpg testimg.ppm testimg.jpg
DISTFILES= $(DOCS) $(MAKEFILES) $(SOURCES) $(INCLUDES) $(OTHERFILES) \
$(TESTFILES)
makljpeg.cf makefile.mms makefile.vms makvms.opt
OTHERFILES= ansi2knr.c ckconfig.c example.c
TESTFILES= testorig.jpg testimg.ppm testimg.gif testimg.jpg
DISTFILES= $(DOCS) $(MAKEFILES) $(SOURCES) $(SYSDEPFILES) $(INCLUDES) \
$(OTHERFILES) $(TESTFILES)
# objectfiles common to cjpeg and djpeg
COMOBJECTS= jutils.o jvirtmem.o jerror.o
COMOBJECTS= jutils.o jerror.o jmemmgr.o jmemsys.o
# compression objectfiles
CLIBOBJECTS= jcmaster.o jcdeflts.o jcarith.o jccolor.o jcexpand.o jchuff.o \
jcmcu.o jcpipe.o jcsample.o jfwddct.o jwrjfif.o jrdgif.o jrdppm.o \
@ -86,7 +95,7 @@ libjpeg.a: $(LIBOBJECTS)
$(AR2) libjpeg.a
clean:
$(RM) *.o cjpeg djpeg libjpeg.a core testout.ppm testout.jpg
$(RM) *.o cjpeg djpeg libjpeg.a core testout.*
distribute:
$(RM) jpegsrc.tar*
@ -94,10 +103,12 @@ distribute:
compress -v jpegsrc.tar
test: cjpeg djpeg
$(RM) testout.ppm testout.jpg
$(RM) testout.ppm testout.gif testout.jpg
./djpeg testorig.jpg >testout.ppm
./djpeg -G testorig.jpg >testout.gif
./cjpeg testimg.ppm >testout.jpg
cmp testimg.ppm testout.ppm
cmp testimg.gif testout.gif
cmp testimg.jpg testout.jpg
@ -127,7 +138,7 @@ jquant2.o : jquant2.c jinclude.h jconfig.h jpegdata.h
jfwddct.o : jfwddct.c jinclude.h jconfig.h jpegdata.h
jrevdct.o : jrevdct.c jinclude.h jconfig.h jpegdata.h
jutils.o : jutils.c jinclude.h jconfig.h jpegdata.h
jvirtmem.o : jvirtmem.c jinclude.h jconfig.h jpegdata.h
jmemmgr.o : jmemmgr.c jinclude.h jconfig.h jpegdata.h jmemsys.h
jrdjfif.o : jrdjfif.c jinclude.h jconfig.h jpegdata.h
jrdgif.o : jrdgif.c jinclude.h jconfig.h jpegdata.h
jrdppm.o : jrdppm.c jinclude.h jconfig.h jpegdata.h
@ -138,3 +149,4 @@ jwrgif.o : jwrgif.c jinclude.h jconfig.h jpegdata.h
jwrppm.o : jwrppm.c jinclude.h jconfig.h jpegdata.h
jwrrle.o : jwrrle.c jinclude.h jconfig.h jpegdata.h
jwrtarga.o : jwrtarga.c jinclude.h jconfig.h jpegdata.h
jmemsys.o : jmemsys.c jinclude.h jconfig.h jpegdata.h jmemsys.h

139
makefile.bcc Normal file
View File

@ -0,0 +1,139 @@
# Makefile for Independent JPEG Group's software
# This makefile is suitable for Borland C (Turbo C) on MS-DOS.
# It is set up for Borland C++, revision 3.0 or later.
# For older versions (pre-3.0), replace "-O2" with "-O -G -Z" in CFLAGS.
# If you have an even older version of Turbo C, you may be able to make it
# work by saying "CC= tcc" below. (Very early versions of Turbo C++,
# like 1.01, are so buggy that you may as well forget it.)
# Thanks to Tom Wright and Ge' Weijers for this file.
# Read SETUP instructions before saying "make" !!
# The name of your C compiler:
CC= bcc
# You may need to adjust these cc options:
CFLAGS= -DHAVE_STDC -DINCLUDES_ARE_ANSI \
-ms -DMSDOS -DINCOMPLETE_TYPES_BROKEN -w-par -O2
# -DHAVE_STDC -DINCLUDES_ARE_ANSI enable ANSI-C features (we DON'T want -A)
# -ms selects small memory model for most efficient code
# -DMSDOS enables DOS-specific code
# -DINCOMPLETE_TYPES_BROKEN suppresses bogus warning about undefined structures
# -w-par suppresses warnings about unused function parameters
# -O2 enables full code optimization (for pre-3.0 Borland C++, use -O -G -Z)
# Link-time cc options:
LDFLAGS= -ms
# memory model option here must match CFLAGS!
# source files (independently compilable files)
SOURCES= jbsmooth.c jcarith.c jccolor.c jcdeflts.c jcexpand.c jchuff.c \
jcmain.c jcmaster.c jcmcu.c jcpipe.c jcsample.c jdarith.c jdcolor.c \
jddeflts.c jdhuff.c jdmain.c jdmaster.c jdmcu.c jdpipe.c jdsample.c \
jerror.c jquant1.c jquant2.c jfwddct.c jrevdct.c jutils.c jmemmgr.c \
jrdjfif.c jrdgif.c jrdppm.c jrdrle.c jrdtarga.c jwrjfif.c jwrgif.c \
jwrppm.c jwrrle.c jwrtarga.c
# virtual source files (not present in distribution file)
VIRTSOURCES= jmemsys.c
# system-dependent implementations of source files
SYSDEPFILES= jmemansi.c jmemname.c jmemnobs.c jmemdos.c jmemdos.h \
jmemdosa.asm
# files included by source files
INCLUDES= jinclude.h jconfig.h jpegdata.h jversion.h jmemsys.h egetopt.c
# documentation, test, and support files
DOCS= README SETUP USAGE CHANGELOG cjpeg.1 djpeg.1 architecture codingrules
MAKEFILES= makefile.ansi makefile.unix makefile.manx makefile.sas \
makefile.mc5 makefile.mc6 makcjpeg.lnk makdjpeg.lnk makefile.bcc \
makcjpeg.lst makdjpeg.lst makefile.pwc makcjpeg.cf makdjpeg.cf \
makljpeg.cf makefile.mms makefile.vms makvms.opt
OTHERFILES= ansi2knr.c ckconfig.c example.c
TESTFILES= testorig.jpg testimg.ppm testimg.gif testimg.jpg
DISTFILES= $(DOCS) $(MAKEFILES) $(SOURCES) $(SYSDEPFILES) $(INCLUDES) \
$(OTHERFILES) $(TESTFILES)
# objectfiles common to cjpeg and djpeg
COMOBJECTS= jutils.obj jerror.obj jmemmgr.obj jmemsys.obj jmemdosa.obj
# compression objectfiles
CLIBOBJECTS= jcmaster.obj jcdeflts.obj jcarith.obj jccolor.obj jcexpand.obj \
jchuff.obj jcmcu.obj jcpipe.obj jcsample.obj jfwddct.obj \
jwrjfif.obj jrdgif.obj jrdppm.obj jrdrle.obj jrdtarga.obj
COBJECTS= jcmain.obj $(CLIBOBJECTS) $(COMOBJECTS)
# decompression objectfiles
DLIBOBJECTS= jdmaster.obj jddeflts.obj jbsmooth.obj jdarith.obj jdcolor.obj \
jdhuff.obj jdmcu.obj jdpipe.obj jdsample.obj jquant1.obj \
jquant2.obj jrevdct.obj jrdjfif.obj jwrgif.obj jwrppm.obj \
jwrrle.obj jwrtarga.obj
DOBJECTS= jdmain.obj $(DLIBOBJECTS) $(COMOBJECTS)
# These objectfiles are included in libjpeg.lib
LIBOBJECTS= $(CLIBOBJECTS) $(DLIBOBJECTS) $(COMOBJECTS)
all: cjpeg.exe djpeg.exe
cjpeg.exe: $(COBJECTS)
$(CC) $(LDFLAGS) -ecjpeg.exe @makcjpeg.lst
djpeg.exe: $(DOBJECTS)
$(CC) $(LDFLAGS) -edjpeg.exe @makdjpeg.lst
.c.obj:
$(CC) $(CFLAGS) -c $<
clean:
del *.obj
del cjpeg.exe
del djpeg.exe
del testout.*
test:
del testout.*
djpeg testorig.jpg testout.ppm
djpeg -G testorig.jpg testout.gif
cjpeg testimg.ppm testout.jpg
fc testimg.ppm testout.ppm
fc testimg.gif testout.gif
fc testimg.jpg testout.jpg
jbsmooth.obj : jbsmooth.c jinclude.h jconfig.h jpegdata.h
jcarith.obj : jcarith.c jinclude.h jconfig.h jpegdata.h
jccolor.obj : jccolor.c jinclude.h jconfig.h jpegdata.h
jcdeflts.obj : jcdeflts.c jinclude.h jconfig.h jpegdata.h
jcexpand.obj : jcexpand.c jinclude.h jconfig.h jpegdata.h
jchuff.obj : jchuff.c jinclude.h jconfig.h jpegdata.h
jcmain.obj : jcmain.c jinclude.h jconfig.h jpegdata.h jversion.h egetopt.c
jcmaster.obj : jcmaster.c jinclude.h jconfig.h jpegdata.h
jcmcu.obj : jcmcu.c jinclude.h jconfig.h jpegdata.h
jcpipe.obj : jcpipe.c jinclude.h jconfig.h jpegdata.h
jcsample.obj : jcsample.c jinclude.h jconfig.h jpegdata.h
jdarith.obj : jdarith.c jinclude.h jconfig.h jpegdata.h
jdcolor.obj : jdcolor.c jinclude.h jconfig.h jpegdata.h
jddeflts.obj : jddeflts.c jinclude.h jconfig.h jpegdata.h
jdhuff.obj : jdhuff.c jinclude.h jconfig.h jpegdata.h
jdmain.obj : jdmain.c jinclude.h jconfig.h jpegdata.h jversion.h egetopt.c
jdmaster.obj : jdmaster.c jinclude.h jconfig.h jpegdata.h
jdmcu.obj : jdmcu.c jinclude.h jconfig.h jpegdata.h
jdpipe.obj : jdpipe.c jinclude.h jconfig.h jpegdata.h
jdsample.obj : jdsample.c jinclude.h jconfig.h jpegdata.h
jerror.obj : jerror.c jinclude.h jconfig.h jpegdata.h
jquant1.obj : jquant1.c jinclude.h jconfig.h jpegdata.h
jquant2.obj : jquant2.c jinclude.h jconfig.h jpegdata.h
jfwddct.obj : jfwddct.c jinclude.h jconfig.h jpegdata.h
jrevdct.obj : jrevdct.c jinclude.h jconfig.h jpegdata.h
jutils.obj : jutils.c jinclude.h jconfig.h jpegdata.h
jmemmgr.obj : jmemmgr.c jinclude.h jconfig.h jpegdata.h jmemsys.h
jrdjfif.obj : jrdjfif.c jinclude.h jconfig.h jpegdata.h
jrdgif.obj : jrdgif.c jinclude.h jconfig.h jpegdata.h
jrdppm.obj : jrdppm.c jinclude.h jconfig.h jpegdata.h
jrdrle.obj : jrdrle.c jinclude.h jconfig.h jpegdata.h
jrdtarga.obj : jrdtarga.c jinclude.h jconfig.h jpegdata.h
jwrjfif.obj : jwrjfif.c jinclude.h jconfig.h jpegdata.h
jwrgif.obj : jwrgif.c jinclude.h jconfig.h jpegdata.h
jwrppm.obj : jwrppm.c jinclude.h jconfig.h jpegdata.h
jwrrle.obj : jwrrle.c jinclude.h jconfig.h jpegdata.h
jwrtarga.obj : jwrtarga.c jinclude.h jconfig.h jpegdata.h
jmemsys.obj : jmemsys.c jinclude.h jconfig.h jpegdata.h jmemsys.h
jmemdosa.obj : jmemdosa.asm
tasm /mx jmemdosa.asm

View File

@ -1,7 +1,8 @@
# Makefile for Independent JPEG Group's software
# This makefile is for Amiga systems using Manx Aztec C ver 5.x.
# Thanks to D.J. James for this version.
# Use jmemname.c as the system-dependent memory manager.
# Thanks to D.J. James (djjames@cup.portal.com) for this version.
# Read SETUP instructions before saying "make" !!
@ -9,7 +10,8 @@
CC= cc
# You may need to adjust these cc options:
CFLAGS= -MC -MD -DTWO_FILE_COMMANDLINE
CFLAGS= -MC -MD -sf -sn -sp -DAMIGA -DTWO_FILE_COMMANDLINE \
-DNEED_SIGNAL_CATCHER -Dsignal_catcher=_abort
# Link-time cc options:
LDFLAGS=
@ -30,23 +32,28 @@ AR= lb
SOURCES= jbsmooth.c jcarith.c jccolor.c jcdeflts.c jcexpand.c jchuff.c \
jcmain.c jcmaster.c jcmcu.c jcpipe.c jcsample.c jdarith.c jdcolor.c \
jddeflts.c jdhuff.c jdmain.c jdmaster.c jdmcu.c jdpipe.c jdsample.c \
jerror.c jquant1.c jquant2.c jfwddct.c jrevdct.c jutils.c \
jvirtmem.c jrdjfif.c jrdgif.c jrdppm.c jrdrle.c jrdtarga.c \
jwrjfif.c jwrgif.c jwrppm.c jwrrle.c jwrtarga.c
jerror.c jquant1.c jquant2.c jfwddct.c jrevdct.c jutils.c jmemmgr.c \
jrdjfif.c jrdgif.c jrdppm.c jrdrle.c jrdtarga.c jwrjfif.c jwrgif.c \
jwrppm.c jwrrle.c jwrtarga.c
# virtual source files (not present in distribution file)
VIRTSOURCES= jmemsys.c
# system-dependent implementations of source files
SYSDEPFILES= jmemansi.c jmemname.c jmemnobs.c jmemdos.c jmemdos.h \
jmemdosa.asm
# files included by source files
INCLUDES= jinclude.h jconfig.h jpegdata.h jversion.h egetopt.c
INCLUDES= jinclude.h jconfig.h jpegdata.h jversion.h jmemsys.h egetopt.c
# documentation, test, and support files
DOCS= README SETUP USAGE CHANGELOG cjpeg.1 djpeg.1 architecture codingrules
MAKEFILES= makefile.ansi makefile.unix makefile.manx makefile.sas \
makefile.mc5 makefile.mc6 makcjpeg.lnk makdjpeg.lnk makefile.tc \
makefile.mc5 makefile.mc6 makcjpeg.lnk makdjpeg.lnk makefile.bcc \
makcjpeg.lst makdjpeg.lst makefile.pwc makcjpeg.cf makdjpeg.cf \
makljpeg.cf
OTHERFILES= ansi2knr.c config.c
TESTFILES= testorig.jpg testimg.ppm testimg.jpg
DISTFILES= $(DOCS) $(MAKEFILES) $(SOURCES) $(INCLUDES) $(OTHERFILES) \
$(TESTFILES)
makljpeg.cf makefile.mms makefile.vms makvms.opt
OTHERFILES= ansi2knr.c ckconfig.c example.c
TESTFILES= testorig.jpg testimg.ppm testimg.gif testimg.jpg
DISTFILES= $(DOCS) $(MAKEFILES) $(SOURCES) $(SYSDEPFILES) $(INCLUDES) \
$(OTHERFILES) $(TESTFILES)
# objectfiles common to cjpeg and djpeg
COMOBJECTS= jutils.o jvirtmem.o jerror.o
COMOBJECTS= jutils.o jerror.o jmemmgr.o jmemsys.o
# compression objectfiles
CLIBOBJECTS= jcmaster.o jcdeflts.o jcarith.o jccolor.o jcexpand.o jchuff.o \
jcmcu.o jcpipe.o jcsample.o jfwddct.o jwrjfif.o jrdgif.o jrdppm.o \
@ -79,7 +86,7 @@ libjpeg.lib: $(LIBOBJECTS)
$(AR) libjpeg.lib $(LIBOBJECTS)
clean:
-$(RM) *.o cjpeg djpeg libjpeg.lib core testout.ppm testout.jpg
-$(RM) *.o cjpeg djpeg libjpeg.lib core testout.*
distribute:
-$(RM) jpegsrc.tar*
@ -87,10 +94,12 @@ distribute:
compress -v jpegsrc.tar
test: cjpeg djpeg
-$(RM) testout.ppm testout.jpg
-$(RM) testout.ppm testout.gif testout.jpg
djpeg testorig.jpg testout.ppm
djpeg -G testorig.jpg testout.gif
cjpeg testimg.ppm testout.jpg
cmp testimg.ppm testout.ppm
cmp testimg.gif testout.gif
cmp testimg.jpg testout.jpg
@ -120,7 +129,7 @@ jquant2.o : jquant2.c jinclude.h jconfig.h jpegdata.h
jfwddct.o : jfwddct.c jinclude.h jconfig.h jpegdata.h
jrevdct.o : jrevdct.c jinclude.h jconfig.h jpegdata.h
jutils.o : jutils.c jinclude.h jconfig.h jpegdata.h
jvirtmem.o : jvirtmem.c jinclude.h jconfig.h jpegdata.h
jmemmgr.o : jmemmgr.c jinclude.h jconfig.h jpegdata.h jmemsys.h
jrdjfif.o : jrdjfif.c jinclude.h jconfig.h jpegdata.h
jrdgif.o : jrdgif.c jinclude.h jconfig.h jpegdata.h
jrdppm.o : jrdppm.c jinclude.h jconfig.h jpegdata.h
@ -131,3 +140,4 @@ jwrgif.o : jwrgif.c jinclude.h jconfig.h jpegdata.h
jwrppm.o : jwrppm.c jinclude.h jconfig.h jpegdata.h
jwrrle.o : jwrrle.c jinclude.h jconfig.h jpegdata.h
jwrtarga.o : jwrtarga.c jinclude.h jconfig.h jpegdata.h
jmemsys.o : jmemsys.c jinclude.h jconfig.h jpegdata.h jmemsys.h

View File

@ -25,23 +25,28 @@ LDFLAGS= /Fm /F 2000 # /F hhhh sets stack size (in hex)
SOURCES= jbsmooth.c jcarith.c jccolor.c jcdeflts.c jcexpand.c jchuff.c \
jcmain.c jcmaster.c jcmcu.c jcpipe.c jcsample.c jdarith.c jdcolor.c \
jddeflts.c jdhuff.c jdmain.c jdmaster.c jdmcu.c jdpipe.c jdsample.c \
jerror.c jquant1.c jquant2.c jfwddct.c jrevdct.c jutils.c \
jvirtmem.c jrdjfif.c jrdgif.c jrdppm.c jrdrle.c jrdtarga.c \
jwrjfif.c jwrgif.c jwrppm.c jwrrle.c jwrtarga.c
jerror.c jquant1.c jquant2.c jfwddct.c jrevdct.c jutils.c jmemmgr.c \
jrdjfif.c jrdgif.c jrdppm.c jrdrle.c jrdtarga.c jwrjfif.c jwrgif.c \
jwrppm.c jwrrle.c jwrtarga.c
# virtual source files (not present in distribution file)
VIRTSOURCES= jmemsys.c
# system-dependent implementations of source files
SYSDEPFILES= jmemansi.c jmemname.c jmemnobs.c jmemdos.c jmemdos.h \
jmemdosa.asm
# files included by source files
INCLUDES= jinclude.h jconfig.h jpegdata.h jversion.h egetopt.c
INCLUDES= jinclude.h jconfig.h jpegdata.h jversion.h jmemsys.h egetopt.c
# documentation, test, and support files
DOCS= README SETUP USAGE CHANGELOG cjpeg.1 djpeg.1 architecture codingrules
MAKEFILES= makefile.ansi makefile.unix makefile.manx makefile.sas \
makefile.mc5 makefile.mc6 makcjpeg.lnk makdjpeg.lnk makefile.tc \
makefile.mc5 makefile.mc6 makcjpeg.lnk makdjpeg.lnk makefile.bcc \
makcjpeg.lst makdjpeg.lst makefile.pwc makcjpeg.cf makdjpeg.cf \
makljpeg.cf
OTHERFILES= ansi2knr.c config.c
TESTFILES= testorig.jpg testimg.ppm testimg.jpg
DISTFILES= $(DOCS) $(MAKEFILES) $(SOURCES) $(INCLUDES) $(OTHERFILES) \
$(TESTFILES)
makljpeg.cf makefile.mms makefile.vms makvms.opt
OTHERFILES= ansi2knr.c ckconfig.c example.c
TESTFILES= testorig.jpg testimg.ppm testimg.gif testimg.jpg
DISTFILES= $(DOCS) $(MAKEFILES) $(SOURCES) $(SYSDEPFILES) $(INCLUDES) \
$(OTHERFILES) $(TESTFILES)
# objectfiles common to cjpeg and djpeg
COMOBJECTS= jutils.obj jvirtmem.obj jerror.obj
COMOBJECTS= jutils.obj jerror.obj jmemmgr.obj jmemsys.obj jmemdosa.obj
# compression objectfiles
CLIBOBJECTS= jcmaster.obj jcdeflts.obj jcarith.obj jccolor.obj jcexpand.obj \
jchuff.obj jcmcu.obj jcpipe.obj jcsample.obj jfwddct.obj \
@ -63,6 +68,11 @@ LIBOBJECTS= $(CLIBOBJECTS) $(DLIBOBJECTS) $(COMOBJECTS)
cl $(CFLAGS) /c $*.c
lib libjpeg -+$*.obj;
# inference rule for assembly code
.asm.obj:
masm /mx $*;
lib libjpeg -+$*.obj;
jbsmooth.obj : jbsmooth.c jinclude.h jconfig.h jpegdata.h
@ -118,7 +128,7 @@ jrevdct.obj : jrevdct.c jinclude.h jconfig.h jpegdata.h
jutils.obj : jutils.c jinclude.h jconfig.h jpegdata.h
jvirtmem.obj : jvirtmem.c jinclude.h jconfig.h jpegdata.h
jmemmgr.obj : jmemmgr.c jinclude.h jconfig.h jpegdata.h jmemsys.h
jrdjfif.obj : jrdjfif.c jinclude.h jconfig.h jpegdata.h
@ -140,6 +150,9 @@ jwrrle.obj : jwrrle.c jinclude.h jconfig.h jpegdata.h
jwrtarga.obj : jwrtarga.c jinclude.h jconfig.h jpegdata.h
jmemsys.obj : jmemsys.c jinclude.h jconfig.h jpegdata.h jmemsys.h
jmemdosa.obj : jmemdosa.asm
cjpeg.exe: $(COBJECTS)

View File

@ -8,39 +8,44 @@
# compiler flags. -D gives a #define to the sources:
# -O default optimisation
# -W3 warning level 3
# -Za ANSI conformance, defines__STDC__ but undefines far
# -Za ANSI conformance, defines __STDC__ but undefines far
# and near, so we DON'T use it.
# -D__STDC__ pretend we have full ANSI compliance. MSC is near
# enough anyway
# -DHAVE_STDC indicate we do have all the ANSI language features
# -DINCLUDES_ARE_ANSI and all the ANSI include files.
# -DMSDOS we are on an MSDOS machine
# -DMEM_STATS enable memory usage statistics (optional)
# -c compile, don't link (implicit in inference rules)
# You might also want to add -G2 if you have an 80286, etc.
CFLAGS = -c -O -W3 -D__STDC__ -DMSDOS
CFLAGS = -c -O -W3 -DHAVE_STDC -DINCLUDES_ARE_ANSI -DMSDOS
# source files (independently compilable files)
SOURCES= jbsmooth.c jcarith.c jccolor.c jcdeflts.c jcexpand.c jchuff.c \
jcmain.c jcmaster.c jcmcu.c jcpipe.c jcsample.c jdarith.c jdcolor.c \
jddeflts.c jdhuff.c jdmain.c jdmaster.c jdmcu.c jdpipe.c jdsample.c \
jerror.c jquant1.c jquant2.c jfwddct.c jrevdct.c jutils.c \
jvirtmem.c jrdjfif.c jrdgif.c jrdppm.c jrdrle.c jrdtarga.c \
jwrjfif.c jwrgif.c jwrppm.c jwrrle.c jwrtarga.c
jerror.c jquant1.c jquant2.c jfwddct.c jrevdct.c jutils.c jmemmgr.c \
jrdjfif.c jrdgif.c jrdppm.c jrdrle.c jrdtarga.c jwrjfif.c jwrgif.c \
jwrppm.c jwrrle.c jwrtarga.c
# virtual source files (not present in distribution file)
VIRTSOURCES= jmemsys.c
# system-dependent implementations of source files
SYSDEPFILES= jmemansi.c jmemname.c jmemnobs.c jmemdos.c jmemdos.h \
jmemdosa.asm
# files included by source files
INCLUDES= jinclude.h jconfig.h jpegdata.h jversion.h egetopt.c
INCLUDES= jinclude.h jconfig.h jpegdata.h jversion.h jmemsys.h egetopt.c
# documentation, test, and support files
DOCS= README SETUP USAGE CHANGELOG cjpeg.1 djpeg.1 architecture codingrules
MAKEFILES= makefile.ansi makefile.unix makefile.manx makefile.sas \
makefile.mc5 makefile.mc6 makcjpeg.lnk makdjpeg.lnk makefile.tc \
makefile.mc5 makefile.mc6 makcjpeg.lnk makdjpeg.lnk makefile.bcc \
makcjpeg.lst makdjpeg.lst makefile.pwc makcjpeg.cf makdjpeg.cf \
makljpeg.cf
OTHERFILES= ansi2knr.c config.c
TESTFILES= testorig.jpg testimg.ppm testimg.jpg
DISTFILES= $(DOCS) $(MAKEFILES) $(SOURCES) $(INCLUDES) $(OTHERFILES) \
$(TESTFILES)
makljpeg.cf makefile.mms makefile.vms makvms.opt
OTHERFILES= ansi2knr.c ckconfig.c example.c
TESTFILES= testorig.jpg testimg.ppm testimg.gif testimg.jpg
DISTFILES= $(DOCS) $(MAKEFILES) $(SOURCES) $(SYSDEPFILES) $(INCLUDES) \
$(OTHERFILES) $(TESTFILES)
# objectfiles common to cjpeg and djpeg
COMOBJECTS= jutils.obj jvirtmem.obj jerror.obj
COMOBJECTS= jutils.obj jerror.obj jmemmgr.obj jmemsys.obj jmemdosa.obj
# compression objectfiles
CLIBOBJECTS= jcmaster.obj jcdeflts.obj jcarith.obj jccolor.obj jcexpand.obj \
jchuff.obj jcmcu.obj jcpipe.obj jcsample.obj jfwddct.obj \
@ -86,7 +91,7 @@ jquant2.obj : jquant2.c jinclude.h jconfig.h jpegdata.h
jfwddct.obj : jfwddct.c jinclude.h jconfig.h jpegdata.h
jrevdct.obj : jrevdct.c jinclude.h jconfig.h jpegdata.h
jutils.obj : jutils.c jinclude.h jconfig.h jpegdata.h
jvirtmem.obj : jvirtmem.c jinclude.h jconfig.h jpegdata.h
jmemmgr.obj : jmemmgr.c jinclude.h jconfig.h jpegdata.h jmemsys.h
jrdjfif.obj : jrdjfif.c jinclude.h jconfig.h jpegdata.h
jrdgif.obj : jrdgif.c jinclude.h jconfig.h jpegdata.h
jrdppm.obj : jrdppm.c jinclude.h jconfig.h jpegdata.h
@ -97,6 +102,10 @@ jwrgif.obj : jwrgif.c jinclude.h jconfig.h jpegdata.h
jwrppm.obj : jwrppm.c jinclude.h jconfig.h jpegdata.h
jwrrle.obj : jwrrle.c jinclude.h jconfig.h jpegdata.h
jwrtarga.obj : jwrtarga.c jinclude.h jconfig.h jpegdata.h
jmemsys.obj : jmemsys.c jinclude.h jconfig.h jpegdata.h jmemsys.h
jmemdosa.obj : jmemdosa.asm
masm /mx $*;
# use linker response files because file list > 128 chars
@ -106,3 +115,12 @@ cjpeg.exe: $(COBJECTS)
djpeg.exe: $(DOBJECTS)
link /STACK:8192 @makdjpeg.lnk
test:
del testout.*
djpeg testorig.jpg testout.ppm
djpeg -G testorig.jpg testout.gif
cjpeg testimg.ppm testout.jpg
fc testimg.ppm testout.ppm
fc testimg.gif testout.gif
fc testimg.jpg testout.jpg

134
makefile.mms Normal file
View File

@ -0,0 +1,134 @@
# Makefile for Independent JPEG Group's software
# This makefile is for use with MMS on VAX/VMS systems.
# Thanks to Rick Dyson (dyson@iowasp.physics.uiowa.edu) for his help.
# Read SETUP instructions before saying "MMS" !!
CFLAGS= $(CFLAGS) /NoDebug /Optimize /Define = (TWO_FILE_COMMANDLINE,HAVE_STDC,INCLUDES_ARE_ANSI)
OPT= Sys$Disk:[]MAKVMS.OPT
# source files (independently compilable files)
SOURCES= jbsmooth.c jcarith.c jccolor.c jcdeflts.c jcexpand.c jchuff.c \
jcmain.c jcmaster.c jcmcu.c jcpipe.c jcsample.c jdarith.c jdcolor.c \
jddeflts.c jdhuff.c jdmain.c jdmaster.c jdmcu.c jdpipe.c jdsample.c \
jerror.c jquant1.c jquant2.c jfwddct.c jrevdct.c jutils.c jmemmgr.c \
jrdjfif.c jrdgif.c jrdppm.c jrdrle.c jrdtarga.c jwrjfif.c jwrgif.c \
jwrppm.c jwrrle.c jwrtarga.c
# virtual source files (not present in distribution file)
VIRTSOURCES= jmemsys.c
# system-dependent implementations of source files
SYSDEPFILES= jmemansi.c jmemname.c jmemnobs.c jmemdos.c jmemdos.h \
jmemdosa.asm
# files included by source files
INCLUDES= jinclude.h jconfig.h jpegdata.h jversion.h jmemsys.h egetopt.c
# documentation, test, and support files
DOCS= README SETUP USAGE CHANGELOG cjpeg.1 djpeg.1 architecture codingrules
MAKEFILES= makefile.ansi makefile.unix makefile.manx makefile.sas \
makefile.mc5 makefile.mc6 makcjpeg.lnk makdjpeg.lnk makefile.bcc \
makcjpeg.lst makdjpeg.lst makefile.pwc makcjpeg.cf makdjpeg.cf \
makljpeg.cf makefile.mms makefile.vms makvms.opt
OTHERFILES= ansi2knr.c ckconfig.c example.c
TESTFILES= testorig.jpg testimg.ppm testimg.gif testimg.jpg
DISTFILES= $(DOCS) $(MAKEFILES) $(SOURCES) $(SYSDEPFILES) $(INCLUDES) \
$(OTHERFILES) $(TESTFILES)
# objectfiles common to cjpeg and djpeg
COMOBJECTS= jutils.obj jerror.obj jmemmgr.obj jmemsys.obj
# compression objectfiles
CLIBOBJECTS= jcmaster.obj jcdeflts.obj jcarith.obj jccolor.obj jcexpand.obj \
jchuff.obj jcmcu.obj jcpipe.obj jcsample.obj jfwddct.obj \
jwrjfif.obj jrdgif.obj jrdppm.obj jrdrle.obj jrdtarga.obj
COBJECTS= jcmain.obj $(CLIBOBJECTS) $(COMOBJECTS)
# decompression objectfiles
DLIBOBJECTS= jdmaster.obj jddeflts.obj jbsmooth.obj jdarith.obj jdcolor.obj \
jdhuff.obj jdmcu.obj jdpipe.obj jdsample.obj jquant1.obj \
jquant2.obj jrevdct.obj jrdjfif.obj jwrgif.obj jwrppm.obj \
jwrrle.obj jwrtarga.obj
DOBJECTS= jdmain.obj $(DLIBOBJECTS) $(COMOBJECTS)
# These objectfiles are included in libjpeg.olb
LIBOBJECTS= $(CLIBOBJECTS) $(DLIBOBJECTS) $(COMOBJECTS)
# objectfile lists with commas --- what a crock
COBJLIST= jcmain.obj,jcmaster.obj,jcdeflts.obj,jcarith.obj,jccolor.obj,\
jcexpand.obj,jchuff.obj,jcmcu.obj,jcpipe.obj,jcsample.obj,\
jfwddct.obj,jwrjfif.obj,jrdgif.obj,jrdppm.obj,jrdrle.obj,\
jrdtarga.obj,jutils.obj,jerror.obj,jmemmgr.obj,jmemsys.obj
DOBJLIST= jdmain.obj,jdmaster.obj,jddeflts.obj,jbsmooth.obj,jdarith.obj,\
jdcolor.obj,jdhuff.obj,jdmcu.obj,jdpipe.obj,jdsample.obj,\
jquant1.obj,jquant2.obj,jrevdct.obj,jrdjfif.obj,jwrgif.obj,\
jwrppm.obj,jwrrle.obj,jwrtarga.obj,jutils.obj,jerror.obj,\
jmemmgr.obj,jmemsys.obj
LIBOBJLIST= jcmaster.obj,jcdeflts.obj,jcarith.obj,jccolor.obj,jcexpand.obj,\
jchuff.obj,jcmcu.obj,jcpipe.obj,jcsample.obj,jfwddct.obj,\
jwrjfif.obj,jrdgif.obj,jrdppm.obj,jrdrle.obj,jrdtarga.obj,\
jdmaster.obj,jddeflts.obj,jbsmooth.obj,jdarith.obj,jdcolor.obj,\
jdhuff.obj,jdmcu.obj,jdpipe.obj,jdsample.obj,jquant1.obj,\
jquant2.obj,jrevdct.obj,jrdjfif.obj,jwrgif.obj,jwrppm.obj,\
jwrrle.obj,jwrtarga.obj,jutils.obj,jerror.obj,jmemmgr.obj,\
jmemsys.obj
.first
@ Define Sys Sys$Library
# By default, libjpeg.olb is not built unless you explicitly request it.
# You can add libjpeg.olb to the next line if you want it built by default.
ALL : cjpeg.exe djpeg.exe
@ Continue
cjpeg.exe : $(COBJECTS)
$(LINK) $(LFLAGS) /Executable = cjpeg.exe $(COBJLIST),$(OPT)/Option
djpeg.exe : $(DOBJECTS)
$(LINK) $(LFLAGS) /Executable = djpeg.exe $(DOBJLIST),$(OPT)/Option
# libjpeg.olb is useful if you are including the JPEG software in a larger
# program; you'd include it in your link, rather than the individual modules.
libjpeg.olb : $(LIBOBJECTS)
Library /Create libjpeg.olb $(LIBOBJLIST)
clean :
@- Set Protection = Owner:RWED *.*;-1
@- Set Protection = Owner:RWED *.OBJ
- Purge /NoLog /NoConfirm *.*
- Delete /NoLog /NoConfirm *.OBJ;
jbsmooth.obj : jbsmooth.c jinclude.h jconfig.h jpegdata.h
jcarith.obj : jcarith.c jinclude.h jconfig.h jpegdata.h
jccolor.obj : jccolor.c jinclude.h jconfig.h jpegdata.h
jcdeflts.obj : jcdeflts.c jinclude.h jconfig.h jpegdata.h
jcexpand.obj : jcexpand.c jinclude.h jconfig.h jpegdata.h
jchuff.obj : jchuff.c jinclude.h jconfig.h jpegdata.h
jcmain.obj : jcmain.c jinclude.h jconfig.h jpegdata.h jversion.h egetopt.c
jcmaster.obj : jcmaster.c jinclude.h jconfig.h jpegdata.h
jcmcu.obj : jcmcu.c jinclude.h jconfig.h jpegdata.h
jcpipe.obj : jcpipe.c jinclude.h jconfig.h jpegdata.h
jcsample.obj : jcsample.c jinclude.h jconfig.h jpegdata.h
jdarith.obj : jdarith.c jinclude.h jconfig.h jpegdata.h
jdcolor.obj : jdcolor.c jinclude.h jconfig.h jpegdata.h
jddeflts.obj : jddeflts.c jinclude.h jconfig.h jpegdata.h
jdhuff.obj : jdhuff.c jinclude.h jconfig.h jpegdata.h
jdmain.obj : jdmain.c jinclude.h jconfig.h jpegdata.h jversion.h egetopt.c
jdmaster.obj : jdmaster.c jinclude.h jconfig.h jpegdata.h
jdmcu.obj : jdmcu.c jinclude.h jconfig.h jpegdata.h
jdpipe.obj : jdpipe.c jinclude.h jconfig.h jpegdata.h
jdsample.obj : jdsample.c jinclude.h jconfig.h jpegdata.h
jerror.obj : jerror.c jinclude.h jconfig.h jpegdata.h
jquant1.obj : jquant1.c jinclude.h jconfig.h jpegdata.h
jquant2.obj : jquant2.c jinclude.h jconfig.h jpegdata.h
jfwddct.obj : jfwddct.c jinclude.h jconfig.h jpegdata.h
jrevdct.obj : jrevdct.c jinclude.h jconfig.h jpegdata.h
jutils.obj : jutils.c jinclude.h jconfig.h jpegdata.h
jmemmgr.obj : jmemmgr.c jinclude.h jconfig.h jpegdata.h jmemsys.h
jrdjfif.obj : jrdjfif.c jinclude.h jconfig.h jpegdata.h
jrdgif.obj : jrdgif.c jinclude.h jconfig.h jpegdata.h
jrdppm.obj : jrdppm.c jinclude.h jconfig.h jpegdata.h
jrdrle.obj : jrdrle.c jinclude.h jconfig.h jpegdata.h
jrdtarga.obj : jrdtarga.c jinclude.h jconfig.h jpegdata.h
jwrjfif.obj : jwrjfif.c jinclude.h jconfig.h jpegdata.h
jwrgif.obj : jwrgif.c jinclude.h jconfig.h jpegdata.h
jwrppm.obj : jwrppm.c jinclude.h jconfig.h jpegdata.h
jwrrle.obj : jwrrle.c jinclude.h jconfig.h jpegdata.h
jwrtarga.obj : jwrtarga.c jinclude.h jconfig.h jpegdata.h
jmemsys.obj : jmemsys.c jinclude.h jconfig.h jpegdata.h jmemsys.h

View File

@ -2,6 +2,9 @@
# This makefile is for Mix Software's Power C, v2.1.1
# and Dan Grayson's pd make 2.14 under MS-DOS.
# This file assumes that you have Microsoft's MASM or a compatible assembler
# to handle the jmemdosa.asm file. If not, you will need to use jmemname.c
# and go to a large-data memory model.
# Thanks to Bob Hardy for this version.
# Read SETUP instructions before saying "make" !!
@ -29,17 +32,21 @@ AR=merge
# source files (independently compilable files)
SOURCES= jbsmooth.c jcarith.c jccolor.c jcdeflts.c jcexpand.c jchuff.c jcmain.c jcmaster.c jcmcu.c jcpipe.c jcsample.c jdarith.c jdcolor.c jddeflts.c jdhuff.c jdmain.c jdmaster.c jdmcu.c jdpipe.c jdsample.c jerror.c jquant1.c jquant2.c jfwddct.c jrevdct.c jutils.c jvirtmem.c jrdjfif.c jrdgif.c jrdppm.c jrdrle.c jrdtarga.c jwrjfif.c jwrgif.c jwrppm.c jwrrle.c jwrtarga.c
SOURCES= jbsmooth.c jcarith.c jccolor.c jcdeflts.c jcexpand.c jchuff.c jcmain.c jcmaster.c jcmcu.c jcpipe.c jcsample.c jdarith.c jdcolor.c jddeflts.c jdhuff.c jdmain.c jdmaster.c jdmcu.c jdpipe.c jdsample.c jerror.c jquant1.c jquant2.c jfwddct.c jrevdct.c jutils.c jmemmgr.c jrdjfif.c jrdgif.c jrdppm.c jrdrle.c jrdtarga.c jwrjfif.c jwrgif.c jwrppm.c jwrrle.c jwrtarga.c
# virtual source files (not present in distribution file)
VIRTSOURCES= jmemsys.c
# system-dependent implementations of source files
SYSDEPFILES= jmemansi.c jmemname.c jmemnobs.c jmemdos.c jmemdos.h jmemdosa.asm
# files included by source files
INCLUDES= jinclude.h jconfig.h jpegdata.h jversion.h egetopt.c
INCLUDES= jinclude.h jconfig.h jpegdata.h jversion.h jmemsys.h egetopt.c
# documentation, test, and support files
DOCS= README SETUP USAGE CHANGELOG cjpeg.1 djpeg.1 architecture codingrules
MAKEFILES= makefile.ansi makefile.unix makefile.manx makefile.sas makefile.mc5 makefile.mc6 makcjpeg.lnk makdjpeg.lnk makefile.tc makcjpeg.lst makdjpeg.lst makefile.pwc makcjpeg.cf makdjpeg.cf makljpeg.cf
OTHERFILES= ansi2knr.c config.c
TESTFILES= testorig.jpg testimg.ppm testimg.jpg
DISTFILES= $(DOCS) $(MAKEFILES) $(SOURCES) $(INCLUDES) $(OTHERFILES) $(TESTFILES)
MAKEFILES= makefile.ansi makefile.unix makefile.manx makefile.sas makefile.mc5 makefile.mc6 makcjpeg.lnk makdjpeg.lnk makefile.bcc makcjpeg.lst makdjpeg.lst makefile.pwc makcjpeg.cf makdjpeg.cf makljpeg.cf makefile.mms makefile.vms makvms.opt
OTHERFILES= ansi2knr.c ckconfig.c example.c
TESTFILES= testorig.jpg testimg.ppm testimg.gif testimg.jpg
DISTFILES= $(DOCS) $(MAKEFILES) $(SOURCES) $(SYSDEPFILES) $(INCLUDES) $(OTHERFILES) $(TESTFILES)
# objectfiles common to cjpeg and djpeg
COMOBJECTS= jutils.mix jvirtmem.mix jerror.mix
COMOBJECTS= jutils.mix jerror.mix jmemmgr.mix jmemsys.mix jmemdosa.mix
# compression objectfiles
CLIBOBJECTS= jcmaster.mix jcdeflts.mix jcarith.mix jccolor.mix jcexpand.mix jchuff.mix jcmcu.mix jcpipe.mix jcsample.mix jfwddct.mix jwrjfif.mix jrdgif.mix jrdppm.mix jrdrle.mix jrdtarga.mix
COBJECTS= jcmain.mix $(CLIBOBJECTS) $(COMOBJECTS)
@ -73,8 +80,10 @@ clean:
test:
@$(RM) testout.*
+djpeg testorig.jpg testout.ppm
+djpeg -G testorig.jpg testout.gif
+cjpeg testimg.ppm testout.jpg
fc testimg.ppm testout.ppm
fc testimg.gif testout.gif
fc testimg.jpg testout.jpg
@ -104,7 +113,7 @@ jquant2.mix : jquant2.c jinclude.h jconfig.h jpegdata.h
jfwddct.mix : jfwddct.c jinclude.h jconfig.h jpegdata.h
jrevdct.mix : jrevdct.c jinclude.h jconfig.h jpegdata.h
jutils.mix : jutils.c jinclude.h jconfig.h jpegdata.h
jvirtmem.mix : jvirtmem.c jinclude.h jconfig.h jpegdata.h
jmemmgr.mix : jmemmgr.c jinclude.h jconfig.h jpegdata.h jmemsys.h
jrdjfif.mix : jrdjfif.c jinclude.h jconfig.h jpegdata.h
jrdgif.mix : jrdgif.c jinclude.h jconfig.h jpegdata.h
jrdppm.mix : jrdppm.c jinclude.h jconfig.h jpegdata.h
@ -115,3 +124,7 @@ jwrgif.mix : jwrgif.c jinclude.h jconfig.h jpegdata.h
jwrppm.mix : jwrppm.c jinclude.h jconfig.h jpegdata.h
jwrrle.mix : jwrrle.c jinclude.h jconfig.h jpegdata.h
jwrtarga.mix : jwrtarga.c jinclude.h jconfig.h jpegdata.h
jmemsys.mix : jmemsys.c jinclude.h jconfig.h jpegdata.h jmemsys.h
jmemdosa.mix : jmemdosa.asm
masm /mx jmemdosa;
mix jmemdosa.obj

View File

@ -1,6 +1,7 @@
# Makefile for Independent JPEG Group's software
# This makefile is for Amiga systems using SAS C 5.10b.
# Use jmemname.c as the system-dependent memory manager.
# Contributed by Ed Hanway (sisd!jeh@uunet.uu.net).
# Read SETUP instructions before saying "make" !!
@ -17,7 +18,9 @@ SUFFIX=
#SUFFIX=.030
# You may need to adjust these cc options:
CFLAGS= -v -b -rr -O -j104 -D__STDC__ -DTWO_FILE_COMMANDLINE -DINCOMPLETE_TYPES_BROKEN $(ARCHFLAGS)
CFLAGS= -v -b -rr -O -j104 $(ARCHFLAGS) -DHAVE_STDC -DINCLUDES_ARE_ANSI \
-DAMIGA -DTWO_FILE_COMMANDLINE -DINCOMPLETE_TYPES_BROKEN \
-DNO_MKTEMP -DNEED_SIGNAL_CATCHER
# -j104 disables warnings for mismatched const qualifiers
# Link-time cc options:
@ -39,23 +42,28 @@ AR= oml
SOURCES= jbsmooth.c jcarith.c jccolor.c jcdeflts.c jcexpand.c jchuff.c \
jcmain.c jcmaster.c jcmcu.c jcpipe.c jcsample.c jdarith.c jdcolor.c \
jddeflts.c jdhuff.c jdmain.c jdmaster.c jdmcu.c jdpipe.c jdsample.c \
jerror.c jquant1.c jquant2.c jfwddct.c jrevdct.c jutils.c \
jvirtmem.c jrdjfif.c jrdgif.c jrdppm.c jrdrle.c jrdtarga.c \
jwrjfif.c jwrgif.c jwrppm.c jwrrle.c jwrtarga.c
jerror.c jquant1.c jquant2.c jfwddct.c jrevdct.c jutils.c jmemmgr.c \
jrdjfif.c jrdgif.c jrdppm.c jrdrle.c jrdtarga.c jwrjfif.c jwrgif.c \
jwrppm.c jwrrle.c jwrtarga.c
# virtual source files (not present in distribution file)
VIRTSOURCES= jmemsys.c
# system-dependent implementations of source files
SYSDEPFILES= jmemansi.c jmemname.c jmemnobs.c jmemdos.c jmemdos.h \
jmemdosa.asm
# files included by source files
INCLUDES= jinclude.h jconfig.h jpegdata.h jversion.h egetopt.c
INCLUDES= jinclude.h jconfig.h jpegdata.h jversion.h jmemsys.h egetopt.c
# documentation, test, and support files
DOCS= README SETUP USAGE CHANGELOG cjpeg.1 djpeg.1 architecture codingrules
MAKEFILES= makefile.ansi makefile.unix makefile.manx makefile.sas \
makefile.mc5 makefile.mc6 makcjpeg.lnk makdjpeg.lnk makefile.tc \
makefile.mc5 makefile.mc6 makcjpeg.lnk makdjpeg.lnk makefile.bcc \
makcjpeg.lst makdjpeg.lst makefile.pwc makcjpeg.cf makdjpeg.cf \
makljpeg.cf
OTHERFILES= ansi2knr.c config.c
TESTFILES= testorig.jpg testimg.ppm testimg.jpg
DISTFILES= $(DOCS) $(MAKEFILES) $(SOURCES) $(INCLUDES) $(OTHERFILES) \
$(TESTFILES)
makljpeg.cf makefile.mms makefile.vms makvms.opt
OTHERFILES= ansi2knr.c ckconfig.c example.c
TESTFILES= testorig.jpg testimg.ppm testimg.gif testimg.jpg
DISTFILES= $(DOCS) $(MAKEFILES) $(SOURCES) $(SYSDEPFILES) $(INCLUDES) \
$(OTHERFILES) $(TESTFILES)
# objectfiles common to cjpeg and djpeg
COMOBJECTS= jutils.o jvirtmem.o jerror.o
COMOBJECTS= jutils.o jerror.o jmemmgr.o jmemsys.o
# compression objectfiles
CLIBOBJECTS= jcmaster.o jcdeflts.o jcarith.o jccolor.o jcexpand.o jchuff.o \
jcmcu.o jcpipe.o jcsample.o jfwddct.o jwrjfif.o jrdgif.o jrdppm.o \
@ -98,7 +106,7 @@ libjpeg.lib: $(LIBOBJECTS)
$(AR) libjpeg.lib r $(LIBOBJECTS)
clean:
-$(RM) *.o cjpeg djpeg cjpeg.030 djpeg.030 libjpeg.lib core testout.ppm testout.jpg
-$(RM) *.o cjpeg djpeg cjpeg.030 djpeg.030 libjpeg.lib core testout.*
distribute:
-$(RM) jpegsrc.tar*
@ -106,10 +114,12 @@ distribute:
compress -v jpegsrc.tar
test: cjpeg djpeg
-$(RM) testout.ppm testout.jpg
-$(RM) testout.ppm testout.gif testout.jpg
djpeg testorig.jpg testout.ppm
djpeg -G testorig.jpg testout.gif
cjpeg testimg.ppm testout.jpg
cmp testimg.ppm testout.ppm
cmp testimg.gif testout.gif
cmp testimg.jpg testout.jpg
@ -139,7 +149,7 @@ jquant2.o : jquant2.c jinclude.h jconfig.h jpegdata.h
jfwddct.o : jfwddct.c jinclude.h jconfig.h jpegdata.h
jrevdct.o : jrevdct.c jinclude.h jconfig.h jpegdata.h
jutils.o : jutils.c jinclude.h jconfig.h jpegdata.h
jvirtmem.o : jvirtmem.c jinclude.h jconfig.h jpegdata.h
jmemmgr.o : jmemmgr.c jinclude.h jconfig.h jpegdata.h jmemsys.h
jrdjfif.o : jrdjfif.c jinclude.h jconfig.h jpegdata.h
jrdgif.o : jrdgif.c jinclude.h jconfig.h jpegdata.h
jrdppm.o : jrdppm.c jinclude.h jconfig.h jpegdata.h
@ -150,3 +160,4 @@ jwrgif.o : jwrgif.c jinclude.h jconfig.h jpegdata.h
jwrppm.o : jwrppm.c jinclude.h jconfig.h jpegdata.h
jwrrle.o : jwrrle.c jinclude.h jconfig.h jpegdata.h
jwrtarga.o : jwrtarga.c jinclude.h jconfig.h jpegdata.h
jmemsys.o : jmemsys.c jinclude.h jconfig.h jpegdata.h jmemsys.h

View File

@ -1,113 +0,0 @@
# Makefile for Independent JPEG Group's software
# This makefile is suitable for Borland C (Turbo C) on MS-DOS.
# It is set up for Borland C++ revision 2.0; if you have an older
# version of Turbo C, you need to say "CC= tc" below.
# Thanks to Tom Wright for this version.
# Read SETUP instructions before saying "make" !!
# The name of your C compiler:
CC= bcc
# You may need to adjust these cc options:
CFLAGS= -c -ml -DINCOMPLETE_TYPES_BROKEN
# -DINCOMPLETE_TYPES_BROKEN suppresses warnings about undefined structures
# Link-time cc options:
LDFLAGS= -ml
# source files (independently compilable files)
SOURCES= jbsmooth.c jcarith.c jccolor.c jcdeflts.c jcexpand.c jchuff.c \
jcmain.c jcmaster.c jcmcu.c jcpipe.c jcsample.c jdarith.c jdcolor.c \
jddeflts.c jdhuff.c jdmain.c jdmaster.c jdmcu.c jdpipe.c jdsample.c \
jerror.c jquant1.c jquant2.c jfwddct.c jrevdct.c jutils.c \
jvirtmem.c jrdjfif.c jrdgif.c jrdppm.c jrdrle.c jrdtarga.c \
jwrjfif.c jwrgif.c jwrppm.c jwrrle.c jwrtarga.c
# files included by source files
INCLUDES= jinclude.h jconfig.h jpegdata.h jversion.h egetopt.c
# documentation, test, and support files
DOCS= README SETUP USAGE CHANGELOG cjpeg.1 djpeg.1 architecture codingrules
MAKEFILES= makefile.ansi makefile.unix makefile.manx makefile.sas \
makefile.mc5 makefile.mc6 makcjpeg.lnk makdjpeg.lnk makefile.tc \
makcjpeg.lst makdjpeg.lst makefile.pwc makcjpeg.cf makdjpeg.cf \
makljpeg.cf
OTHERFILES= ansi2knr.c config.c
TESTFILES= testorig.jpg testimg.ppm testimg.jpg
DISTFILES= $(DOCS) $(MAKEFILES) $(SOURCES) $(INCLUDES) $(OTHERFILES) \
$(TESTFILES)
# objectfiles common to cjpeg and djpeg
COMOBJECTS= jutils.obj jvirtmem.obj jerror.obj
# compression objectfiles
CLIBOBJECTS= jcmaster.obj jcdeflts.obj jcarith.obj jccolor.obj jcexpand.obj \
jchuff.obj jcmcu.obj jcpipe.obj jcsample.obj jfwddct.obj \
jwrjfif.obj jrdgif.obj jrdppm.obj jrdrle.obj jrdtarga.obj
COBJECTS= jcmain.obj $(CLIBOBJECTS) $(COMOBJECTS)
# decompression objectfiles
DLIBOBJECTS= jdmaster.obj jddeflts.obj jbsmooth.obj jdarith.obj jdcolor.obj \
jdhuff.obj jdmcu.obj jdpipe.obj jdsample.obj jquant1.obj \
jquant2.obj jrevdct.obj jrdjfif.obj jwrgif.obj jwrppm.obj \
jwrrle.obj jwrtarga.obj
DOBJECTS= jdmain.obj $(DLIBOBJECTS) $(COMOBJECTS)
# These objectfiles are included in libjpeg.lib
LIBOBJECTS= $(CLIBOBJECTS) $(DLIBOBJECTS) $(COMOBJECTS)
all: cjpeg.exe djpeg.exe
cjpeg.exe: $(COBJECTS)
$(CC) $(LDFLAGS) -ecjpeg.exe @makcjpeg.lst
djpeg.exe: $(DOBJECTS)
$(CC) $(LDFLAGS) -edjpeg.exe @makdjpeg.lst
.c.obj:
$(CC) $(CFLAGS) $<
test:
del testout.*
djpeg testorig.jpg testout.ppm
cjpeg testimg.ppm testout.jpg
fc testimg.ppm testout.ppm
fc testimg.jpg testout.jpg
jbsmooth.o : jbsmooth.c jinclude.h jconfig.h jpegdata.h
jcarith.o : jcarith.c jinclude.h jconfig.h jpegdata.h
jccolor.o : jccolor.c jinclude.h jconfig.h jpegdata.h
jcdeflts.o : jcdeflts.c jinclude.h jconfig.h jpegdata.h
jcexpand.o : jcexpand.c jinclude.h jconfig.h jpegdata.h
jchuff.o : jchuff.c jinclude.h jconfig.h jpegdata.h
jcmain.o : jcmain.c jinclude.h jconfig.h jpegdata.h jversion.h egetopt.c
jcmaster.o : jcmaster.c jinclude.h jconfig.h jpegdata.h
jcmcu.o : jcmcu.c jinclude.h jconfig.h jpegdata.h
jcpipe.o : jcpipe.c jinclude.h jconfig.h jpegdata.h
jcsample.o : jcsample.c jinclude.h jconfig.h jpegdata.h
jdarith.o : jdarith.c jinclude.h jconfig.h jpegdata.h
jdcolor.o : jdcolor.c jinclude.h jconfig.h jpegdata.h
jddeflts.o : jddeflts.c jinclude.h jconfig.h jpegdata.h
jdhuff.o : jdhuff.c jinclude.h jconfig.h jpegdata.h
jdmain.o : jdmain.c jinclude.h jconfig.h jpegdata.h jversion.h egetopt.c
jdmaster.o : jdmaster.c jinclude.h jconfig.h jpegdata.h
jdmcu.o : jdmcu.c jinclude.h jconfig.h jpegdata.h
jdpipe.o : jdpipe.c jinclude.h jconfig.h jpegdata.h
jdsample.o : jdsample.c jinclude.h jconfig.h jpegdata.h
jerror.o : jerror.c jinclude.h jconfig.h jpegdata.h
jquant1.o : jquant1.c jinclude.h jconfig.h jpegdata.h
jquant2.o : jquant2.c jinclude.h jconfig.h jpegdata.h
jfwddct.o : jfwddct.c jinclude.h jconfig.h jpegdata.h
jrevdct.o : jrevdct.c jinclude.h jconfig.h jpegdata.h
jutils.o : jutils.c jinclude.h jconfig.h jpegdata.h
jvirtmem.o : jvirtmem.c jinclude.h jconfig.h jpegdata.h
jrdjfif.o : jrdjfif.c jinclude.h jconfig.h jpegdata.h
jrdgif.o : jrdgif.c jinclude.h jconfig.h jpegdata.h
jrdppm.o : jrdppm.c jinclude.h jconfig.h jpegdata.h
jrdrle.o : jrdrle.c jinclude.h jconfig.h jpegdata.h
jrdtarga.o : jrdtarga.c jinclude.h jconfig.h jpegdata.h
jwrjfif.o : jwrjfif.c jinclude.h jconfig.h jpegdata.h
jwrgif.o : jwrgif.c jinclude.h jconfig.h jpegdata.h
jwrppm.o : jwrppm.c jinclude.h jconfig.h jpegdata.h
jwrrle.o : jwrrle.c jinclude.h jconfig.h jpegdata.h
jwrtarga.o : jwrtarga.c jinclude.h jconfig.h jpegdata.h

View File

@ -28,33 +28,42 @@ LDFLAGS=
LDLIBS=
# miscellaneous OS-dependent stuff
LN= $(CC) # linker
RM= rm -f # file deletion command
AR= ar rc # library (.a) file creation command
AR2= ranlib # second step in .a creation (use "touch" if not needed)
# linker
LN= $(CC)
# file deletion command
RM= rm -f
# library (.a) file creation command
AR= ar rc
# second step in .a creation (use "touch" if not needed)
AR2= ranlib
# source files (independently compilable files)
SOURCES= jbsmooth.c jcarith.c jccolor.c jcdeflts.c jcexpand.c jchuff.c \
jcmain.c jcmaster.c jcmcu.c jcpipe.c jcsample.c jdarith.c jdcolor.c \
jddeflts.c jdhuff.c jdmain.c jdmaster.c jdmcu.c jdpipe.c jdsample.c \
jerror.c jquant1.c jquant2.c jfwddct.c jrevdct.c jutils.c \
jvirtmem.c jrdjfif.c jrdgif.c jrdppm.c jrdrle.c jrdtarga.c \
jwrjfif.c jwrgif.c jwrppm.c jwrrle.c jwrtarga.c
jerror.c jquant1.c jquant2.c jfwddct.c jrevdct.c jutils.c jmemmgr.c \
jrdjfif.c jrdgif.c jrdppm.c jrdrle.c jrdtarga.c jwrjfif.c jwrgif.c \
jwrppm.c jwrrle.c jwrtarga.c
# virtual source files (not present in distribution file)
VIRTSOURCES= jmemsys.c
# system-dependent implementations of source files
SYSDEPFILES= jmemansi.c jmemname.c jmemnobs.c jmemdos.c jmemdos.h \
jmemdosa.asm
# files included by source files
INCLUDES= jinclude.h jconfig.h jpegdata.h jversion.h egetopt.c
INCLUDES= jinclude.h jconfig.h jpegdata.h jversion.h jmemsys.h egetopt.c
# documentation, test, and support files
DOCS= README SETUP USAGE CHANGELOG cjpeg.1 djpeg.1 architecture codingrules
MAKEFILES= makefile.ansi makefile.unix makefile.manx makefile.sas \
makefile.mc5 makefile.mc6 makcjpeg.lnk makdjpeg.lnk makefile.tc \
makefile.mc5 makefile.mc6 makcjpeg.lnk makdjpeg.lnk makefile.bcc \
makcjpeg.lst makdjpeg.lst makefile.pwc makcjpeg.cf makdjpeg.cf \
makljpeg.cf
OTHERFILES= ansi2knr.c config.c
TESTFILES= testorig.jpg testimg.ppm testimg.jpg
DISTFILES= $(DOCS) $(MAKEFILES) $(SOURCES) $(INCLUDES) $(OTHERFILES) \
$(TESTFILES)
makljpeg.cf makefile.mms makefile.vms makvms.opt
OTHERFILES= ansi2knr.c ckconfig.c example.c
TESTFILES= testorig.jpg testimg.ppm testimg.gif testimg.jpg
DISTFILES= $(DOCS) $(MAKEFILES) $(SOURCES) $(SYSDEPFILES) $(INCLUDES) \
$(OTHERFILES) $(TESTFILES)
# objectfiles common to cjpeg and djpeg
COMOBJECTS= jutils.o jvirtmem.o jerror.o
COMOBJECTS= jutils.o jerror.o jmemmgr.o jmemsys.o
# compression objectfiles
CLIBOBJECTS= jcmaster.o jcdeflts.o jcarith.o jccolor.o jcexpand.o jchuff.o \
jcmcu.o jcpipe.o jcsample.o jfwddct.o jwrjfif.o jrdgif.o jrdppm.o \
@ -101,7 +110,7 @@ libjpeg.a: ansi2knr $(LIBOBJECTS)
$(AR2) libjpeg.a
clean:
$(RM) *.o cjpeg djpeg libjpeg.a ansi2knr core tmpansi.* testout.ppm testout.jpg
$(RM) *.o cjpeg djpeg libjpeg.a ansi2knr core tmpansi.* testout.*
distribute:
$(RM) jpegsrc.tar*
@ -109,10 +118,12 @@ distribute:
compress -v jpegsrc.tar
test: cjpeg djpeg
$(RM) testout.ppm testout.jpg
$(RM) testout.ppm testout.gif testout.jpg
./djpeg testorig.jpg >testout.ppm
./djpeg -G testorig.jpg >testout.gif
./cjpeg testimg.ppm >testout.jpg
cmp testimg.ppm testout.ppm
cmp testimg.gif testout.gif
cmp testimg.jpg testout.jpg
@ -142,7 +153,7 @@ jquant2.o : jquant2.c jinclude.h jconfig.h jpegdata.h
jfwddct.o : jfwddct.c jinclude.h jconfig.h jpegdata.h
jrevdct.o : jrevdct.c jinclude.h jconfig.h jpegdata.h
jutils.o : jutils.c jinclude.h jconfig.h jpegdata.h
jvirtmem.o : jvirtmem.c jinclude.h jconfig.h jpegdata.h
jmemmgr.o : jmemmgr.c jinclude.h jconfig.h jpegdata.h jmemsys.h
jrdjfif.o : jrdjfif.c jinclude.h jconfig.h jpegdata.h
jrdgif.o : jrdgif.c jinclude.h jconfig.h jpegdata.h
jrdppm.o : jrdppm.c jinclude.h jconfig.h jpegdata.h
@ -153,3 +164,4 @@ jwrgif.o : jwrgif.c jinclude.h jconfig.h jpegdata.h
jwrppm.o : jwrppm.c jinclude.h jconfig.h jpegdata.h
jwrrle.o : jwrrle.c jinclude.h jconfig.h jpegdata.h
jwrtarga.o : jwrtarga.c jinclude.h jconfig.h jpegdata.h
jmemsys.o : jmemsys.c jinclude.h jconfig.h jpegdata.h jmemsys.h

64
makefile.vms Normal file
View File

@ -0,0 +1,64 @@
$! Makefile for Independent JPEG Group's software
$!
$! This is a command procedure for use on VAX/VMS systems that do not have MMS.
$! It builds the JPEG software by brute force, recompiling everything whether
$! or not it is necessary.
$! Thanks to Rick Dyson (dyson@iowasp.physics.uiowa.edu) for his help.
$!
$! Read SETUP instructions before running this!!
$!
$ DoCompile := CC /NoDebug /Optimize /Define = (TWO_FILE_COMMANDLINE,HAVE_STDC,INCLUDES_ARE_ANSI)
$!
$ DoCompile jcmain.c
$ DoCompile jdmain.c
$ DoCompile jcmaster.c
$ DoCompile jcdeflts.c
$ DoCompile jcarith.c
$ DoCompile jccolor.c
$ DoCompile jcexpand.c
$ DoCompile jchuff.c
$ DoCompile jcmcu.c
$ DoCompile jcpipe.c
$ DoCompile jcsample.c
$ DoCompile jfwddct.c
$ DoCompile jwrjfif.c
$ DoCompile jrdgif.c
$ DoCompile jrdppm.c
$ DoCompile jrdrle.c
$ DoCompile jrdtarga.c
$ DoCompile jdmaster.c
$ DoCompile jddeflts.c
$ DoCompile jbsmooth.c
$ DoCompile jdarith.c
$ DoCompile jdcolor.c
$ DoCompile jdhuff.c
$ DoCompile jdmcu.c
$ DoCompile jdpipe.c
$ DoCompile jdsample.c
$ DoCompile jquant1.c
$ DoCompile jquant2.c
$ DoCompile jrevdct.c
$ DoCompile jrdjfif.c
$ DoCompile jwrgif.c
$ DoCompile jwrppm.c
$ DoCompile jwrrle.c
$ DoCompile jwrtarga.c
$ DoCompile jutils.c
$ DoCompile jerror.c
$ DoCompile jmemmgr.c
$ DoCompile jmemsys.c
$!
$ Library /Create libjpeg.olb jcmaster.obj,jcdeflts.obj,jcarith.obj, -
jccolor.obj,jcexpand.obj,jchuff.obj,jcmcu.obj,jcpipe.obj, -
jcsample.obj,jfwddct.obj,jwrjfif.obj,jrdgif.obj,jrdppm.obj, -
jrdrle.obj,jrdtarga.obj,jdmaster.obj,jddeflts.obj,jbsmooth.obj, -
jdarith.obj,jdcolor.obj,jdhuff.obj,jdmcu.obj,jdpipe.obj, -
jdsample.obj,jquant1.obj,jquant2.obj,jrevdct.obj,jrdjfif.obj, -
jwrgif.obj,jwrppm.obj,jwrrle.obj,jwrtarga.obj,jutils.obj, -
jerror.obj,jmemmgr.obj,jmemsys.obj
$!
$ Link /Executable = cjpeg.exe jcmain.obj,libjpeg.olb/Library,Sys$Disk:[]MAKVMS.OPT/Option
$!
$ Link /Executable = djpeg.exe jdmain.obj,libjpeg.olb/Library,Sys$Disk:[]MAKVMS.OPT/Option
$!
$ Exit

View File

@ -3,4 +3,5 @@ jcmcu.mix,jcpipe.mix,jcsample.mix,jfwddct.mix,jwrjfif.mix,jrdgif.mix
jrdppm.mix,jrdrle.mix,jrdtarga.mix,jdmaster.mix,jddeflts.mix,jbsmooth.mix
jdarith.mix,jdcolor.mix,jdhuff.mix,jdmcu.mix,jdpipe.mix,jdsample.mix
jquant1.mix,jquant2.mix,jrevdct.mix,jrdjfif.mix,jwrgif.mix,jwrppm.mix
jwrrle.mix,jwrtarga.mix,jutils.mix,jvirtmem.mix,jerror.mix
jwrrle.mix,jwrtarga.mix,jutils.mix,jerror.mix,jmemmgr.mix,jmemsys.mix
jmemdosa.mix

3
makvms.opt Normal file
View File

@ -0,0 +1,3 @@
! a pointer to the VAX/VMS C Run-Time Shareable Library
! This file is needed by makefile.mms and makefile.vms
Sys$Library:VAXCRTL.EXE /Share

BIN
testimg.gif Normal file

Binary file not shown.

After

Width:  |  Height:  |  Size: 15 KiB

Binary file not shown.

Before

Width:  |  Height:  |  Size: 4.3 KiB

After

Width:  |  Height:  |  Size: 4.3 KiB

Binary file not shown.

Binary file not shown.

Before

Width:  |  Height:  |  Size: 4.3 KiB

After

Width:  |  Height:  |  Size: 4.3 KiB