The Independent JPEG Group's JPEG software v3
This commit is contained in:
parent
bd543f030e
commit
4a6b730364
40
CHANGELOG
40
CHANGELOG
@ -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
119
README
@ -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
229
SETUP
@ -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
140
USAGE
@ -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.
|
||||
|
176
architecture
176
architecture
@ -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
18
cjpeg.1
@ -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
|
||||
|
@ -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
82
djpeg.1
@ -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
624
example.c
Normal 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.
|
||||
*/
|
||||
}
|
@ -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;
|
||||
|
@ -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.
|
||||
*
|
||||
|
47
jccolor.c
47
jccolor.c
@ -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;
|
||||
|
76
jcdeflts.c
76
jcdeflts.c
@ -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]);
|
||||
}
|
||||
}
|
||||
|
@ -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.
|
||||
*
|
||||
|
54
jchuff.c
54
jchuff.c
@ -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
|
||||
}
|
||||
}
|
||||
|
92
jcmain.c
92
jcmain.c
@ -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 */
|
||||
}
|
||||
|
@ -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? */
|
||||
}
|
||||
|
2
jcmcu.c
2
jcmcu.c
@ -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.
|
||||
*
|
||||
|
71
jconfig.h
71
jconfig.h
@ -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
|
||||
|
||||
|
47
jcpipe.c
47
jcpipe.c
@ -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 */
|
||||
|
@ -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.
|
||||
*
|
||||
|
@ -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
198
jdcolor.c
@ -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;
|
||||
}
|
||||
|
119
jddeflts.c
119
jddeflts.c
@ -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;
|
||||
}
|
||||
|
30
jdhuff.c
30
jdhuff.c
@ -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);
|
||||
|
96
jdmain.c
96
jdmain.c
@ -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 */
|
||||
}
|
||||
|
43
jdmaster.c
43
jdmaster.c
@ -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
81
jdmcu.c
@ -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
684
jdpipe.c
@ -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
|
||||
|
115
jdsample.c
115
jdsample.c
@ -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");
|
||||
}
|
||||
|
19
jerror.c
19
jerror.c
@ -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
166
jfwddct.c
@ -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;
|
||||
}
|
||||
}
|
||||
|
@ -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
157
jmemansi.c
Normal 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
608
jmemdos.c
Normal 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
135
jmemdos.h
Normal 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
379
jmemdosa.asm
Normal 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
|
248
jmemname.c
Normal file
248
jmemname.c
Normal 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
96
jmemnobs.c
Normal 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
127
jmemsys.h
Normal 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));
|
105
jpegdata.h
105
jpegdata.h
@ -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
506
jquant1.c
@ -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!");
|
||||
}
|
||||
|
18
jrdgif.c
18
jrdgif.c
@ -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) */
|
||||
}
|
||||
|
||||
|
||||
|
42
jrdjfif.c
42
jrdjfif.c
@ -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);
|
||||
|
5
jrdppm.c
5
jrdppm.c
@ -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) */
|
||||
}
|
||||
|
||||
|
||||
|
20
jrdrle.c
20
jrdrle.c
@ -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) */
|
||||
}
|
||||
|
||||
|
||||
|
47
jrdtarga.c
47
jrdtarga.c
@ -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
186
jrevdct.c
@ -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;
|
||||
}
|
||||
}
|
||||
|
14
jutils.c
14
jutils.c
@ -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,
|
||||
|
@ -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"
|
||||
|
614
jvirtmem.c
614
jvirtmem.c
@ -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;
|
||||
}
|
61
jwrgif.c
61
jwrgif.c
@ -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) */
|
||||
}
|
||||
|
||||
|
||||
|
@ -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);
|
||||
|
11
jwrppm.c
11
jwrppm.c
@ -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;
|
||||
}
|
||||
|
||||
|
13
jwrrle.c
13
jwrrle.c
@ -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) */
|
||||
}
|
||||
|
||||
|
||||
|
13
jwrtarga.c
13
jwrtarga.c
@ -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;
|
||||
}
|
||||
}
|
||||
|
@ -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,
|
||||
|
@ -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
|
||||
|
||||
|
@ -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
|
||||
|
@ -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,
|
||||
|
@ -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
|
||||
|
||||
|
@ -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
|
||||
|
@ -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
139
makefile.bcc
Normal 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
|
@ -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
|
||||
|
37
makefile.mc5
37
makefile.mc5
@ -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)
|
||||
|
50
makefile.mc6
50
makefile.mc6
@ -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
134
makefile.mms
Normal 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
|
29
makefile.pwc
29
makefile.pwc
@ -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
|
||||
|
41
makefile.sas
41
makefile.sas
@ -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
|
||||
|
113
makefile.tc
113
makefile.tc
@ -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
|
@ -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
64
makefile.vms
Normal 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
|
@ -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
3
makvms.opt
Normal 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
BIN
testimg.gif
Normal file
Binary file not shown.
After Width: | Height: | Size: 15 KiB |
BIN
testimg.jpg
BIN
testimg.jpg
Binary file not shown.
Before Width: | Height: | Size: 4.3 KiB After Width: | Height: | Size: 4.3 KiB |
BIN
testimg.ppm
BIN
testimg.ppm
Binary file not shown.
BIN
testorig.jpg
BIN
testorig.jpg
Binary file not shown.
Before Width: | Height: | Size: 4.3 KiB After Width: | Height: | Size: 4.3 KiB |
Loading…
Reference in New Issue
Block a user