[freeimage] 44/47: Imported Debian patch 3.15.4-4.1
Ghislain Vaillant
ghisvail-guest at moszumanska.debian.org
Sat Sep 26 22:27:35 UTC 2015
This is an automated email from the git hooks/post-receive script.
ghisvail-guest pushed a commit to branch master
in repository freeimage.
commit 86f238c7583331acc3cf6ab09b58bd8a86e30999
Author: Ondřej Surý <ondrej at debian.org>
Date: Mon Oct 6 11:29:52 2014 +0200
Imported Debian patch 3.15.4-4.1
---
.gitignore | 1 -
Dist/delete.me | 0
debian/changelog | 25 +
debian/copyright | 526 ++---
.../patches/build_using_libjpeg62_transupp.c.patch | 2005 ++++++++++++++++++++
debian/patches/disable_embedded_libraries.patch | 116 +-
debian/patches/fix-big-endian-detection.patch | 48 +
debian/patches/fix_ftbfs_amd64.patch | 16 +-
debian/patches/makefile_modifications.patch | 22 +-
debian/patches/series | 2 +
debian/patches/tag_truncation.patch | 8 +-
11 files changed, 2467 insertions(+), 302 deletions(-)
diff --git a/.gitignore b/.gitignore
deleted file mode 100644
index 845ca06..0000000
--- a/.gitignore
+++ /dev/null
@@ -1 +0,0 @@
-.pc
diff --git a/Dist/delete.me b/Dist/delete.me
new file mode 100644
index 0000000..e69de29
diff --git a/debian/changelog b/debian/changelog
index a134c58..2c3b764 100644
--- a/debian/changelog
+++ b/debian/changelog
@@ -1,3 +1,28 @@
+freeimage (3.15.4-4.1) unstable; urgency=medium
+
+ * Non-maintainer upload
+ * Remove libjpeg8-dev from Build-Depends
+ * Add compatibility transupp.c from src:libjpeg-turbo and use that
+ to compile against libjpeg62 (Closes: #763255)
+ * Make d/copyright machine readable and add jpeg/* and Source/LibJPEG/*
+ license
+
+ -- Ondřej Surý <ondrej at debian.org> Mon, 06 Oct 2014 11:29:52 +0200
+
+freeimage (3.15.4-4) unstable; urgency=medium
+
+ * QA upload.
+ * Build-depend on libjpeg8-dev.
+ Patch by Dejan Latinovic <Dejan.Latinovic at imgtec.com>.
+ Closes: #763255.
+ * Improve big endian detection.
+ Add fix-big-endian-detection.patch.
+ Patch by Dejan Latinovic <Dejan.Latinovic at imgtec.com>.
+ Closes: #763730.
+ * Refresh patches
+
+ -- Anibal Monsalve Salazar <anibal at debian.org> Thu, 02 Oct 2014 10:18:47 +0100
+
freeimage (3.15.4-3) unstable; urgency=low
* QA upload.
diff --git a/debian/copyright b/debian/copyright
index 5265a7f..2481d75 100644
--- a/debian/copyright
+++ b/debian/copyright
@@ -1,215 +1,198 @@
-This package was debianized by:
-
- Federico Di Gregorio <fog at debian.org> on Sat, 21 Apr 2007 09:36:44 +0200.
-
-It was downloaded from:
-
- http://freeimage.sourceforge.net/
-
-Upstream Author:
-
- Hervé Drolon at drolon at infonie.fr
- Floris van den Berg at flvdberg at wxs.nl
-
-Copyright:
-
- Copyright (C) 2003-2007 FreeImage Group
-
- FreeImage is currently maintained by Harvé Drolon.
-
- FreeImage is licensed under the GNU General Public License (GPL)
- and the FreeImage Public License (FIPL). You can choose the license
- that has the most advantages for you.
-
-License (FIPL):
-
-1. Definitions.
-
-1.1. "Contributor" means each entity that creates or contributes to the
-creation of Modifications.
-
-1.2. "Contributor Version" means the combination of the Original Code, prior
-Modifications used by a Contributor, and the Modifications made by that
-particular Contributor.
-
-1.3. "Covered Code" means the Original Code or Modifications or the combination
-of the Original Code and Modifications, in each case including portions
-thereof.
-
-1.4. "Electronic Distribution Mechanism" means a mechanism generally accepted
-in the software development community for the electronic transfer of data.
-
-1.5. "Executable" means Covered Code in any form other than Source Code.
-
-1.6. "Initial Developer" means the individual or entity identified as the
-Initial Developer in the Source Code notice required by Exhibit A.
-
-1.7. "Larger Work" means a work which combines Covered Code or portions thereof
-with code not governed by the terms of this License.
-
-1.8. "License" means this document.
-
-1.9. "Modifications" means any addition to or deletion from the substance or
-structure of either the Original Code or any previous Modifications. When
-Covered Code is released as a series of files, a Modification is:
-
-A. Any addition to or deletion from the contents of a file containing Original
-Code or previous Modifications.
-
-B. Any new file that contains any part of the Original Code or previous
-Modifications.
-
-1.10. "Original Code" means Source Code of computer software code which is
-described in the Source Code notice required by Exhibit A as Original Code,
-and which, at the time of its release under this License is not already
-Covered Code governed by this License.
-
-1.11. "Source Code" means the preferred form of the Covered Code for making
-modifications to it, including all modules it contains, plus any associated interface definition files, scripts used to control
-compilation and installation of an Executable, or a list of source code differential comparisons against either the Original Code or another well known, available Covered Code of the Contributor's choice. The Source Code can be in a compressed or archival form, provided the appropriate decompression or de-archiving software is widely available for no charge.
-
-1.12. "You" means an individual or a legal entity exercising rights under, and complying with all of the terms of, this License or a future version of this License issued under Section 6.1. For legal entities, "You" includes any entity which controls, is controlled by, or is under common control with You. For purposes of this definition, "control" means (a) the power, direct or indirect, to cause the
-direction or management of such entity, whether by contract or otherwise, or (b) ownership of fifty percent (50%) or more of the outstanding shares or beneficial ownership of such entity.
-
-2. Source Code License.
-
-2.1. The Initial Developer Grant.
-The Initial Developer hereby grants You a world-wide, royalty-free, non-exclusive license, subject to third party intellectual property claims:
-
-(a) to use, reproduce, modify, display, perform, sublicense and distribute the Original Code (or portions thereof) with or without Modifications, or as part of a Larger Work; and
-
-(b) under patents now or hereafter owned or controlled by Initial Developer, to make, have made, use and sell ("Utilize") the Original Code (or portions thereof), but solely to the extent that
-any such patent is reasonably necessary to enable You to Utilize the Original Code (or portions thereof) and not to any greater extent that may be necessary to Utilize further Modifications or
-combinations.
-
-2.2. Contributor Grant.
-Each Contributor hereby grants You a world-wide, royalty-free, non-exclusive license, subject to third party intellectual property claims:
-
-(a) to use, reproduce, modify, display, perform, sublicense and distribute the Modifications created by such Contributor (or portions thereof) either on an unmodified basis, with other Modifications, as Covered Code or as part of a Larger Work; and
-
-(b) under patents now or hereafter owned or controlled by Contributor, to Utilize the Contributor Version (or portions thereof), but solely to the extent that any such patent is reasonably necessary to enable You to Utilize the Contributor Version (or portions thereof), and not to any greater extent that
-may be necessary to Utilize further Modifications or combinations.
-
-3. Distribution Obligations.
-
-3.1. Application of License.
-The Modifications which You create or to which You contribute are governed by the terms of this License, including without limitation Section 2.2. The Source Code version of Covered Code may be distributed only under the terms of this License or a future version of this License released under Section 6.1, and You must include a copy of this License with every copy of the Source Code You distribute. You may not offer or impose any terms on any Source Code version that alters or
-restricts the applicable version of this License or the recipients' rights hereunder. However, You may include an additional document offering the additional rights described in Section 3.5.
-
-3.2. Availability of Source Code.
-Any Modification which You create or to which You contribute must be made available in Source Code form under the terms of this License either on the same media as an Executable version or via an accepted Electronic Distribution Mechanism to anyone to whom you made an Executable version available; and if made available via Electronic Distribution Mechanism, must remain available for at least twelve (12) months after the date it initially became available, or at least six (6) months after [...]
-
-3.3. Description of Modifications.
-You must cause all Covered Code to which you contribute to contain a file documenting the changes You made to create that Covered Code and the date of any change. You must include a prominent statement that the Modification is derived, directly or indirectly, from Original Code provided by the Initial Developer and including the name of the Initial Developer in (a) the Source Code, and (b) in any notice in an Executable version or related documentation in which You describe the origin or [...]
-
-3.4. Intellectual Property Matters
-
-(a) Third Party Claims.
-If You have knowledge that a party claims an intellectual property right in particular functionality or code (or its utilization under this License), you must include a text file with the source code distribution titled "LEGAL" which describes the claim and the party making the claim in sufficient detail that a recipient will know whom to contact. If you obtain such knowledge after You make Your Modification available as described in Section 3.2, You shall promptly modify the LEGAL file [...]
-available thereafter and shall take other steps (such as notifying appropriate mailing lists or newsgroups) reasonably calculated to inform those who received the Covered Code that new knowledge has been obtained.
-
-(b) Contributor APIs.
-If Your Modification is an application programming interface and You own or control patents which are reasonably necessary to implement that API, you must also include this information in the LEGAL file.
-
-3.5. Required Notices.
-You must duplicate the notice in Exhibit A in each file of the Source Code, and this License in any documentation for the Source Code, where You describe recipients' rights relating to Covered Code. If You created one or more Modification(s), You may add your name as a Contributor to the notice described in Exhibit A. If it is not possible to put such notice in a particular Source Code file due to its
-structure, then you must include such notice in a location (such as a relevant directory file) where a user would be likely to look for such a notice. You may choose to offer, and to charge a fee for, warranty, support, indemnity or liability obligations to one or more recipients of Covered Code. However, You may do so only on Your own behalf, and not on behalf of the Initial Developer or any Contributor. You must make it absolutely clear than any such warranty, support, indemnity or
-liability obligation is offered by You alone, and You hereby agree to indemnify the Initial Developer and every Contributor for any liability incurred by the Initial Developer or such Contributor as a result of
-warranty, support, indemnity or liability terms You offer.
-
-3.6. Distribution of Executable Versions.
-You may distribute Covered Code in Executable form only if the requirements of Section 3.1-3.5 have been met for that Covered Code, and if You include a notice stating that the Source Code version of the Covered Code is available under the terms of this License, including a description of how and where You have fulfilled the obligations of Section 3.2. The notice must be conspicuously included in any notice in an Executable version, related documentation or collateral in which You
-describe recipients' rights relating to the Covered Code. You may distribute the Executable version of Covered Code under a license of Your choice, which may contain terms different from this License,
-provided that You are in compliance with the terms of this License and that the license for the Executable version does not attempt to limit or alter the recipient's rights in the Source Code version from the rights set forth in this License. If You distribute the Executable version under a different license You must make it absolutely clear that any terms which differ from this License are offered by You alone, not by the Initial Developer or any Contributor. You hereby agree to indemni [...]
-
-3.7. Larger Works.
-You may create a Larger Work by combining Covered Code with other code not governed by the terms of this License and distribute the Larger Work as a single product. In such a case, You must make sure the requirements of this License are fulfilled for the Covered Code.
-
-4. Inability to Comply Due to Statute or Regulation.
-
-If it is impossible for You to comply with any of the terms of this License with respect to some or all of the Covered Code due to statute or regulation then You must: (a) comply with the terms of this License to the maximum extent possible; and (b) describe the limitations and the code they affect. Such description must be included in the LEGAL file described in Section 3.4 and must be included with all distributions of the Source Code. Except to the extent prohibited by statute or regu [...]
-
-5. Application of this License.
-
-This License applies to code to which the Initial Developer has attached the notice in Exhibit A, and to related Covered Code.
-
-6. Versions of the License.
-
-6.1. New Versions.
-Floris van den Berg may publish revised and/or new versions of the License from time to time. Each version will be given a distinguishing version number.
-
-6.2. Effect of New Versions.
-Once Covered Code has been published under a particular version of the License, You may always continue to use it under the terms of that version. You may also choose to use such Covered Code under the terms of any subsequent version of the License published by Floris van den Berg
-No one other than Floris van den Berg has the right to modify the terms applicable to Covered Code created under this License.
-
-6.3. Derivative Works.
-If you create or use a modified version of this License (which you may only do in order to apply it to code which is not already Covered Code governed by this License), you must (a) rename Your license so that the phrases "FreeImage", `FreeImage Public License", "FIPL", or any confusingly similar phrase do not appear anywhere in your license and (b) otherwise make it clear that your version of the license contains terms which differ from the FreeImage Public License. (Filling in the name [...]
-
-7. DISCLAIMER OF WARRANTY.
-
-COVERED CODE IS PROVIDED UNDER THIS LICENSE ON AN "AS IS" BASIS, WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, WITHOUT LIMITATION, WARRANTIES THAT THE COVERED CODE IS FREE OF DEFECTS, MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE OR NON-INFRINGING. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE COVERED CODE IS WITH YOU. SHOULD ANY COVERED CODE PROVE DEFECTIVE IN ANY RESPECT, YOU (NOT THE INITIAL DEVELOPER OR ANY OTHER CONTRIBUTOR) ASSUME THE COST OF ANY NEC [...]
-
-8. TERMINATION.
-
-This License and the rights granted hereunder will terminate automatically if You fail to comply with terms herein and fail to cure such breach within 30 days of becoming aware of the breach. All sublicenses to the Covered Code which are properly granted shall survive any termination of this License. Provisions which, by their nature, must remain in effect beyond the termination of this License shall survive.
-
-9. LIMITATION OF LIABILITY.
-
-UNDER NO CIRCUMSTANCES AND UNDER NO LEGAL THEORY, WHETHER TORT (INCLUDING NEGLIGENCE), CONTRACT, OR OTHERWISE, SHALL THE INITIAL DEVELOPER, ANY OTHER CONTRIBUTOR, OR ANY DISTRIBUTOR OF COVERED CODE, OR ANY SUPPLIER OF ANY OF SUCH PARTIES, BE LIABLE TO YOU OR ANY OTHER PERSON FOR ANY INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES OF ANY CHARACTER INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF GOODWILL, WORK STOPPAGE, COMPUTER FAILURE OR MALFUNCTION, OR ANY AND ALL OTHER COMME [...]
-EXCLUSION OR LIMITATION OF INCIDENTAL OR CONSEQUENTIAL DAMAGES, SO THAT EXCLUSION AND LIMITATION MAY NOT APPLY TO YOU.
-
-10. U.S. GOVERNMENT END USERS.
-
-The Covered Code is a "commercial item," as that term is defined in 48 C.F.R. 2.101 (Oct. 1995), consisting of "commercial computer software" and "commercial computer software documentation," as such terms are used in 48 C.F.R. 12.212 (Sept. 1995). Consistent with 48 C.F.R. 12.212 and 48 C.F.R. 227.7202-1 through 227.7202-4 (June 1995), all U.S. Government End Users acquire Covered Code with only those rights set forth herein.
-
-11. MISCELLANEOUS.
-
-This License represents the complete agreement concerning subject matter hereof. If any provision of this License is held to be unenforceable, such provision shall be reformed only to the extent necessary to make it enforceable. This License shall be governed by Dutch law provisions (except to the extent applicable law, if any, provides otherwise), excluding its conflict-of-law provisions. With respect to disputes in which at least one party is a citizen of, or an entity chartered or reg [...]
-
-12. RESPONSIBILITY FOR CLAIMS.
-
-Except in cases where another Contributor has failed to comply with Section 3.4, You are responsible for damages arising, directly or indirectly, out of Your utilization of rights under this License, based
-on the number of copies of Covered Code you made available, the revenues you received from utilizing such rights, and other relevant factors. You agree to work with affected parties to distribute
-responsibility on an equitable basis.
-
-EXHIBIT A.
-
-"The contents of this file are subject to the FreeImage Public License Version 1.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://home.wxs.nl/~flvdberg/freeimage-license.txt
-
-Software distributed under the License is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License for the specific language governing rights and limitations under the License.
-
-License (GPL):
-
- This package is free software; you can redistribute it and/or modify
- it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2 of the License, or
- (at your option) any later version.
-
- This package is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- GNU General Public License for more details.
-
- You should have received a copy of the GNU General Public License
- along with this package; if not, write to the Free Software
- Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
-
-On Debian systems, the complete text of the GNU General
-Public License can be found in `/usr/share/common-licenses/GPL-2'.
-
-freeimage embeds a copy of libtiff, whose copyright and license are:
- Copyright (C) 1988-1997 Sam Leffler
- Copyright (C) 1991-1997 Silicon Graphics, Inc.
- Portions Copyright (C) 1985-1987, 1990 Regents of the University of California
- Portions Copyright (C) 1990, 1991 Digital Equipment Corporation
- Portions Copyright (C) 1990 Sun Microsystems, Inc.
- Portions Copyright (C) 1990, 1995 Frank D. Cringle
- Portions Copyright (C) 1996 BancTec AB
- Portions Copyright (C) 1996 Mike Johnson
- Portions Copyright (C) 1996 Pixar
- Portions Copyright (C) 1997 Greg Ward Larson
- Portions Copyright (C) 2000 Frank Warmerdam
-
+Format: http://www.debian.org/doc/packaging-manuals/copyright-format/1.0/
+Upstream-Name: freeimage
+Source: http://freeimage.sourceforge.net/
+
+Files: *
+Copyright: 2003-2007 FreeImage Group
+License: GPL or FIPL
+
+License: FIPL
+ 1. Definitions.
+ .
+ 1.1. "Contributor" means each entity that creates or contributes to the
+ creation of Modifications.
+ .
+ 1.2. "Contributor Version" means the combination of the Original Code, prior
+ Modifications used by a Contributor, and the Modifications made by that
+ particular Contributor.
+ .
+ 1.3. "Covered Code" means the Original Code or Modifications or the combination
+ of the Original Code and Modifications, in each case including portions
+ thereof.
+ .
+ 1.4. "Electronic Distribution Mechanism" means a mechanism generally accepted
+ in the software development community for the electronic transfer of data.
+ .
+ 1.5. "Executable" means Covered Code in any form other than Source Code.
+ .
+ 1.6. "Initial Developer" means the individual or entity identified as the
+ Initial Developer in the Source Code notice required by Exhibit A.
+ .
+ 1.7. "Larger Work" means a work which combines Covered Code or portions thereof
+ with code not governed by the terms of this License.
+ .
+ 1.8. "License" means this document.
+ .
+ 1.9. "Modifications" means any addition to or deletion from the substance or
+ structure of either the Original Code or any previous Modifications. When
+ Covered Code is released as a series of files, a Modification is:
+ .
+ A. Any addition to or deletion from the contents of a file containing Original
+ Code or previous Modifications.
+ .
+ B. Any new file that contains any part of the Original Code or previous
+ Modifications.
+ .
+ 1.10. "Original Code" means Source Code of computer software code which is
+ described in the Source Code notice required by Exhibit A as Original Code,
+ and which, at the time of its release under this License is not already
+ Covered Code governed by this License.
+ .
+ 1.11. "Source Code" means the preferred form of the Covered Code for making
+ modifications to it, including all modules it contains, plus any associated interface definition files, scripts used to control
+ compilation and installation of an Executable, or a list of source code differential comparisons against either the Original Code or another well known, available Covered Code of the Contr ibutor's choice. The Source Code can be in a compressed or archival form, provided the appropriate decompression or de-archiving software is widely available for no charge.
+ .
+ 1.12. "You" means an individual or a legal entity exercising rights under, and complying with all of the terms of, this License or a future version of this License issued under Section 6.1 . For legal entities, "You" includes any entity which controls, is controlled by, or is under common control with You. For purposes of this definition, "control" means (a) the power, direc t or indirect, to cause the
+ direction or management of such entity, whether by contract or otherwise, or (b) ownership of fifty percent (50%) or more of the outstanding shares or beneficial ownership of such entity.
+ .
+ 2. Source Code License.
+ .
+ 2.1. The Initial Developer Grant.
+ The Initial Developer hereby grants You a world-wide, royalty-free, non-exclusive license, subject to third party intellectual property claims:
+ .
+ (a) to use, reproduce, modify, display, perform, sublicense and distribute the Original Code (or portions thereof) with or without Modifications, or as part of a Larger Work; and
+ .
+ (b) under patents now or hereafter owned or controlled by Initial Developer, to make, have made, use and sell ("Utilize") the Original Code (or portions thereof), but solely to the extent that
+ any such patent is reasonably necessary to enable You to Utilize the Original Code (or portions thereof) and not to any greater extent that may be necessary to Utilize further Modification s or
+ combinations.
+ .
+ 2.2. Contributor Grant.
+ Each Contributor hereby grants You a world-wide, royalty-free, non-exclusive license, subject to third party intellectual property claims:
+ .
+ (a) to use, reproduce, modify, display, perform, sublicense and distribute the Modifications created by such Contributor (or portions thereof) either on an unmodified basis, with other Mod ifications, as Covered Code or as part of a Larger Work; and
+ .
+ (b) under patents now or hereafter owned or controlled by Contributor, to Utilize the Contributor Version (or portions thereof), but solely to the extent that any such patent is reasonably necessary to enable You to Utilize the Contributor Version (or portions thereof), and not to any greater extent that
+ may be necessary to Utilize further Modifications or combinations.
+ .
+ 3. Distribution Obligations.
+ .
+ 3.1. Application of License.
+ The Modifications which You create or to which You contribute are governed by the terms of this License, including without limitation Section 2.2. The Source Code version of Covered Code m ay be distributed only under the terms of this License or a future version of this License released under Section 6.1, and You must include a copy of this License with every copy of the So urce Code You distribute. You may not offer or impose any terms on any Source Code version that alters or
+ restricts the applicable version of this License or the recipients' rights hereunder. However, You may include an additional document offering the additional rights described in Section 3. 5.
+ .
+ 3.2. Availability of Source Code.
+ Any Modification which You create or to which You contribute must be made available in Source Code form under the terms of this License either on the same media as an Executable version or via an accepted Electronic Distribution Mechanism to anyone to whom you made an Executable version available; and if made available via Electronic Distribution Mechanism, must remain avai lable for at least twelve (12) months after the date it initially became available, or at least six (6) months af [...]
+ .
+ 3.3. Description of Modifications.
+ You must cause all Covered Code to which you contribute to contain a file documenting the changes You made to create that Covered Code and the date of any change. You must include a promin ent statement that the Modification is derived, directly or indirectly, from Original Code provided by the Initial Developer and including the name of the Initial Developer in (a) the Sour ce Code, and (b) in any notice in an Executable version or related documentation in which You describe the origin [...]
+ .
+ 3.4. Intellectual Property Matters
+ .
+ (a) Third Party Claims.
+ If You have knowledge that a party claims an intellectual property right in particular functionality or code (or its utilization under this License), you must include a text file with the source code distribution titled "LEGAL" which describes the claim and the party making the claim in sufficient detail that a recipient will know whom to contact. If you obtain such knowled ge after You make Your Modification available as described in Section 3.2, You shall promptly modify the LEGAL fi [...]
+ available thereafter and shall take other steps (such as notifying appropriate mailing lists or newsgroups) reasonably calculated to inform those who received the Covered Code that new kno wledge has been obtained.
+ .
+ (b) Contributor APIs.
+ If Your Modification is an application programming interface and You own or control patents which are reasonably necessary to implement that API, you must also include this information in the LEGAL file.
+ .
+ 3.5. Required Notices.
+ You must duplicate the notice in Exhibit A in each file of the Source Code, and this License in any documentation for the Source Code, where You describe recipients' rights relating to Cov ered Code. If You created one or more Modification(s), You may add your name as a Contributor to the notice described in Exhibit A. If it is not possible to put such notice in a particular Source Code file due to its
+ structure, then you must include such notice in a location (such as a relevant directory file) where a user would be likely to look for such a notice. You may choose to offer, and to charg e a fee for, warranty, support, indemnity or liability obligations to one or more recipients of Covered Code. However, You may do so only on Your own behalf, and not on behalf of the Initi al Developer or any Contributor. You must make it absolutely clear than any such warranty, support, indemnity or
+ liability obligation is offered by You alone, and You hereby agree to indemnify the Initial Developer and every Contributor for any liability incurred by the Initial Developer or such Cont ributor as a result of
+ warranty, support, indemnity or liability terms You offer.
+ .
+ 3.6. Distribution of Executable Versions.
+ You may distribute Covered Code in Executable form only if the requirements of Section 3.1-3.5 have been met for that Covered Code, and if You include a notice stating that the Source Code version of the Covered Code is available under the terms of this License, including a description of how and where You have fulfilled the obligations of Section 3.2. The notice must be co nspicuously included in any notice in an Executable version, related documentation or collateral in which You
+ describe recipients' rights relating to the Covered Code. You may distribute the Executable version of Covered Code under a license of Your choice, which may contain terms different from t his License,
+ provided that You are in compliance with the terms of this License and that the license for the Executable version does not attempt to limit or alter the recipient's rights in the Source C ode version from the rights set forth in this License. If You distribute the Executable version under a different license You must make it absolutely clear that any terms which differ from this License are offered by You alone, not by the Initial Developer or any Contributor. You hereby agree to inde [...]
+ .
+ 3.7. Larger Works.
+ You may create a Larger Work by combining Covered Code with other code not governed by the terms of this License and distribute the Larger Work as a single product. In such a case, You mus t make sure the requirements of this License are fulfilled for the Covered Code.
+ .
+ 4. Inability to Comply Due to Statute or Regulation.
+ .
+ If it is impossible for You to comply with any of the terms of this License with respect to some or all of the Covered Code due to statute or regulation then You must: (a) comply with the terms of this License to the maximum extent possible; and (b) describe the limitations and the code they affect. Such description must be included in the LEGAL file described in Section 3. 4 and must be included with all distributions of the Source Code. Except to the extent prohibited by statute or r [...]
+ .
+ 5. Application of this License.
+ .
+ This License applies to code to which the Initial Developer has attached the notice in Exhibit A, and to related Covered Code.
+ .
+ 6. Versions of the License.
+ .
+ 6.1. New Versions.
+ Floris van den Berg may publish revised and/or new versions of the License from time to time. Each version will be given a distinguishing version number.
+ .
+ 6.2. Effect of New Versions.
+ Once Covered Code has been published under a particular version of the License, You may always continue to use it under the terms of that version. You may also choose to use such Covered C ode under the terms of any subsequent version of the License published by Floris van den Berg
+ No one other than Floris van den Berg has the right to modify the terms applicable to Covered Code created under this License.
+ .
+ 6.3. Derivative Works.
+ If you create or use a modified version of this License (which you may only do in order to apply it to code which is not already Covered Code governed by this License), you must (a) rename Your license so that the phrases "FreeImage", `FreeImage Public License", "FIPL", or any confusingly similar phrase do not appear anywhere in your license and (b) otherwise make it clear that your version of the license contains terms which differ from the FreeImage Public License. (Filling in the n [...]
+ .
+ 7. DISCLAIMER OF WARRANTY.
+ .
+ COVERED CODE IS PROVIDED UNDER THIS LICENSE ON AN "AS IS" BASIS, WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, WITHOUT LIMITATION, WARRANTIES THAT THE COVERED CODE IS FREE OF DEFECTS, MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE OR NON-INFRINGING. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE COVERED CODE IS WITH YOU. SHOULD ANY COVERED CODE PROVE DEFECTIVE IN ANY RESPECT, YOU (NOT THE INITIAL DEVELOPER OR ANY OTHER CONTRIBUTOR) ASSUME THE COST OF ANY [...]
+ .
+ 8. TERMINATION.
+ .
+ This License and the rights granted hereunder will terminate automatically if You fail to comply with terms herein and fail to cure such breach within 30 days of becoming aware of the brea ch. All sublicenses to the Covered Code which are properly granted shall survive any termination of this License. Provisions which, by their nature, must remain in effect beyond the termin ation of this License shall survive.
+ .
+ 9. LIMITATION OF LIABILITY.
+ .
+ UNDER NO CIRCUMSTANCES AND UNDER NO LEGAL THEORY, WHETHER TORT (INCLUDING NEGLIGENCE), CONTRACT, OR OTHERWISE, SHALL THE INITIAL DEVELOPER, ANY OTHER CONTRIBUTOR, OR ANY DISTRIBUTOR OF COV ERED CODE, OR ANY SUPPLIER OF ANY OF SUCH PARTIES, BE LIABLE TO YOU OR ANY OTHER PERSON FOR ANY INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES OF ANY CHARACTER INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF GOODWILL, WORK STOPPAGE, COMPUTER FAILURE OR MALFUNCTION, OR ANY AND ALL OTHER CO [...]
+ EXCLUSION OR LIMITATION OF INCIDENTAL OR CONSEQUENTIAL DAMAGES, SO THAT EXCLUSION AND LIMITATION MAY NOT APPLY TO YOU.
+ .
+ 10. U.S. GOVERNMENT END USERS.
+ .
+ The Covered Code is a "commercial item," as that term is defined in 48 C.F.R. 2.101 (Oct. 1995), consisting of "commercial computer software" and "commercial computer software documentatio n," as such terms are used in 48 C.F.R. 12.212 (Sept. 1995). Consistent with 48 C.F.R. 12.212 and 48 C.F.R. 227.7202-1 through 227.7202-4 (June 1995), all U.S. Government End Users acquire Covered Code with only those rights set forth herein.
+ .
+ 11. MISCELLANEOUS.
+ .
+ This License represents the complete agreement concerning subject matter hereof. If any provision of this License is held to be unenforceable, such provision shall be reformed only to the extent necessary to make it enforceable. This License shall be governed by Dutch law provisions (except to the extent applicable law, if any, provides otherwise), excluding its conflict-of -law provisions. With respect to disputes in which at least one party is a citizen of, or an entity chartered or [...]
+ .
+ 12. RESPONSIBILITY FOR CLAIMS.
+ .
+ Except in cases where another Contributor has failed to comply with Section 3.4, You are responsible for damages arising, directly or indirectly, out of Your utilization of rights under th is License, based
+ on the number of copies of Covered Code you made available, the revenues you received from utilizing such rights, and other relevant factors. You agree to work with affected parties to dis tribute
+ responsibility on an equitable basis.
+ .
+ EXHIBIT A.
+ .
+ "The contents of this file are subject to the FreeImage Public License Version 1.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy o f the License at http://home.wxs.nl/~flvdberg/freeimage-license.txt
+ .
+ Software distributed under the License is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License for the specific language governing righ ts and limitations under the License.
+
+License: GPL-2+
+ This package is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2 of the License, or
+ (at your option) any later version.
+ .
+ This package is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+ .
+ You should have received a copy of the GNU General Public License
+ along with this package; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ .
+ On Debian systems, the complete text of the GNU General
+ Public License can be found in `/usr/share/common-licenses/GPL-2'.
+
+Files: Source/LibTIFF4/*
+Copyright: Copyright (C) 1988-1997 Sam Leffler
+ Copyright (C) 1991-1997 Silicon Graphics, Inc.
+ Portions Copyright (C) 1985-1987, 1990 Regents of the University of California
+ Portions Copyright (C) 1990, 1991 Digital Equipment Corporation
+ Portions Copyright (C) 1990 Sun Microsystems, Inc.
+ Portions Copyright (C) 1990, 1995 Frank D. Cringle
+ Portions Copyright (C) 1996 BancTec AB
+ Portions Copyright (C) 1996 Mike Johnson
+ Portions Copyright (C) 1996 Pixar
+ Portions Copyright (C) 1997 Greg Ward Larson
+ Portions Copyright (C) 2000 Frank Warmerdam
+License:
Permission to use, copy, modify, distribute, and sell this software and
its documentation for any purpose is hereby granted without fee, provided
that (i) the above copyright notices and this permission notice appear in
@@ -229,6 +212,119 @@ freeimage embeds a copy of libtiff, whose copyright and license are:
LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
OF THIS SOFTWARE.
-
-The Debian packaging is Copyright (C) 2007, Federico Di Gregorio
-<fog at debian.org> and is licensed under the GPL, see above.
+Files: jpeg/* Source/LibJPEG/*
+Copyright: 1991-2010 Thomas G. Lane
+ 1991-2011 Guido Vollbeding
+ 1999-2006 MIYASAKA Masaru
+ 2009-2011 D. R. Commander
+ 2009 Pierre Ossman <ossman at cendio.se> for Cendio AB
+ 2009-2011 Nokia Corporation and/or its subsidiary(-ies)
+License: BSD-BY-LC-NE
+
+License: BSD-BY-LC-NE
+ In plain English:
+ .
+ 1. We don't promise that this software works. (But if you find any bugs,
+ please let us know!)
+ 2. You can use this software for whatever you want. You don't have to pay us.
+ 3. You may not pretend that you wrote this software. If you use it in a
+ program, you must acknowledge somewhere in your documentation that
+ you've used the IJG code.
+ .
+ In legalese:
+ .
+ The authors make NO WARRANTY or representation, either express or implied,
+ 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-2010, Thomas G. Lane, Guido Vollbeding.
+ All Rights Reserved except as specified below.
+ .
+ Permission is hereby granted to use, copy, modify, and distribute this
+ software (or portions thereof) for any purpose, without fee, subject to these
+ conditions:
+ (1) If any part of the source code for this software is distributed, then this
+ README file must be included, with this copyright and no-warranty notice
+ unaltered; and any additions, deletions, or changes to the original files
+ must be clearly indicated in accompanying documentation.
+ (2) If only executable code is distributed, then the accompanying
+ documentation must state that "this software is based in part on the work of
+ the Independent JPEG Group".
+ (3) Permission for use of this software is granted only if the user accepts
+ full responsibility for any undesirable consequences; the authors accept
+ NO LIABILITY for damages of any kind.
+ .
+ These conditions apply to any software derived from or based on the IJG code,
+ not just to the unmodified library. If you use our work, you ought to
+ acknowledge us.
+ .
+ Permission is NOT granted for the use of any IJG author's name or company name
+ in advertising or publicity relating to this software or products derived from
+ it. This software may be referred to only as "the Independent JPEG Group's
+ software".
+ .
+ We specifically permit and encourage the use of this software as the basis of
+ commercial products, provided that all warranty or liability claims are
+ assumed by the product vendor.
+ .
+ ansi2knr.c is included in this distribution by permission of L. Peter Deutsch,
+ sole proprietor of its copyright holder, Aladdin Enterprises of Menlo Park, CA.
+ ansi2knr.c is NOT covered by the above copyright and conditions, but instead
+ by the usual distribution terms of the Free Software Foundation; principally,
+ that you must include source code if you redistribute it. (See the file
+ ansi2knr.c for full details.) However, since ansi2knr.c is not needed as part
+ of any program generated from the IJG code, this does not limit you more than
+ the foregoing paragraphs do.
+ .
+ The Unix configuration script "configure" was produced with GNU Autoconf.
+ It is copyright by the Free Software Foundation but is freely distributable.
+ The same holds for its supporting scripts (config.guess, config.sub,
+ ltmain.sh). Another support script, install-sh, is copyright by X Consortium
+ but is also freely distributable.
+ .
+ The IJG distribution formerly included code to read and write GIF files.
+ To avoid entanglement with the Unisys LZW patent, GIF reading support has
+ been removed altogether, and the GIF writer has been simplified to produce
+ "uncompressed GIFs". This technique does not use the LZW algorithm; the
+ resulting GIF files are larger than usual, but are readable by all standard
+ GIF decoders.
+ .
+ We are required to state that
+ "The Graphics Interchange Format(c) is the Copyright property of
+ CompuServe Incorporated. GIF(sm) is a Service Mark property of
+ CompuServe Incorporated."
+ .
+ The complete text can be found in README, supplied with the source.
+ .
+ libjpeg-turbo is licensed under a non-restrictive, BSD-style license
+ (see README.) The TurboJPEG/OSS wrapper (both C and Java versions) and
+ associated test programs bear a similar license, which is reproduced below:
+ .
+ Redistribution and use in source and binary forms, with or without
+ modification, are permitted provided that the following conditions are met:
+ .
+ - Redistributions of source code must retain the above copyright notice,
+ this list of conditions and the following disclaimer.
+ - Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+ - Neither the name of the libjpeg-turbo Project nor the names of its
+ contributors may be used to endorse or promote products derived from this
+ software without specific prior written permission.
+ .
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS",
+ AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE
+ LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ POSSIBILITY OF SUCH DAMAGE.
+
+Files: debian/*
+Copyright: 2007, Federico Di Gregorio
+License: GPL
diff --git a/debian/patches/build_using_libjpeg62_transupp.c.patch b/debian/patches/build_using_libjpeg62_transupp.c.patch
new file mode 100644
index 0000000..749613c
--- /dev/null
+++ b/debian/patches/build_using_libjpeg62_transupp.c.patch
@@ -0,0 +1,2005 @@
+--- freeimage.orig/gensrclist.sh
++++ freeimage/gensrclist.sh
+@@ -12,7 +12,7 @@ for DIR in $DIRLIST; do
+ egrep 'RelativePath=.*\.(c|cpp)' $DIR/*.2008.vcproj | cut -d'"' -f2 | tr '\\' '/' | awk '{print "'$DIR'/"$0}' | tr '\r\n' ' ' | tr -s ' ' >> Makefile.srcs
+ fi
+ done
+-echo -n ' Source/LibJPEG/transupp.c' >> Makefile.srcs
++echo -n ' jpeg/transupp.c' >> Makefile.srcs
+ echo >> Makefile.srcs
+
+ echo -n "INCLS = " >> Makefile.srcs
+--- /dev/null
++++ freeimage/jpeg/jinclude.h
+@@ -0,0 +1,91 @@
++/*
++ * jinclude.h
++ *
++ * Copyright (C) 1991-1994, 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 exists to provide a single place to fix any problems with
++ * including the wrong system include files. (Common problems are taken
++ * care of by the standard jconfig symbols, but on really weird systems
++ * you may have to edit this file.)
++ *
++ * NOTE: this file is NOT intended to be included by applications using the
++ * JPEG library. Most applications need only include jpeglib.h.
++ */
++
++
++/* Include auto-config file to find out which system include files we need. */
++
++#include "jconfig.h" /* auto configuration options */
++#define JCONFIG_INCLUDED /* so that jpeglib.h doesn't do it again */
++
++/*
++ * We need the NULL macro and size_t typedef.
++ * On an ANSI-conforming system it is sufficient to include <stddef.h>.
++ * Otherwise, we get them from <stdlib.h> or <stdio.h>; we may have to
++ * pull in <sys/types.h> as well.
++ * Note that the core JPEG library does not require <stdio.h>;
++ * only the default error handler and data source/destination modules do.
++ * But we must pull it in because of the references to FILE in jpeglib.h.
++ * You can remove those references if you want to compile without <stdio.h>.
++ */
++
++#ifdef HAVE_STDDEF_H
++#include <stddef.h>
++#endif
++
++#ifdef HAVE_STDLIB_H
++#include <stdlib.h>
++#endif
++
++#ifdef NEED_SYS_TYPES_H
++#include <sys/types.h>
++#endif
++
++#include <stdio.h>
++
++/*
++ * We need memory copying and zeroing functions, plus strncpy().
++ * ANSI and System V implementations declare these in <string.h>.
++ * BSD doesn't have the mem() functions, but it does have bcopy()/bzero().
++ * Some systems may declare memset and memcpy in <memory.h>.
++ *
++ * NOTE: we assume the size parameters to these functions are of type size_t.
++ * Change the casts in these macros if not!
++ */
++
++#ifdef NEED_BSD_STRINGS
++
++#include <strings.h>
++#define MEMZERO(target,size) bzero((void *)(target), (size_t)(size))
++#define MEMCOPY(dest,src,size) bcopy((const void *)(src), (void *)(dest), (size_t)(size))
++
++#else /* not BSD, assume ANSI/SysV string lib */
++
++#include <string.h>
++#define MEMZERO(target,size) memset((void *)(target), 0, (size_t)(size))
++#define MEMCOPY(dest,src,size) memcpy((void *)(dest), (const void *)(src), (size_t)(size))
++
++#endif
++
++/*
++ * In ANSI C, and indeed any rational implementation, size_t is also the
++ * type returned by sizeof(). However, it seems there are some irrational
++ * implementations out there, in which sizeof() returns an int even though
++ * size_t is defined as long or unsigned long. To ensure consistent results
++ * we always use this SIZEOF() macro in place of using sizeof() directly.
++ */
++
++#define SIZEOF(object) ((size_t) sizeof(object))
++
++/*
++ * The modules that use fread() and fwrite() always invoke them through
++ * these macros. On some systems you may need to twiddle the argument casts.
++ * CAUTION: argument order is different from underlying functions!
++ */
++
++#define JFREAD(file,buf,sizeofbuf) \
++ ((size_t) fread((void *) (buf), (size_t) 1, (size_t) (sizeofbuf), (file)))
++#define JFWRITE(file,buf,sizeofbuf) \
++ ((size_t) fwrite((const void *) (buf), (size_t) 1, (size_t) (sizeofbuf), (file)))
+--- /dev/null
++++ freeimage/jpeg/jpegcomp.h
+@@ -0,0 +1,30 @@
++/*
++ * jpegcomp.h
++ *
++ * Copyright (C) 2010, D. R. Commander
++ * For conditions of distribution and use, see the accompanying README file.
++ *
++ * JPEG compatibility macros
++ * These declarations are considered internal to the JPEG library; most
++ * applications using the library shouldn't need to include this file.
++ */
++
++#if JPEG_LIB_VERSION >= 70
++#define _DCT_scaled_size DCT_h_scaled_size
++#define _DCT_h_scaled_size DCT_h_scaled_size
++#define _DCT_v_scaled_size DCT_v_scaled_size
++#define _min_DCT_scaled_size min_DCT_h_scaled_size
++#define _min_DCT_h_scaled_size min_DCT_h_scaled_size
++#define _min_DCT_v_scaled_size min_DCT_v_scaled_size
++#define _jpeg_width jpeg_width
++#define _jpeg_height jpeg_height
++#else
++#define _DCT_scaled_size DCT_scaled_size
++#define _DCT_h_scaled_size DCT_scaled_size
++#define _DCT_v_scaled_size DCT_scaled_size
++#define _min_DCT_scaled_size min_DCT_scaled_size
++#define _min_DCT_h_scaled_size min_DCT_scaled_size
++#define _min_DCT_v_scaled_size min_DCT_scaled_size
++#define _jpeg_width image_width
++#define _jpeg_height image_height
++#endif
+--- /dev/null
++++ freeimage/jpeg/transupp.c
+@@ -0,0 +1,1630 @@
++/*
++ * transupp.c
++ *
++ * This file was part of the Independent JPEG Group's software:
++ * Copyright (C) 1997-2011, Thomas G. Lane, Guido Vollbeding.
++ * libjpeg-turbo Modifications:
++ * Copyright (C) 2010, D. R. Commander.
++ * For conditions of distribution and use, see the accompanying README file.
++ *
++ * This file contains image transformation routines and other utility code
++ * used by the jpegtran sample application. These are NOT part of the core
++ * JPEG library. But we keep these routines separate from jpegtran.c to
++ * ease the task of maintaining jpegtran-like programs that have other user
++ * interfaces.
++ */
++
++/* Although this file really shouldn't have access to the library internals,
++ * it's helpful to let it call jround_up() and jcopy_block_row().
++ */
++#define JPEG_INTERNALS
++
++#include "jinclude.h"
++#include "jpeglib.h"
++#include "transupp.h" /* My own external interface */
++#include "jpegcomp.h"
++#include <ctype.h> /* to declare isdigit() */
++
++
++#if JPEG_LIB_VERSION >= 70
++#define dstinfo_min_DCT_h_scaled_size dstinfo->min_DCT_h_scaled_size
++#define dstinfo_min_DCT_v_scaled_size dstinfo->min_DCT_v_scaled_size
++#else
++#define dstinfo_min_DCT_h_scaled_size DCTSIZE
++#define dstinfo_min_DCT_v_scaled_size DCTSIZE
++#endif
++
++
++#if TRANSFORMS_SUPPORTED
++
++/*
++ * Lossless image transformation routines. These routines work on DCT
++ * coefficient arrays and thus do not require any lossy decompression
++ * or recompression of the image.
++ * Thanks to Guido Vollbeding for the initial design and code of this feature,
++ * and to Ben Jackson for introducing the cropping feature.
++ *
++ * Horizontal flipping is done in-place, using a single top-to-bottom
++ * pass through the virtual source array. It will thus be much the
++ * fastest option for images larger than main memory.
++ *
++ * The other routines require a set of destination virtual arrays, so they
++ * need twice as much memory as jpegtran normally does. The destination
++ * arrays are always written in normal scan order (top to bottom) because
++ * the virtual array manager expects this. The source arrays will be scanned
++ * in the corresponding order, which means multiple passes through the source
++ * arrays for most of the transforms. That could result in much thrashing
++ * if the image is larger than main memory.
++ *
++ * If cropping or trimming is involved, the destination arrays may be smaller
++ * than the source arrays. Note it is not possible to do horizontal flip
++ * in-place when a nonzero Y crop offset is specified, since we'd have to move
++ * data from one block row to another but the virtual array manager doesn't
++ * guarantee we can touch more than one row at a time. So in that case,
++ * we have to use a separate destination array.
++ *
++ * Some notes about the operating environment of the individual transform
++ * routines:
++ * 1. Both the source and destination virtual arrays are allocated from the
++ * source JPEG object, and therefore should be manipulated by calling the
++ * source's memory manager.
++ * 2. The destination's component count should be used. It may be smaller
++ * than the source's when forcing to grayscale.
++ * 3. Likewise the destination's sampling factors should be used. When
++ * forcing to grayscale the destination's sampling factors will be all 1,
++ * and we may as well take that as the effective iMCU size.
++ * 4. When "trim" is in effect, the destination's dimensions will be the
++ * trimmed values but the source's will be untrimmed.
++ * 5. When "crop" is in effect, the destination's dimensions will be the
++ * cropped values but the source's will be uncropped. Each transform
++ * routine is responsible for picking up source data starting at the
++ * correct X and Y offset for the crop region. (The X and Y offsets
++ * passed to the transform routines are measured in iMCU blocks of the
++ * destination.)
++ * 6. All the routines assume that the source and destination buffers are
++ * padded out to a full iMCU boundary. This is true, although for the
++ * source buffer it is an undocumented property of jdcoefct.c.
++ */
++
++
++LOCAL(void)
++do_crop (j_decompress_ptr srcinfo, j_compress_ptr dstinfo,
++ JDIMENSION x_crop_offset, JDIMENSION y_crop_offset,
++ jvirt_barray_ptr *src_coef_arrays,
++ jvirt_barray_ptr *dst_coef_arrays)
++/* Crop. This is only used when no rotate/flip is requested with the crop. */
++{
++ JDIMENSION dst_blk_y, x_crop_blocks, y_crop_blocks;
++ int ci, offset_y;
++ JBLOCKARRAY src_buffer, dst_buffer;
++ jpeg_component_info *compptr;
++
++ /* We simply have to copy the right amount of data (the destination's
++ * image size) starting at the given X and Y offsets in the source.
++ */
++ for (ci = 0; ci < dstinfo->num_components; ci++) {
++ compptr = dstinfo->comp_info + ci;
++ x_crop_blocks = x_crop_offset * compptr->h_samp_factor;
++ y_crop_blocks = y_crop_offset * compptr->v_samp_factor;
++ for (dst_blk_y = 0; dst_blk_y < compptr->height_in_blocks;
++ dst_blk_y += compptr->v_samp_factor) {
++ dst_buffer = (*srcinfo->mem->access_virt_barray)
++ ((j_common_ptr) srcinfo, dst_coef_arrays[ci], dst_blk_y,
++ (JDIMENSION) compptr->v_samp_factor, TRUE);
++ src_buffer = (*srcinfo->mem->access_virt_barray)
++ ((j_common_ptr) srcinfo, src_coef_arrays[ci],
++ dst_blk_y + y_crop_blocks,
++ (JDIMENSION) compptr->v_samp_factor, FALSE);
++ for (offset_y = 0; offset_y < compptr->v_samp_factor; offset_y++) {
++ jcopy_block_row(src_buffer[offset_y] + x_crop_blocks,
++ dst_buffer[offset_y],
++ compptr->width_in_blocks);
++ }
++ }
++ }
++}
++
++
++LOCAL(void)
++do_flip_h_no_crop (j_decompress_ptr srcinfo, j_compress_ptr dstinfo,
++ JDIMENSION x_crop_offset,
++ jvirt_barray_ptr *src_coef_arrays)
++/* Horizontal flip; done in-place, so no separate dest array is required.
++ * NB: this only works when y_crop_offset is zero.
++ */
++{
++ JDIMENSION MCU_cols, comp_width, blk_x, blk_y, x_crop_blocks;
++ int ci, k, offset_y;
++ JBLOCKARRAY buffer;
++ JCOEFPTR ptr1, ptr2;
++ JCOEF temp1, temp2;
++ jpeg_component_info *compptr;
++
++ /* Horizontal mirroring of DCT blocks is accomplished by swapping
++ * pairs of blocks in-place. Within a DCT block, we perform horizontal
++ * mirroring by changing the signs of odd-numbered columns.
++ * Partial iMCUs at the right edge are left untouched.
++ */
++ MCU_cols = srcinfo->output_width /
++ (dstinfo->max_h_samp_factor * dstinfo_min_DCT_h_scaled_size);
++
++ for (ci = 0; ci < dstinfo->num_components; ci++) {
++ compptr = dstinfo->comp_info + ci;
++ comp_width = MCU_cols * compptr->h_samp_factor;
++ x_crop_blocks = x_crop_offset * compptr->h_samp_factor;
++ for (blk_y = 0; blk_y < compptr->height_in_blocks;
++ blk_y += compptr->v_samp_factor) {
++ buffer = (*srcinfo->mem->access_virt_barray)
++ ((j_common_ptr) srcinfo, src_coef_arrays[ci], blk_y,
++ (JDIMENSION) compptr->v_samp_factor, TRUE);
++ for (offset_y = 0; offset_y < compptr->v_samp_factor; offset_y++) {
++ /* Do the mirroring */
++ for (blk_x = 0; blk_x * 2 < comp_width; blk_x++) {
++ ptr1 = buffer[offset_y][blk_x];
++ ptr2 = buffer[offset_y][comp_width - blk_x - 1];
++ /* this unrolled loop doesn't need to know which row it's on... */
++ for (k = 0; k < DCTSIZE2; k += 2) {
++ temp1 = *ptr1; /* swap even column */
++ temp2 = *ptr2;
++ *ptr1++ = temp2;
++ *ptr2++ = temp1;
++ temp1 = *ptr1; /* swap odd column with sign change */
++ temp2 = *ptr2;
++ *ptr1++ = -temp2;
++ *ptr2++ = -temp1;
++ }
++ }
++ if (x_crop_blocks > 0) {
++ /* Now left-justify the portion of the data to be kept.
++ * We can't use a single jcopy_block_row() call because that routine
++ * depends on memcpy(), whose behavior is unspecified for overlapping
++ * source and destination areas. Sigh.
++ */
++ for (blk_x = 0; blk_x < compptr->width_in_blocks; blk_x++) {
++ jcopy_block_row(buffer[offset_y] + blk_x + x_crop_blocks,
++ buffer[offset_y] + blk_x,
++ (JDIMENSION) 1);
++ }
++ }
++ }
++ }
++ }
++}
++
++
++LOCAL(void)
++do_flip_h (j_decompress_ptr srcinfo, j_compress_ptr dstinfo,
++ JDIMENSION x_crop_offset, JDIMENSION y_crop_offset,
++ jvirt_barray_ptr *src_coef_arrays,
++ jvirt_barray_ptr *dst_coef_arrays)
++/* Horizontal flip in general cropping case */
++{
++ JDIMENSION MCU_cols, comp_width, dst_blk_x, dst_blk_y;
++ JDIMENSION x_crop_blocks, y_crop_blocks;
++ int ci, k, offset_y;
++ JBLOCKARRAY src_buffer, dst_buffer;
++ JBLOCKROW src_row_ptr, dst_row_ptr;
++ JCOEFPTR src_ptr, dst_ptr;
++ jpeg_component_info *compptr;
++
++ /* Here we must output into a separate array because we can't touch
++ * different rows of a single virtual array simultaneously. Otherwise,
++ * this is essentially the same as the routine above.
++ */
++ MCU_cols = srcinfo->output_width /
++ (dstinfo->max_h_samp_factor * dstinfo_min_DCT_h_scaled_size);
++
++ for (ci = 0; ci < dstinfo->num_components; ci++) {
++ compptr = dstinfo->comp_info + ci;
++ comp_width = MCU_cols * compptr->h_samp_factor;
++ x_crop_blocks = x_crop_offset * compptr->h_samp_factor;
++ y_crop_blocks = y_crop_offset * compptr->v_samp_factor;
++ for (dst_blk_y = 0; dst_blk_y < compptr->height_in_blocks;
++ dst_blk_y += compptr->v_samp_factor) {
++ dst_buffer = (*srcinfo->mem->access_virt_barray)
++ ((j_common_ptr) srcinfo, dst_coef_arrays[ci], dst_blk_y,
++ (JDIMENSION) compptr->v_samp_factor, TRUE);
++ src_buffer = (*srcinfo->mem->access_virt_barray)
++ ((j_common_ptr) srcinfo, src_coef_arrays[ci],
++ dst_blk_y + y_crop_blocks,
++ (JDIMENSION) compptr->v_samp_factor, FALSE);
++ for (offset_y = 0; offset_y < compptr->v_samp_factor; offset_y++) {
++ dst_row_ptr = dst_buffer[offset_y];
++ src_row_ptr = src_buffer[offset_y];
++ for (dst_blk_x = 0; dst_blk_x < compptr->width_in_blocks; dst_blk_x++) {
++ if (x_crop_blocks + dst_blk_x < comp_width) {
++ /* Do the mirrorable blocks */
++ dst_ptr = dst_row_ptr[dst_blk_x];
++ src_ptr = src_row_ptr[comp_width - x_crop_blocks - dst_blk_x - 1];
++ /* this unrolled loop doesn't need to know which row it's on... */
++ for (k = 0; k < DCTSIZE2; k += 2) {
++ *dst_ptr++ = *src_ptr++; /* copy even column */
++ *dst_ptr++ = - *src_ptr++; /* copy odd column with sign change */
++ }
++ } else {
++ /* Copy last partial block(s) verbatim */
++ jcopy_block_row(src_row_ptr + dst_blk_x + x_crop_blocks,
++ dst_row_ptr + dst_blk_x,
++ (JDIMENSION) 1);
++ }
++ }
++ }
++ }
++ }
++}
++
++
++LOCAL(void)
++do_flip_v (j_decompress_ptr srcinfo, j_compress_ptr dstinfo,
++ JDIMENSION x_crop_offset, JDIMENSION y_crop_offset,
++ jvirt_barray_ptr *src_coef_arrays,
++ jvirt_barray_ptr *dst_coef_arrays)
++/* Vertical flip */
++{
++ JDIMENSION MCU_rows, comp_height, dst_blk_x, dst_blk_y;
++ JDIMENSION x_crop_blocks, y_crop_blocks;
++ int ci, i, j, offset_y;
++ JBLOCKARRAY src_buffer, dst_buffer;
++ JBLOCKROW src_row_ptr, dst_row_ptr;
++ JCOEFPTR src_ptr, dst_ptr;
++ jpeg_component_info *compptr;
++
++ /* We output into a separate array because we can't touch different
++ * rows of the source virtual array simultaneously. Otherwise, this
++ * is a pretty straightforward analog of horizontal flip.
++ * Within a DCT block, vertical mirroring is done by changing the signs
++ * of odd-numbered rows.
++ * Partial iMCUs at the bottom edge are copied verbatim.
++ */
++ MCU_rows = srcinfo->output_height /
++ (dstinfo->max_v_samp_factor * dstinfo_min_DCT_v_scaled_size);
++
++ for (ci = 0; ci < dstinfo->num_components; ci++) {
++ compptr = dstinfo->comp_info + ci;
++ comp_height = MCU_rows * compptr->v_samp_factor;
++ x_crop_blocks = x_crop_offset * compptr->h_samp_factor;
++ y_crop_blocks = y_crop_offset * compptr->v_samp_factor;
++ for (dst_blk_y = 0; dst_blk_y < compptr->height_in_blocks;
++ dst_blk_y += compptr->v_samp_factor) {
++ dst_buffer = (*srcinfo->mem->access_virt_barray)
++ ((j_common_ptr) srcinfo, dst_coef_arrays[ci], dst_blk_y,
++ (JDIMENSION) compptr->v_samp_factor, TRUE);
++ if (y_crop_blocks + dst_blk_y < comp_height) {
++ /* Row is within the mirrorable area. */
++ src_buffer = (*srcinfo->mem->access_virt_barray)
++ ((j_common_ptr) srcinfo, src_coef_arrays[ci],
++ comp_height - y_crop_blocks - dst_blk_y -
++ (JDIMENSION) compptr->v_samp_factor,
++ (JDIMENSION) compptr->v_samp_factor, FALSE);
++ } else {
++ /* Bottom-edge blocks will be copied verbatim. */
++ src_buffer = (*srcinfo->mem->access_virt_barray)
++ ((j_common_ptr) srcinfo, src_coef_arrays[ci],
++ dst_blk_y + y_crop_blocks,
++ (JDIMENSION) compptr->v_samp_factor, FALSE);
++ }
++ for (offset_y = 0; offset_y < compptr->v_samp_factor; offset_y++) {
++ if (y_crop_blocks + dst_blk_y < comp_height) {
++ /* Row is within the mirrorable area. */
++ dst_row_ptr = dst_buffer[offset_y];
++ src_row_ptr = src_buffer[compptr->v_samp_factor - offset_y - 1];
++ src_row_ptr += x_crop_blocks;
++ for (dst_blk_x = 0; dst_blk_x < compptr->width_in_blocks;
++ dst_blk_x++) {
++ dst_ptr = dst_row_ptr[dst_blk_x];
++ src_ptr = src_row_ptr[dst_blk_x];
++ for (i = 0; i < DCTSIZE; i += 2) {
++ /* copy even row */
++ for (j = 0; j < DCTSIZE; j++)
++ *dst_ptr++ = *src_ptr++;
++ /* copy odd row with sign change */
++ for (j = 0; j < DCTSIZE; j++)
++ *dst_ptr++ = - *src_ptr++;
++ }
++ }
++ } else {
++ /* Just copy row verbatim. */
++ jcopy_block_row(src_buffer[offset_y] + x_crop_blocks,
++ dst_buffer[offset_y],
++ compptr->width_in_blocks);
++ }
++ }
++ }
++ }
++}
++
++
++LOCAL(void)
++do_transpose (j_decompress_ptr srcinfo, j_compress_ptr dstinfo,
++ JDIMENSION x_crop_offset, JDIMENSION y_crop_offset,
++ jvirt_barray_ptr *src_coef_arrays,
++ jvirt_barray_ptr *dst_coef_arrays)
++/* Transpose source into destination */
++{
++ JDIMENSION dst_blk_x, dst_blk_y, x_crop_blocks, y_crop_blocks;
++ int ci, i, j, offset_x, offset_y;
++ JBLOCKARRAY src_buffer, dst_buffer;
++ JCOEFPTR src_ptr, dst_ptr;
++ jpeg_component_info *compptr;
++
++ /* Transposing pixels within a block just requires transposing the
++ * DCT coefficients.
++ * Partial iMCUs at the edges require no special treatment; we simply
++ * process all the available DCT blocks for every component.
++ */
++ for (ci = 0; ci < dstinfo->num_components; ci++) {
++ compptr = dstinfo->comp_info + ci;
++ x_crop_blocks = x_crop_offset * compptr->h_samp_factor;
++ y_crop_blocks = y_crop_offset * compptr->v_samp_factor;
++ for (dst_blk_y = 0; dst_blk_y < compptr->height_in_blocks;
++ dst_blk_y += compptr->v_samp_factor) {
++ dst_buffer = (*srcinfo->mem->access_virt_barray)
++ ((j_common_ptr) srcinfo, dst_coef_arrays[ci], dst_blk_y,
++ (JDIMENSION) compptr->v_samp_factor, TRUE);
++ for (offset_y = 0; offset_y < compptr->v_samp_factor; offset_y++) {
++ for (dst_blk_x = 0; dst_blk_x < compptr->width_in_blocks;
++ dst_blk_x += compptr->h_samp_factor) {
++ src_buffer = (*srcinfo->mem->access_virt_barray)
++ ((j_common_ptr) srcinfo, src_coef_arrays[ci],
++ dst_blk_x + x_crop_blocks,
++ (JDIMENSION) compptr->h_samp_factor, FALSE);
++ for (offset_x = 0; offset_x < compptr->h_samp_factor; offset_x++) {
++ dst_ptr = dst_buffer[offset_y][dst_blk_x + offset_x];
++ src_ptr = src_buffer[offset_x][dst_blk_y + offset_y + y_crop_blocks];
++ for (i = 0; i < DCTSIZE; i++)
++ for (j = 0; j < DCTSIZE; j++)
++ dst_ptr[j*DCTSIZE+i] = src_ptr[i*DCTSIZE+j];
++ }
++ }
++ }
++ }
++ }
++}
++
++
++LOCAL(void)
++do_rot_90 (j_decompress_ptr srcinfo, j_compress_ptr dstinfo,
++ JDIMENSION x_crop_offset, JDIMENSION y_crop_offset,
++ jvirt_barray_ptr *src_coef_arrays,
++ jvirt_barray_ptr *dst_coef_arrays)
++/* 90 degree rotation is equivalent to
++ * 1. Transposing the image;
++ * 2. Horizontal mirroring.
++ * These two steps are merged into a single processing routine.
++ */
++{
++ JDIMENSION MCU_cols, comp_width, dst_blk_x, dst_blk_y;
++ JDIMENSION x_crop_blocks, y_crop_blocks;
++ int ci, i, j, offset_x, offset_y;
++ JBLOCKARRAY src_buffer, dst_buffer;
++ JCOEFPTR src_ptr, dst_ptr;
++ jpeg_component_info *compptr;
++
++ /* Because of the horizontal mirror step, we can't process partial iMCUs
++ * at the (output) right edge properly. They just get transposed and
++ * not mirrored.
++ */
++ MCU_cols = srcinfo->output_height /
++ (dstinfo->max_h_samp_factor * dstinfo_min_DCT_h_scaled_size);
++
++ for (ci = 0; ci < dstinfo->num_components; ci++) {
++ compptr = dstinfo->comp_info + ci;
++ comp_width = MCU_cols * compptr->h_samp_factor;
++ x_crop_blocks = x_crop_offset * compptr->h_samp_factor;
++ y_crop_blocks = y_crop_offset * compptr->v_samp_factor;
++ for (dst_blk_y = 0; dst_blk_y < compptr->height_in_blocks;
++ dst_blk_y += compptr->v_samp_factor) {
++ dst_buffer = (*srcinfo->mem->access_virt_barray)
++ ((j_common_ptr) srcinfo, dst_coef_arrays[ci], dst_blk_y,
++ (JDIMENSION) compptr->v_samp_factor, TRUE);
++ for (offset_y = 0; offset_y < compptr->v_samp_factor; offset_y++) {
++ for (dst_blk_x = 0; dst_blk_x < compptr->width_in_blocks;
++ dst_blk_x += compptr->h_samp_factor) {
++ if (x_crop_blocks + dst_blk_x < comp_width) {
++ /* Block is within the mirrorable area. */
++ src_buffer = (*srcinfo->mem->access_virt_barray)
++ ((j_common_ptr) srcinfo, src_coef_arrays[ci],
++ comp_width - x_crop_blocks - dst_blk_x -
++ (JDIMENSION) compptr->h_samp_factor,
++ (JDIMENSION) compptr->h_samp_factor, FALSE);
++ } else {
++ /* Edge blocks are transposed but not mirrored. */
++ src_buffer = (*srcinfo->mem->access_virt_barray)
++ ((j_common_ptr) srcinfo, src_coef_arrays[ci],
++ dst_blk_x + x_crop_blocks,
++ (JDIMENSION) compptr->h_samp_factor, FALSE);
++ }
++ for (offset_x = 0; offset_x < compptr->h_samp_factor; offset_x++) {
++ dst_ptr = dst_buffer[offset_y][dst_blk_x + offset_x];
++ if (x_crop_blocks + dst_blk_x < comp_width) {
++ /* Block is within the mirrorable area. */
++ src_ptr = src_buffer[compptr->h_samp_factor - offset_x - 1]
++ [dst_blk_y + offset_y + y_crop_blocks];
++ for (i = 0; i < DCTSIZE; i++) {
++ for (j = 0; j < DCTSIZE; j++)
++ dst_ptr[j*DCTSIZE+i] = src_ptr[i*DCTSIZE+j];
++ i++;
++ for (j = 0; j < DCTSIZE; j++)
++ dst_ptr[j*DCTSIZE+i] = -src_ptr[i*DCTSIZE+j];
++ }
++ } else {
++ /* Edge blocks are transposed but not mirrored. */
++ src_ptr = src_buffer[offset_x]
++ [dst_blk_y + offset_y + y_crop_blocks];
++ for (i = 0; i < DCTSIZE; i++)
++ for (j = 0; j < DCTSIZE; j++)
++ dst_ptr[j*DCTSIZE+i] = src_ptr[i*DCTSIZE+j];
++ }
++ }
++ }
++ }
++ }
++ }
++}
++
++
++LOCAL(void)
++do_rot_270 (j_decompress_ptr srcinfo, j_compress_ptr dstinfo,
++ JDIMENSION x_crop_offset, JDIMENSION y_crop_offset,
++ jvirt_barray_ptr *src_coef_arrays,
++ jvirt_barray_ptr *dst_coef_arrays)
++/* 270 degree rotation is equivalent to
++ * 1. Horizontal mirroring;
++ * 2. Transposing the image.
++ * These two steps are merged into a single processing routine.
++ */
++{
++ JDIMENSION MCU_rows, comp_height, dst_blk_x, dst_blk_y;
++ JDIMENSION x_crop_blocks, y_crop_blocks;
++ int ci, i, j, offset_x, offset_y;
++ JBLOCKARRAY src_buffer, dst_buffer;
++ JCOEFPTR src_ptr, dst_ptr;
++ jpeg_component_info *compptr;
++
++ /* Because of the horizontal mirror step, we can't process partial iMCUs
++ * at the (output) bottom edge properly. They just get transposed and
++ * not mirrored.
++ */
++ MCU_rows = srcinfo->output_width /
++ (dstinfo->max_v_samp_factor * dstinfo_min_DCT_v_scaled_size);
++
++ for (ci = 0; ci < dstinfo->num_components; ci++) {
++ compptr = dstinfo->comp_info + ci;
++ comp_height = MCU_rows * compptr->v_samp_factor;
++ x_crop_blocks = x_crop_offset * compptr->h_samp_factor;
++ y_crop_blocks = y_crop_offset * compptr->v_samp_factor;
++ for (dst_blk_y = 0; dst_blk_y < compptr->height_in_blocks;
++ dst_blk_y += compptr->v_samp_factor) {
++ dst_buffer = (*srcinfo->mem->access_virt_barray)
++ ((j_common_ptr) srcinfo, dst_coef_arrays[ci], dst_blk_y,
++ (JDIMENSION) compptr->v_samp_factor, TRUE);
++ for (offset_y = 0; offset_y < compptr->v_samp_factor; offset_y++) {
++ for (dst_blk_x = 0; dst_blk_x < compptr->width_in_blocks;
++ dst_blk_x += compptr->h_samp_factor) {
++ src_buffer = (*srcinfo->mem->access_virt_barray)
++ ((j_common_ptr) srcinfo, src_coef_arrays[ci],
++ dst_blk_x + x_crop_blocks,
++ (JDIMENSION) compptr->h_samp_factor, FALSE);
++ for (offset_x = 0; offset_x < compptr->h_samp_factor; offset_x++) {
++ dst_ptr = dst_buffer[offset_y][dst_blk_x + offset_x];
++ if (y_crop_blocks + dst_blk_y < comp_height) {
++ /* Block is within the mirrorable area. */
++ src_ptr = src_buffer[offset_x]
++ [comp_height - y_crop_blocks - dst_blk_y - offset_y - 1];
++ for (i = 0; i < DCTSIZE; i++) {
++ for (j = 0; j < DCTSIZE; j++) {
++ dst_ptr[j*DCTSIZE+i] = src_ptr[i*DCTSIZE+j];
++ j++;
++ dst_ptr[j*DCTSIZE+i] = -src_ptr[i*DCTSIZE+j];
++ }
++ }
++ } else {
++ /* Edge blocks are transposed but not mirrored. */
++ src_ptr = src_buffer[offset_x]
++ [dst_blk_y + offset_y + y_crop_blocks];
++ for (i = 0; i < DCTSIZE; i++)
++ for (j = 0; j < DCTSIZE; j++)
++ dst_ptr[j*DCTSIZE+i] = src_ptr[i*DCTSIZE+j];
++ }
++ }
++ }
++ }
++ }
++ }
++}
++
++
++LOCAL(void)
++do_rot_180 (j_decompress_ptr srcinfo, j_compress_ptr dstinfo,
++ JDIMENSION x_crop_offset, JDIMENSION y_crop_offset,
++ jvirt_barray_ptr *src_coef_arrays,
++ jvirt_barray_ptr *dst_coef_arrays)
++/* 180 degree rotation is equivalent to
++ * 1. Vertical mirroring;
++ * 2. Horizontal mirroring.
++ * These two steps are merged into a single processing routine.
++ */
++{
++ JDIMENSION MCU_cols, MCU_rows, comp_width, comp_height, dst_blk_x, dst_blk_y;
++ JDIMENSION x_crop_blocks, y_crop_blocks;
++ int ci, i, j, offset_y;
++ JBLOCKARRAY src_buffer, dst_buffer;
++ JBLOCKROW src_row_ptr, dst_row_ptr;
++ JCOEFPTR src_ptr, dst_ptr;
++ jpeg_component_info *compptr;
++
++ MCU_cols = srcinfo->output_width /
++ (dstinfo->max_h_samp_factor * dstinfo_min_DCT_h_scaled_size);
++ MCU_rows = srcinfo->output_height /
++ (dstinfo->max_v_samp_factor * dstinfo_min_DCT_v_scaled_size);
++
++ for (ci = 0; ci < dstinfo->num_components; ci++) {
++ compptr = dstinfo->comp_info + ci;
++ comp_width = MCU_cols * compptr->h_samp_factor;
++ comp_height = MCU_rows * compptr->v_samp_factor;
++ x_crop_blocks = x_crop_offset * compptr->h_samp_factor;
++ y_crop_blocks = y_crop_offset * compptr->v_samp_factor;
++ for (dst_blk_y = 0; dst_blk_y < compptr->height_in_blocks;
++ dst_blk_y += compptr->v_samp_factor) {
++ dst_buffer = (*srcinfo->mem->access_virt_barray)
++ ((j_common_ptr) srcinfo, dst_coef_arrays[ci], dst_blk_y,
++ (JDIMENSION) compptr->v_samp_factor, TRUE);
++ if (y_crop_blocks + dst_blk_y < comp_height) {
++ /* Row is within the vertically mirrorable area. */
++ src_buffer = (*srcinfo->mem->access_virt_barray)
++ ((j_common_ptr) srcinfo, src_coef_arrays[ci],
++ comp_height - y_crop_blocks - dst_blk_y -
++ (JDIMENSION) compptr->v_samp_factor,
++ (JDIMENSION) compptr->v_samp_factor, FALSE);
++ } else {
++ /* Bottom-edge rows are only mirrored horizontally. */
++ src_buffer = (*srcinfo->mem->access_virt_barray)
++ ((j_common_ptr) srcinfo, src_coef_arrays[ci],
++ dst_blk_y + y_crop_blocks,
++ (JDIMENSION) compptr->v_samp_factor, FALSE);
++ }
++ for (offset_y = 0; offset_y < compptr->v_samp_factor; offset_y++) {
++ dst_row_ptr = dst_buffer[offset_y];
++ if (y_crop_blocks + dst_blk_y < comp_height) {
++ /* Row is within the mirrorable area. */
++ src_row_ptr = src_buffer[compptr->v_samp_factor - offset_y - 1];
++ for (dst_blk_x = 0; dst_blk_x < compptr->width_in_blocks; dst_blk_x++) {
++ dst_ptr = dst_row_ptr[dst_blk_x];
++ if (x_crop_blocks + dst_blk_x < comp_width) {
++ /* Process the blocks that can be mirrored both ways. */
++ src_ptr = src_row_ptr[comp_width - x_crop_blocks - dst_blk_x - 1];
++ for (i = 0; i < DCTSIZE; i += 2) {
++ /* For even row, negate every odd column. */
++ for (j = 0; j < DCTSIZE; j += 2) {
++ *dst_ptr++ = *src_ptr++;
++ *dst_ptr++ = - *src_ptr++;
++ }
++ /* For odd row, negate every even column. */
++ for (j = 0; j < DCTSIZE; j += 2) {
++ *dst_ptr++ = - *src_ptr++;
++ *dst_ptr++ = *src_ptr++;
++ }
++ }
++ } else {
++ /* Any remaining right-edge blocks are only mirrored vertically. */
++ src_ptr = src_row_ptr[x_crop_blocks + dst_blk_x];
++ for (i = 0; i < DCTSIZE; i += 2) {
++ for (j = 0; j < DCTSIZE; j++)
++ *dst_ptr++ = *src_ptr++;
++ for (j = 0; j < DCTSIZE; j++)
++ *dst_ptr++ = - *src_ptr++;
++ }
++ }
++ }
++ } else {
++ /* Remaining rows are just mirrored horizontally. */
++ src_row_ptr = src_buffer[offset_y];
++ for (dst_blk_x = 0; dst_blk_x < compptr->width_in_blocks; dst_blk_x++) {
++ if (x_crop_blocks + dst_blk_x < comp_width) {
++ /* Process the blocks that can be mirrored. */
++ dst_ptr = dst_row_ptr[dst_blk_x];
++ src_ptr = src_row_ptr[comp_width - x_crop_blocks - dst_blk_x - 1];
++ for (i = 0; i < DCTSIZE2; i += 2) {
++ *dst_ptr++ = *src_ptr++;
++ *dst_ptr++ = - *src_ptr++;
++ }
++ } else {
++ /* Any remaining right-edge blocks are only copied. */
++ jcopy_block_row(src_row_ptr + dst_blk_x + x_crop_blocks,
++ dst_row_ptr + dst_blk_x,
++ (JDIMENSION) 1);
++ }
++ }
++ }
++ }
++ }
++ }
++}
++
++
++LOCAL(void)
++do_transverse (j_decompress_ptr srcinfo, j_compress_ptr dstinfo,
++ JDIMENSION x_crop_offset, JDIMENSION y_crop_offset,
++ jvirt_barray_ptr *src_coef_arrays,
++ jvirt_barray_ptr *dst_coef_arrays)
++/* Transverse transpose is equivalent to
++ * 1. 180 degree rotation;
++ * 2. Transposition;
++ * or
++ * 1. Horizontal mirroring;
++ * 2. Transposition;
++ * 3. Horizontal mirroring.
++ * These steps are merged into a single processing routine.
++ */
++{
++ JDIMENSION MCU_cols, MCU_rows, comp_width, comp_height, dst_blk_x, dst_blk_y;
++ JDIMENSION x_crop_blocks, y_crop_blocks;
++ int ci, i, j, offset_x, offset_y;
++ JBLOCKARRAY src_buffer, dst_buffer;
++ JCOEFPTR src_ptr, dst_ptr;
++ jpeg_component_info *compptr;
++
++ MCU_cols = srcinfo->output_height /
++ (dstinfo->max_h_samp_factor * dstinfo_min_DCT_h_scaled_size);
++ MCU_rows = srcinfo->output_width /
++ (dstinfo->max_v_samp_factor * dstinfo_min_DCT_v_scaled_size);
++
++ for (ci = 0; ci < dstinfo->num_components; ci++) {
++ compptr = dstinfo->comp_info + ci;
++ comp_width = MCU_cols * compptr->h_samp_factor;
++ comp_height = MCU_rows * compptr->v_samp_factor;
++ x_crop_blocks = x_crop_offset * compptr->h_samp_factor;
++ y_crop_blocks = y_crop_offset * compptr->v_samp_factor;
++ for (dst_blk_y = 0; dst_blk_y < compptr->height_in_blocks;
++ dst_blk_y += compptr->v_samp_factor) {
++ dst_buffer = (*srcinfo->mem->access_virt_barray)
++ ((j_common_ptr) srcinfo, dst_coef_arrays[ci], dst_blk_y,
++ (JDIMENSION) compptr->v_samp_factor, TRUE);
++ for (offset_y = 0; offset_y < compptr->v_samp_factor; offset_y++) {
++ for (dst_blk_x = 0; dst_blk_x < compptr->width_in_blocks;
++ dst_blk_x += compptr->h_samp_factor) {
++ if (x_crop_blocks + dst_blk_x < comp_width) {
++ /* Block is within the mirrorable area. */
++ src_buffer = (*srcinfo->mem->access_virt_barray)
++ ((j_common_ptr) srcinfo, src_coef_arrays[ci],
++ comp_width - x_crop_blocks - dst_blk_x -
++ (JDIMENSION) compptr->h_samp_factor,
++ (JDIMENSION) compptr->h_samp_factor, FALSE);
++ } else {
++ src_buffer = (*srcinfo->mem->access_virt_barray)
++ ((j_common_ptr) srcinfo, src_coef_arrays[ci],
++ dst_blk_x + x_crop_blocks,
++ (JDIMENSION) compptr->h_samp_factor, FALSE);
++ }
++ for (offset_x = 0; offset_x < compptr->h_samp_factor; offset_x++) {
++ dst_ptr = dst_buffer[offset_y][dst_blk_x + offset_x];
++ if (y_crop_blocks + dst_blk_y < comp_height) {
++ if (x_crop_blocks + dst_blk_x < comp_width) {
++ /* Block is within the mirrorable area. */
++ src_ptr = src_buffer[compptr->h_samp_factor - offset_x - 1]
++ [comp_height - y_crop_blocks - dst_blk_y - offset_y - 1];
++ for (i = 0; i < DCTSIZE; i++) {
++ for (j = 0; j < DCTSIZE; j++) {
++ dst_ptr[j*DCTSIZE+i] = src_ptr[i*DCTSIZE+j];
++ j++;
++ dst_ptr[j*DCTSIZE+i] = -src_ptr[i*DCTSIZE+j];
++ }
++ i++;
++ for (j = 0; j < DCTSIZE; j++) {
++ dst_ptr[j*DCTSIZE+i] = -src_ptr[i*DCTSIZE+j];
++ j++;
++ dst_ptr[j*DCTSIZE+i] = src_ptr[i*DCTSIZE+j];
++ }
++ }
++ } else {
++ /* Right-edge blocks are mirrored in y only */
++ src_ptr = src_buffer[offset_x]
++ [comp_height - y_crop_blocks - dst_blk_y - offset_y - 1];
++ for (i = 0; i < DCTSIZE; i++) {
++ for (j = 0; j < DCTSIZE; j++) {
++ dst_ptr[j*DCTSIZE+i] = src_ptr[i*DCTSIZE+j];
++ j++;
++ dst_ptr[j*DCTSIZE+i] = -src_ptr[i*DCTSIZE+j];
++ }
++ }
++ }
++ } else {
++ if (x_crop_blocks + dst_blk_x < comp_width) {
++ /* Bottom-edge blocks are mirrored in x only */
++ src_ptr = src_buffer[compptr->h_samp_factor - offset_x - 1]
++ [dst_blk_y + offset_y + y_crop_blocks];
++ for (i = 0; i < DCTSIZE; i++) {
++ for (j = 0; j < DCTSIZE; j++)
++ dst_ptr[j*DCTSIZE+i] = src_ptr[i*DCTSIZE+j];
++ i++;
++ for (j = 0; j < DCTSIZE; j++)
++ dst_ptr[j*DCTSIZE+i] = -src_ptr[i*DCTSIZE+j];
++ }
++ } else {
++ /* At lower right corner, just transpose, no mirroring */
++ src_ptr = src_buffer[offset_x]
++ [dst_blk_y + offset_y + y_crop_blocks];
++ for (i = 0; i < DCTSIZE; i++)
++ for (j = 0; j < DCTSIZE; j++)
++ dst_ptr[j*DCTSIZE+i] = src_ptr[i*DCTSIZE+j];
++ }
++ }
++ }
++ }
++ }
++ }
++ }
++}
++
++
++/* Parse an unsigned integer: subroutine for jtransform_parse_crop_spec.
++ * Returns TRUE if valid integer found, FALSE if not.
++ * *strptr is advanced over the digit string, and *result is set to its value.
++ */
++
++LOCAL(boolean)
++jt_read_integer (const char ** strptr, JDIMENSION * result)
++{
++ const char * ptr = *strptr;
++ JDIMENSION val = 0;
++
++ for (; isdigit(*ptr); ptr++) {
++ val = val * 10 + (JDIMENSION) (*ptr - '0');
++ }
++ *result = val;
++ if (ptr == *strptr)
++ return FALSE; /* oops, no digits */
++ *strptr = ptr;
++ return TRUE;
++}
++
++
++/* Parse a crop specification (written in X11 geometry style).
++ * The routine returns TRUE if the spec string is valid, FALSE if not.
++ *
++ * The crop spec string should have the format
++ * <width>[f]x<height>[f]{+-}<xoffset>{+-}<yoffset>
++ * where width, height, xoffset, and yoffset are unsigned integers.
++ * Each of the elements can be omitted to indicate a default value.
++ * (A weakness of this style is that it is not possible to omit xoffset
++ * while specifying yoffset, since they look alike.)
++ *
++ * This code is loosely based on XParseGeometry from the X11 distribution.
++ */
++
++GLOBAL(boolean)
++jtransform_parse_crop_spec (jpeg_transform_info *info, const char *spec)
++{
++ info->crop = FALSE;
++ info->crop_width_set = JCROP_UNSET;
++ info->crop_height_set = JCROP_UNSET;
++ info->crop_xoffset_set = JCROP_UNSET;
++ info->crop_yoffset_set = JCROP_UNSET;
++
++ if (isdigit(*spec)) {
++ /* fetch width */
++ if (! jt_read_integer(&spec, &info->crop_width))
++ return FALSE;
++ if (*spec == 'f' || *spec == 'F') {
++ spec++;
++ info->crop_width_set = JCROP_FORCE;
++ } else
++ info->crop_width_set = JCROP_POS;
++ }
++ if (*spec == 'x' || *spec == 'X') {
++ /* fetch height */
++ spec++;
++ if (! jt_read_integer(&spec, &info->crop_height))
++ return FALSE;
++ if (*spec == 'f' || *spec == 'F') {
++ spec++;
++ info->crop_height_set = JCROP_FORCE;
++ } else
++ info->crop_height_set = JCROP_POS;
++ }
++ if (*spec == '+' || *spec == '-') {
++ /* fetch xoffset */
++ info->crop_xoffset_set = (*spec == '-') ? JCROP_NEG : JCROP_POS;
++ spec++;
++ if (! jt_read_integer(&spec, &info->crop_xoffset))
++ return FALSE;
++ }
++ if (*spec == '+' || *spec == '-') {
++ /* fetch yoffset */
++ info->crop_yoffset_set = (*spec == '-') ? JCROP_NEG : JCROP_POS;
++ spec++;
++ if (! jt_read_integer(&spec, &info->crop_yoffset))
++ return FALSE;
++ }
++ /* We had better have gotten to the end of the string. */
++ if (*spec != '\0')
++ return FALSE;
++ info->crop = TRUE;
++ return TRUE;
++}
++
++
++/* Trim off any partial iMCUs on the indicated destination edge */
++
++LOCAL(void)
++trim_right_edge (jpeg_transform_info *info, JDIMENSION full_width)
++{
++ JDIMENSION MCU_cols;
++
++ MCU_cols = info->output_width / info->iMCU_sample_width;
++ if (MCU_cols > 0 && info->x_crop_offset + MCU_cols ==
++ full_width / info->iMCU_sample_width)
++ info->output_width = MCU_cols * info->iMCU_sample_width;
++}
++
++LOCAL(void)
++trim_bottom_edge (jpeg_transform_info *info, JDIMENSION full_height)
++{
++ JDIMENSION MCU_rows;
++
++ MCU_rows = info->output_height / info->iMCU_sample_height;
++ if (MCU_rows > 0 && info->y_crop_offset + MCU_rows ==
++ full_height / info->iMCU_sample_height)
++ info->output_height = MCU_rows * info->iMCU_sample_height;
++}
++
++
++/* Request any required workspace.
++ *
++ * This routine figures out the size that the output image will be
++ * (which implies that all the transform parameters must be set before
++ * it is called).
++ *
++ * We allocate the workspace virtual arrays from the source decompression
++ * object, so that all the arrays (both the original data and the workspace)
++ * will be taken into account while making memory management decisions.
++ * Hence, this routine must be called after jpeg_read_header (which reads
++ * the image dimensions) and before jpeg_read_coefficients (which realizes
++ * the source's virtual arrays).
++ *
++ * This function returns FALSE right away if -perfect is given
++ * and transformation is not perfect. Otherwise returns TRUE.
++ */
++
++GLOBAL(boolean)
++jtransform_request_workspace (j_decompress_ptr srcinfo,
++ jpeg_transform_info *info)
++{
++ jvirt_barray_ptr *coef_arrays;
++ boolean need_workspace, transpose_it;
++ jpeg_component_info *compptr;
++ JDIMENSION xoffset, yoffset;
++ JDIMENSION width_in_iMCUs, height_in_iMCUs;
++ JDIMENSION width_in_blocks, height_in_blocks;
++ int ci, h_samp_factor, v_samp_factor;
++
++ /* Determine number of components in output image */
++ if (info->force_grayscale &&
++ srcinfo->jpeg_color_space == JCS_YCbCr &&
++ srcinfo->num_components == 3)
++ /* We'll only process the first component */
++ info->num_components = 1;
++ else
++ /* Process all the components */
++ info->num_components = srcinfo->num_components;
++
++ /* Compute output image dimensions and related values. */
++#if JPEG_LIB_VERSION >= 80
++ jpeg_core_output_dimensions(srcinfo);
++#else
++ srcinfo->output_width = srcinfo->image_width;
++ srcinfo->output_height = srcinfo->image_height;
++#endif
++
++ /* Return right away if -perfect is given and transformation is not perfect.
++ */
++ if (info->perfect) {
++ if (info->num_components == 1) {
++ if (!jtransform_perfect_transform(srcinfo->output_width,
++ srcinfo->output_height,
++ srcinfo->_min_DCT_h_scaled_size,
++ srcinfo->_min_DCT_v_scaled_size,
++ info->transform))
++ return FALSE;
++ } else {
++ if (!jtransform_perfect_transform(srcinfo->output_width,
++ srcinfo->output_height,
++ srcinfo->max_h_samp_factor * srcinfo->_min_DCT_h_scaled_size,
++ srcinfo->max_v_samp_factor * srcinfo->_min_DCT_v_scaled_size,
++ info->transform))
++ return FALSE;
++ }
++ }
++
++ /* If there is only one output component, force the iMCU size to be 1;
++ * else use the source iMCU size. (This allows us to do the right thing
++ * when reducing color to grayscale, and also provides a handy way of
++ * cleaning up "funny" grayscale images whose sampling factors are not 1x1.)
++ */
++ switch (info->transform) {
++ case JXFORM_TRANSPOSE:
++ case JXFORM_TRANSVERSE:
++ case JXFORM_ROT_90:
++ case JXFORM_ROT_270:
++ info->output_width = srcinfo->output_height;
++ info->output_height = srcinfo->output_width;
++ if (info->num_components == 1) {
++ info->iMCU_sample_width = srcinfo->_min_DCT_v_scaled_size;
++ info->iMCU_sample_height = srcinfo->_min_DCT_h_scaled_size;
++ } else {
++ info->iMCU_sample_width =
++ srcinfo->max_v_samp_factor * srcinfo->_min_DCT_v_scaled_size;
++ info->iMCU_sample_height =
++ srcinfo->max_h_samp_factor * srcinfo->_min_DCT_h_scaled_size;
++ }
++ break;
++ default:
++ info->output_width = srcinfo->output_width;
++ info->output_height = srcinfo->output_height;
++ if (info->num_components == 1) {
++ info->iMCU_sample_width = srcinfo->_min_DCT_h_scaled_size;
++ info->iMCU_sample_height = srcinfo->_min_DCT_v_scaled_size;
++ } else {
++ info->iMCU_sample_width =
++ srcinfo->max_h_samp_factor * srcinfo->_min_DCT_h_scaled_size;
++ info->iMCU_sample_height =
++ srcinfo->max_v_samp_factor * srcinfo->_min_DCT_v_scaled_size;
++ }
++ break;
++ }
++
++ /* If cropping has been requested, compute the crop area's position and
++ * dimensions, ensuring that its upper left corner falls at an iMCU boundary.
++ */
++ if (info->crop) {
++ /* Insert default values for unset crop parameters */
++ if (info->crop_xoffset_set == JCROP_UNSET)
++ info->crop_xoffset = 0; /* default to +0 */
++ if (info->crop_yoffset_set == JCROP_UNSET)
++ info->crop_yoffset = 0; /* default to +0 */
++ if (info->crop_xoffset >= info->output_width ||
++ info->crop_yoffset >= info->output_height)
++ ERREXIT(srcinfo, JERR_BAD_CROP_SPEC);
++ if (info->crop_width_set == JCROP_UNSET)
++ info->crop_width = info->output_width - info->crop_xoffset;
++ if (info->crop_height_set == JCROP_UNSET)
++ info->crop_height = info->output_height - info->crop_yoffset;
++ /* Ensure parameters are valid */
++ if (info->crop_width <= 0 || info->crop_width > info->output_width ||
++ info->crop_height <= 0 || info->crop_height > info->output_height ||
++ info->crop_xoffset > info->output_width - info->crop_width ||
++ info->crop_yoffset > info->output_height - info->crop_height)
++ ERREXIT(srcinfo, JERR_BAD_CROP_SPEC);
++ /* Convert negative crop offsets into regular offsets */
++ if (info->crop_xoffset_set == JCROP_NEG)
++ xoffset = info->output_width - info->crop_width - info->crop_xoffset;
++ else
++ xoffset = info->crop_xoffset;
++ if (info->crop_yoffset_set == JCROP_NEG)
++ yoffset = info->output_height - info->crop_height - info->crop_yoffset;
++ else
++ yoffset = info->crop_yoffset;
++ /* Now adjust so that upper left corner falls at an iMCU boundary */
++ if (info->crop_width_set == JCROP_FORCE)
++ info->output_width = info->crop_width;
++ else
++ info->output_width =
++ info->crop_width + (xoffset % info->iMCU_sample_width);
++ if (info->crop_height_set == JCROP_FORCE)
++ info->output_height = info->crop_height;
++ else
++ info->output_height =
++ info->crop_height + (yoffset % info->iMCU_sample_height);
++ /* Save x/y offsets measured in iMCUs */
++ info->x_crop_offset = xoffset / info->iMCU_sample_width;
++ info->y_crop_offset = yoffset / info->iMCU_sample_height;
++ } else {
++ info->x_crop_offset = 0;
++ info->y_crop_offset = 0;
++ }
++
++ /* Figure out whether we need workspace arrays,
++ * and if so whether they are transposed relative to the source.
++ */
++ need_workspace = FALSE;
++ transpose_it = FALSE;
++ switch (info->transform) {
++ case JXFORM_NONE:
++ if (info->x_crop_offset != 0 || info->y_crop_offset != 0)
++ need_workspace = TRUE;
++ /* No workspace needed if neither cropping nor transforming */
++ break;
++ case JXFORM_FLIP_H:
++ if (info->trim)
++ trim_right_edge(info, srcinfo->output_width);
++ if (info->y_crop_offset != 0 || info->slow_hflip)
++ need_workspace = TRUE;
++ /* do_flip_h_no_crop doesn't need a workspace array */
++ break;
++ case JXFORM_FLIP_V:
++ if (info->trim)
++ trim_bottom_edge(info, srcinfo->output_height);
++ /* Need workspace arrays having same dimensions as source image. */
++ need_workspace = TRUE;
++ break;
++ case JXFORM_TRANSPOSE:
++ /* transpose does NOT have to trim anything */
++ /* Need workspace arrays having transposed dimensions. */
++ need_workspace = TRUE;
++ transpose_it = TRUE;
++ break;
++ case JXFORM_TRANSVERSE:
++ if (info->trim) {
++ trim_right_edge(info, srcinfo->output_height);
++ trim_bottom_edge(info, srcinfo->output_width);
++ }
++ /* Need workspace arrays having transposed dimensions. */
++ need_workspace = TRUE;
++ transpose_it = TRUE;
++ break;
++ case JXFORM_ROT_90:
++ if (info->trim)
++ trim_right_edge(info, srcinfo->output_height);
++ /* Need workspace arrays having transposed dimensions. */
++ need_workspace = TRUE;
++ transpose_it = TRUE;
++ break;
++ case JXFORM_ROT_180:
++ if (info->trim) {
++ trim_right_edge(info, srcinfo->output_width);
++ trim_bottom_edge(info, srcinfo->output_height);
++ }
++ /* Need workspace arrays having same dimensions as source image. */
++ need_workspace = TRUE;
++ break;
++ case JXFORM_ROT_270:
++ if (info->trim)
++ trim_bottom_edge(info, srcinfo->output_width);
++ /* Need workspace arrays having transposed dimensions. */
++ need_workspace = TRUE;
++ transpose_it = TRUE;
++ break;
++ }
++
++ /* Allocate workspace if needed.
++ * Note that we allocate arrays padded out to the next iMCU boundary,
++ * so that transform routines need not worry about missing edge blocks.
++ */
++ if (need_workspace) {
++ coef_arrays = (jvirt_barray_ptr *)
++ (*srcinfo->mem->alloc_small) ((j_common_ptr) srcinfo, JPOOL_IMAGE,
++ SIZEOF(jvirt_barray_ptr) * info->num_components);
++ width_in_iMCUs = (JDIMENSION)
++ jdiv_round_up((long) info->output_width,
++ (long) info->iMCU_sample_width);
++ height_in_iMCUs = (JDIMENSION)
++ jdiv_round_up((long) info->output_height,
++ (long) info->iMCU_sample_height);
++ for (ci = 0; ci < info->num_components; ci++) {
++ compptr = srcinfo->comp_info + ci;
++ if (info->num_components == 1) {
++ /* we're going to force samp factors to 1x1 in this case */
++ h_samp_factor = v_samp_factor = 1;
++ } else if (transpose_it) {
++ h_samp_factor = compptr->v_samp_factor;
++ v_samp_factor = compptr->h_samp_factor;
++ } else {
++ h_samp_factor = compptr->h_samp_factor;
++ v_samp_factor = compptr->v_samp_factor;
++ }
++ width_in_blocks = width_in_iMCUs * h_samp_factor;
++ height_in_blocks = height_in_iMCUs * v_samp_factor;
++ coef_arrays[ci] = (*srcinfo->mem->request_virt_barray)
++ ((j_common_ptr) srcinfo, JPOOL_IMAGE, FALSE,
++ width_in_blocks, height_in_blocks, (JDIMENSION) v_samp_factor);
++ }
++ info->workspace_coef_arrays = coef_arrays;
++ } else
++ info->workspace_coef_arrays = NULL;
++
++ return TRUE;
++}
++
++
++/* Transpose destination image parameters */
++
++LOCAL(void)
++transpose_critical_parameters (j_compress_ptr dstinfo)
++{
++ int tblno, i, j, ci, itemp;
++ jpeg_component_info *compptr;
++ JQUANT_TBL *qtblptr;
++ JDIMENSION jtemp;
++ UINT16 qtemp;
++
++ /* Transpose image dimensions */
++ jtemp = dstinfo->image_width;
++ dstinfo->image_width = dstinfo->image_height;
++ dstinfo->image_height = jtemp;
++#if JPEG_LIB_VERSION >= 70
++ itemp = dstinfo->min_DCT_h_scaled_size;
++ dstinfo->min_DCT_h_scaled_size = dstinfo->min_DCT_v_scaled_size;
++ dstinfo->min_DCT_v_scaled_size = itemp;
++#endif
++
++ /* Transpose sampling factors */
++ for (ci = 0; ci < dstinfo->num_components; ci++) {
++ compptr = dstinfo->comp_info + ci;
++ itemp = compptr->h_samp_factor;
++ compptr->h_samp_factor = compptr->v_samp_factor;
++ compptr->v_samp_factor = itemp;
++ }
++
++ /* Transpose quantization tables */
++ for (tblno = 0; tblno < NUM_QUANT_TBLS; tblno++) {
++ qtblptr = dstinfo->quant_tbl_ptrs[tblno];
++ if (qtblptr != NULL) {
++ for (i = 0; i < DCTSIZE; i++) {
++ for (j = 0; j < i; j++) {
++ qtemp = qtblptr->quantval[i*DCTSIZE+j];
++ qtblptr->quantval[i*DCTSIZE+j] = qtblptr->quantval[j*DCTSIZE+i];
++ qtblptr->quantval[j*DCTSIZE+i] = qtemp;
++ }
++ }
++ }
++ }
++}
++
++
++/* Adjust Exif image parameters.
++ *
++ * We try to adjust the Tags ExifImageWidth and ExifImageHeight if possible.
++ */
++
++#if JPEG_LIB_VERSION >= 70
++LOCAL(void)
++adjust_exif_parameters (JOCTET FAR * data, unsigned int length,
++ JDIMENSION new_width, JDIMENSION new_height)
++{
++ boolean is_motorola; /* Flag for byte order */
++ unsigned int number_of_tags, tagnum;
++ unsigned int firstoffset, offset;
++ JDIMENSION new_value;
++
++ if (length < 12) return; /* Length of an IFD entry */
++
++ /* Discover byte order */
++ if (GETJOCTET(data[0]) == 0x49 && GETJOCTET(data[1]) == 0x49)
++ is_motorola = FALSE;
++ else if (GETJOCTET(data[0]) == 0x4D && GETJOCTET(data[1]) == 0x4D)
++ is_motorola = TRUE;
++ else
++ return;
++
++ /* Check Tag Mark */
++ if (is_motorola) {
++ if (GETJOCTET(data[2]) != 0) return;
++ if (GETJOCTET(data[3]) != 0x2A) return;
++ } else {
++ if (GETJOCTET(data[3]) != 0) return;
++ if (GETJOCTET(data[2]) != 0x2A) return;
++ }
++
++ /* Get first IFD offset (offset to IFD0) */
++ if (is_motorola) {
++ if (GETJOCTET(data[4]) != 0) return;
++ if (GETJOCTET(data[5]) != 0) return;
++ firstoffset = GETJOCTET(data[6]);
++ firstoffset <<= 8;
++ firstoffset += GETJOCTET(data[7]);
++ } else {
++ if (GETJOCTET(data[7]) != 0) return;
++ if (GETJOCTET(data[6]) != 0) return;
++ firstoffset = GETJOCTET(data[5]);
++ firstoffset <<= 8;
++ firstoffset += GETJOCTET(data[4]);
++ }
++ if (firstoffset > length - 2) return; /* check end of data segment */
++
++ /* Get the number of directory entries contained in this IFD */
++ if (is_motorola) {
++ number_of_tags = GETJOCTET(data[firstoffset]);
++ number_of_tags <<= 8;
++ number_of_tags += GETJOCTET(data[firstoffset+1]);
++ } else {
++ number_of_tags = GETJOCTET(data[firstoffset+1]);
++ number_of_tags <<= 8;
++ number_of_tags += GETJOCTET(data[firstoffset]);
++ }
++ if (number_of_tags == 0) return;
++ firstoffset += 2;
++
++ /* Search for ExifSubIFD offset Tag in IFD0 */
++ for (;;) {
++ if (firstoffset > length - 12) return; /* check end of data segment */
++ /* Get Tag number */
++ if (is_motorola) {
++ tagnum = GETJOCTET(data[firstoffset]);
++ tagnum <<= 8;
++ tagnum += GETJOCTET(data[firstoffset+1]);
++ } else {
++ tagnum = GETJOCTET(data[firstoffset+1]);
++ tagnum <<= 8;
++ tagnum += GETJOCTET(data[firstoffset]);
++ }
++ if (tagnum == 0x8769) break; /* found ExifSubIFD offset Tag */
++ if (--number_of_tags == 0) return;
++ firstoffset += 12;
++ }
++
++ /* Get the ExifSubIFD offset */
++ if (is_motorola) {
++ if (GETJOCTET(data[firstoffset+8]) != 0) return;
++ if (GETJOCTET(data[firstoffset+9]) != 0) return;
++ offset = GETJOCTET(data[firstoffset+10]);
++ offset <<= 8;
++ offset += GETJOCTET(data[firstoffset+11]);
++ } else {
++ if (GETJOCTET(data[firstoffset+11]) != 0) return;
++ if (GETJOCTET(data[firstoffset+10]) != 0) return;
++ offset = GETJOCTET(data[firstoffset+9]);
++ offset <<= 8;
++ offset += GETJOCTET(data[firstoffset+8]);
++ }
++ if (offset > length - 2) return; /* check end of data segment */
++
++ /* Get the number of directory entries contained in this SubIFD */
++ if (is_motorola) {
++ number_of_tags = GETJOCTET(data[offset]);
++ number_of_tags <<= 8;
++ number_of_tags += GETJOCTET(data[offset+1]);
++ } else {
++ number_of_tags = GETJOCTET(data[offset+1]);
++ number_of_tags <<= 8;
++ number_of_tags += GETJOCTET(data[offset]);
++ }
++ if (number_of_tags < 2) return;
++ offset += 2;
++
++ /* Search for ExifImageWidth and ExifImageHeight Tags in this SubIFD */
++ do {
++ if (offset > length - 12) return; /* check end of data segment */
++ /* Get Tag number */
++ if (is_motorola) {
++ tagnum = GETJOCTET(data[offset]);
++ tagnum <<= 8;
++ tagnum += GETJOCTET(data[offset+1]);
++ } else {
++ tagnum = GETJOCTET(data[offset+1]);
++ tagnum <<= 8;
++ tagnum += GETJOCTET(data[offset]);
++ }
++ if (tagnum == 0xA002 || tagnum == 0xA003) {
++ if (tagnum == 0xA002)
++ new_value = new_width; /* ExifImageWidth Tag */
++ else
++ new_value = new_height; /* ExifImageHeight Tag */
++ if (is_motorola) {
++ data[offset+2] = 0; /* Format = unsigned long (4 octets) */
++ data[offset+3] = 4;
++ data[offset+4] = 0; /* Number Of Components = 1 */
++ data[offset+5] = 0;
++ data[offset+6] = 0;
++ data[offset+7] = 1;
++ data[offset+8] = 0;
++ data[offset+9] = 0;
++ data[offset+10] = (JOCTET)((new_value >> 8) & 0xFF);
++ data[offset+11] = (JOCTET)(new_value & 0xFF);
++ } else {
++ data[offset+2] = 4; /* Format = unsigned long (4 octets) */
++ data[offset+3] = 0;
++ data[offset+4] = 1; /* Number Of Components = 1 */
++ data[offset+5] = 0;
++ data[offset+6] = 0;
++ data[offset+7] = 0;
++ data[offset+8] = (JOCTET)(new_value & 0xFF);
++ data[offset+9] = (JOCTET)((new_value >> 8) & 0xFF);
++ data[offset+10] = 0;
++ data[offset+11] = 0;
++ }
++ }
++ offset += 12;
++ } while (--number_of_tags);
++}
++#endif
++
++
++/* Adjust output image parameters as needed.
++ *
++ * This must be called after jpeg_copy_critical_parameters()
++ * and before jpeg_write_coefficients().
++ *
++ * The return value is the set of virtual coefficient arrays to be written
++ * (either the ones allocated by jtransform_request_workspace, or the
++ * original source data arrays). The caller will need to pass this value
++ * to jpeg_write_coefficients().
++ */
++
++GLOBAL(jvirt_barray_ptr *)
++jtransform_adjust_parameters (j_decompress_ptr srcinfo,
++ j_compress_ptr dstinfo,
++ jvirt_barray_ptr *src_coef_arrays,
++ jpeg_transform_info *info)
++{
++ /* If force-to-grayscale is requested, adjust destination parameters */
++ if (info->force_grayscale) {
++ /* First, ensure we have YCbCr or grayscale data, and that the source's
++ * Y channel is full resolution. (No reasonable person would make Y
++ * be less than full resolution, so actually coping with that case
++ * isn't worth extra code space. But we check it to avoid crashing.)
++ */
++ if (((dstinfo->jpeg_color_space == JCS_YCbCr &&
++ dstinfo->num_components == 3) ||
++ (dstinfo->jpeg_color_space == JCS_GRAYSCALE &&
++ dstinfo->num_components == 1)) &&
++ srcinfo->comp_info[0].h_samp_factor == srcinfo->max_h_samp_factor &&
++ srcinfo->comp_info[0].v_samp_factor == srcinfo->max_v_samp_factor) {
++ /* We use jpeg_set_colorspace to make sure subsidiary settings get fixed
++ * properly. Among other things, it sets the target h_samp_factor &
++ * v_samp_factor to 1, which typically won't match the source.
++ * We have to preserve the source's quantization table number, however.
++ */
++ int sv_quant_tbl_no = dstinfo->comp_info[0].quant_tbl_no;
++ jpeg_set_colorspace(dstinfo, JCS_GRAYSCALE);
++ dstinfo->comp_info[0].quant_tbl_no = sv_quant_tbl_no;
++ } else {
++ /* Sorry, can't do it */
++ ERREXIT(dstinfo, JERR_CONVERSION_NOTIMPL);
++ }
++ } else if (info->num_components == 1) {
++ /* For a single-component source, we force the destination sampling factors
++ * to 1x1, with or without force_grayscale. This is useful because some
++ * decoders choke on grayscale images with other sampling factors.
++ */
++ dstinfo->comp_info[0].h_samp_factor = 1;
++ dstinfo->comp_info[0].v_samp_factor = 1;
++ }
++
++ /* Correct the destination's image dimensions as necessary
++ * for rotate/flip, resize, and crop operations.
++ */
++#if JPEG_LIB_VERSION >= 70
++ dstinfo->jpeg_width = info->output_width;
++ dstinfo->jpeg_height = info->output_height;
++#endif
++
++ /* Transpose destination image parameters */
++ switch (info->transform) {
++ case JXFORM_TRANSPOSE:
++ case JXFORM_TRANSVERSE:
++ case JXFORM_ROT_90:
++ case JXFORM_ROT_270:
++#if JPEG_LIB_VERSION < 70
++ dstinfo->image_width = info->output_height;
++ dstinfo->image_height = info->output_width;
++#endif
++ transpose_critical_parameters(dstinfo);
++ break;
++ default:
++#if JPEG_LIB_VERSION < 70
++ dstinfo->image_width = info->output_width;
++ dstinfo->image_height = info->output_height;
++#endif
++ break;
++ }
++
++ /* Adjust Exif properties */
++ if (srcinfo->marker_list != NULL &&
++ srcinfo->marker_list->marker == JPEG_APP0+1 &&
++ srcinfo->marker_list->data_length >= 6 &&
++ GETJOCTET(srcinfo->marker_list->data[0]) == 0x45 &&
++ GETJOCTET(srcinfo->marker_list->data[1]) == 0x78 &&
++ GETJOCTET(srcinfo->marker_list->data[2]) == 0x69 &&
++ GETJOCTET(srcinfo->marker_list->data[3]) == 0x66 &&
++ GETJOCTET(srcinfo->marker_list->data[4]) == 0 &&
++ GETJOCTET(srcinfo->marker_list->data[5]) == 0) {
++ /* Suppress output of JFIF marker */
++ dstinfo->write_JFIF_header = FALSE;
++#if JPEG_LIB_VERSION >= 70
++ /* Adjust Exif image parameters */
++ if (dstinfo->jpeg_width != srcinfo->image_width ||
++ dstinfo->jpeg_height != srcinfo->image_height)
++ /* Align data segment to start of TIFF structure for parsing */
++ adjust_exif_parameters(srcinfo->marker_list->data + 6,
++ srcinfo->marker_list->data_length - 6,
++ dstinfo->jpeg_width, dstinfo->jpeg_height);
++#endif
++ }
++
++ /* Return the appropriate output data set */
++ if (info->workspace_coef_arrays != NULL)
++ return info->workspace_coef_arrays;
++ return src_coef_arrays;
++}
++
++
++/* Execute the actual transformation, if any.
++ *
++ * This must be called *after* jpeg_write_coefficients, because it depends
++ * on jpeg_write_coefficients to have computed subsidiary values such as
++ * the per-component width and height fields in the destination object.
++ *
++ * Note that some transformations will modify the source data arrays!
++ */
++
++GLOBAL(void)
++jtransform_execute_transform (j_decompress_ptr srcinfo,
++ j_compress_ptr dstinfo,
++ jvirt_barray_ptr *src_coef_arrays,
++ jpeg_transform_info *info)
++{
++ jvirt_barray_ptr *dst_coef_arrays = info->workspace_coef_arrays;
++
++ /* Note: conditions tested here should match those in switch statement
++ * in jtransform_request_workspace()
++ */
++ switch (info->transform) {
++ case JXFORM_NONE:
++ if (info->x_crop_offset != 0 || info->y_crop_offset != 0)
++ do_crop(srcinfo, dstinfo, info->x_crop_offset, info->y_crop_offset,
++ src_coef_arrays, dst_coef_arrays);
++ break;
++ case JXFORM_FLIP_H:
++ if (info->y_crop_offset != 0 || info->slow_hflip)
++ do_flip_h(srcinfo, dstinfo, info->x_crop_offset, info->y_crop_offset,
++ src_coef_arrays, dst_coef_arrays);
++ else
++ do_flip_h_no_crop(srcinfo, dstinfo, info->x_crop_offset,
++ src_coef_arrays);
++ break;
++ case JXFORM_FLIP_V:
++ do_flip_v(srcinfo, dstinfo, info->x_crop_offset, info->y_crop_offset,
++ src_coef_arrays, dst_coef_arrays);
++ break;
++ case JXFORM_TRANSPOSE:
++ do_transpose(srcinfo, dstinfo, info->x_crop_offset, info->y_crop_offset,
++ src_coef_arrays, dst_coef_arrays);
++ break;
++ case JXFORM_TRANSVERSE:
++ do_transverse(srcinfo, dstinfo, info->x_crop_offset, info->y_crop_offset,
++ src_coef_arrays, dst_coef_arrays);
++ break;
++ case JXFORM_ROT_90:
++ do_rot_90(srcinfo, dstinfo, info->x_crop_offset, info->y_crop_offset,
++ src_coef_arrays, dst_coef_arrays);
++ break;
++ case JXFORM_ROT_180:
++ do_rot_180(srcinfo, dstinfo, info->x_crop_offset, info->y_crop_offset,
++ src_coef_arrays, dst_coef_arrays);
++ break;
++ case JXFORM_ROT_270:
++ do_rot_270(srcinfo, dstinfo, info->x_crop_offset, info->y_crop_offset,
++ src_coef_arrays, dst_coef_arrays);
++ break;
++ }
++}
++
++/* jtransform_perfect_transform
++ *
++ * Determine whether lossless transformation is perfectly
++ * possible for a specified image and transformation.
++ *
++ * Inputs:
++ * image_width, image_height: source image dimensions.
++ * MCU_width, MCU_height: pixel dimensions of MCU.
++ * transform: transformation identifier.
++ * Parameter sources from initialized jpeg_struct
++ * (after reading source header):
++ * image_width = cinfo.image_width
++ * image_height = cinfo.image_height
++ * MCU_width = cinfo.max_h_samp_factor * cinfo.block_size
++ * MCU_height = cinfo.max_v_samp_factor * cinfo.block_size
++ * Result:
++ * TRUE = perfect transformation possible
++ * FALSE = perfect transformation not possible
++ * (may use custom action then)
++ */
++
++GLOBAL(boolean)
++jtransform_perfect_transform(JDIMENSION image_width, JDIMENSION image_height,
++ int MCU_width, int MCU_height,
++ JXFORM_CODE transform)
++{
++ boolean result = TRUE; /* initialize TRUE */
++
++ switch (transform) {
++ case JXFORM_FLIP_H:
++ case JXFORM_ROT_270:
++ if (image_width % (JDIMENSION) MCU_width)
++ result = FALSE;
++ break;
++ case JXFORM_FLIP_V:
++ case JXFORM_ROT_90:
++ if (image_height % (JDIMENSION) MCU_height)
++ result = FALSE;
++ break;
++ case JXFORM_TRANSVERSE:
++ case JXFORM_ROT_180:
++ if (image_width % (JDIMENSION) MCU_width)
++ result = FALSE;
++ if (image_height % (JDIMENSION) MCU_height)
++ result = FALSE;
++ break;
++ default:
++ break;
++ }
++
++ return result;
++}
++
++#endif /* TRANSFORMS_SUPPORTED */
++
++
++/* Setup decompression object to save desired markers in memory.
++ * This must be called before jpeg_read_header() to have the desired effect.
++ */
++
++GLOBAL(void)
++jcopy_markers_setup (j_decompress_ptr srcinfo, JCOPY_OPTION option)
++{
++#ifdef SAVE_MARKERS_SUPPORTED
++ int m;
++
++ /* Save comments except under NONE option */
++ if (option != JCOPYOPT_NONE) {
++ jpeg_save_markers(srcinfo, JPEG_COM, 0xFFFF);
++ }
++ /* Save all types of APPn markers iff ALL option */
++ if (option == JCOPYOPT_ALL) {
++ for (m = 0; m < 16; m++)
++ jpeg_save_markers(srcinfo, JPEG_APP0 + m, 0xFFFF);
++ }
++#endif /* SAVE_MARKERS_SUPPORTED */
++}
++
++/* Copy markers saved in the given source object to the destination object.
++ * This should be called just after jpeg_start_compress() or
++ * jpeg_write_coefficients().
++ * Note that those routines will have written the SOI, and also the
++ * JFIF APP0 or Adobe APP14 markers if selected.
++ */
++
++GLOBAL(void)
++jcopy_markers_execute (j_decompress_ptr srcinfo, j_compress_ptr dstinfo,
++ JCOPY_OPTION option)
++{
++ jpeg_saved_marker_ptr marker;
++
++ /* In the current implementation, we don't actually need to examine the
++ * option flag here; we just copy everything that got saved.
++ * But to avoid confusion, we do not output JFIF and Adobe APP14 markers
++ * if the encoder library already wrote one.
++ */
++ for (marker = srcinfo->marker_list; marker != NULL; marker = marker->next) {
++ if (dstinfo->write_JFIF_header &&
++ marker->marker == JPEG_APP0 &&
++ marker->data_length >= 5 &&
++ GETJOCTET(marker->data[0]) == 0x4A &&
++ GETJOCTET(marker->data[1]) == 0x46 &&
++ GETJOCTET(marker->data[2]) == 0x49 &&
++ GETJOCTET(marker->data[3]) == 0x46 &&
++ GETJOCTET(marker->data[4]) == 0)
++ continue; /* reject duplicate JFIF */
++ if (dstinfo->write_Adobe_marker &&
++ marker->marker == JPEG_APP0+14 &&
++ marker->data_length >= 5 &&
++ GETJOCTET(marker->data[0]) == 0x41 &&
++ GETJOCTET(marker->data[1]) == 0x64 &&
++ GETJOCTET(marker->data[2]) == 0x6F &&
++ GETJOCTET(marker->data[3]) == 0x62 &&
++ GETJOCTET(marker->data[4]) == 0x65)
++ continue; /* reject duplicate Adobe */
++#ifdef NEED_FAR_POINTERS
++ /* We could use jpeg_write_marker if the data weren't FAR... */
++ {
++ unsigned int i;
++ jpeg_write_m_header(dstinfo, marker->marker, marker->data_length);
++ for (i = 0; i < marker->data_length; i++)
++ jpeg_write_m_byte(dstinfo, marker->data[i]);
++ }
++#else
++ jpeg_write_marker(dstinfo, marker->marker,
++ marker->data, marker->data_length);
++#endif
++ }
++}
+--- /dev/null
++++ freeimage/jpeg/transupp.h
+@@ -0,0 +1,220 @@
++/*
++ * transupp.h
++ *
++ * Copyright (C) 1997-2011, Thomas G. Lane, Guido Vollbeding.
++ * 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 declarations for image transformation routines and
++ * other utility code used by the jpegtran sample application. These are
++ * NOT part of the core JPEG library. But we keep these routines separate
++ * from jpegtran.c to ease the task of maintaining jpegtran-like programs
++ * that have other user interfaces.
++ *
++ * NOTE: all the routines declared here have very specific requirements
++ * about when they are to be executed during the reading and writing of the
++ * source and destination files. See the comments in transupp.c, or see
++ * jpegtran.c for an example of correct usage.
++ */
++
++/* If you happen not to want the image transform support, disable it here */
++#ifndef TRANSFORMS_SUPPORTED
++#define TRANSFORMS_SUPPORTED 1 /* 0 disables transform code */
++#endif
++
++/*
++ * Although rotating and flipping data expressed as DCT coefficients is not
++ * hard, there is an asymmetry in the JPEG format specification for images
++ * whose dimensions aren't multiples of the iMCU size. The right and bottom
++ * image edges are padded out to the next iMCU boundary with junk data; but
++ * no padding is possible at the top and left edges. If we were to flip
++ * the whole image including the pad data, then pad garbage would become
++ * visible at the top and/or left, and real pixels would disappear into the
++ * pad margins --- perhaps permanently, since encoders & decoders may not
++ * bother to preserve DCT blocks that appear to be completely outside the
++ * nominal image area. So, we have to exclude any partial iMCUs from the
++ * basic transformation.
++ *
++ * Transpose is the only transformation that can handle partial iMCUs at the
++ * right and bottom edges completely cleanly. flip_h can flip partial iMCUs
++ * at the bottom, but leaves any partial iMCUs at the right edge untouched.
++ * Similarly flip_v leaves any partial iMCUs at the bottom edge untouched.
++ * The other transforms are defined as combinations of these basic transforms
++ * and process edge blocks in a way that preserves the equivalence.
++ *
++ * The "trim" option causes untransformable partial iMCUs to be dropped;
++ * this is not strictly lossless, but it usually gives the best-looking
++ * result for odd-size images. Note that when this option is active,
++ * the expected mathematical equivalences between the transforms may not hold.
++ * (For example, -rot 270 -trim trims only the bottom edge, but -rot 90 -trim
++ * followed by -rot 180 -trim trims both edges.)
++ *
++ * We also offer a lossless-crop option, which discards data outside a given
++ * image region but losslessly preserves what is inside. Like the rotate and
++ * flip transforms, lossless crop is restricted by the JPEG format: the upper
++ * left corner of the selected region must fall on an iMCU boundary. If this
++ * does not hold for the given crop parameters, we silently move the upper left
++ * corner up and/or left to make it so, simultaneously increasing the region
++ * dimensions to keep the lower right crop corner unchanged. (Thus, the
++ * output image covers at least the requested region, but may cover more.)
++ * The adjustment of the region dimensions may be optionally disabled.
++ *
++ * We also provide a lossless-resize option, which is kind of a lossless-crop
++ * operation in the DCT coefficient block domain - it discards higher-order
++ * coefficients and losslessly preserves lower-order coefficients of a
++ * sub-block.
++ *
++ * Rotate/flip transform, resize, and crop can be requested together in a
++ * single invocation. The crop is applied last --- that is, the crop region
++ * is specified in terms of the destination image after transform/resize.
++ *
++ * We also offer a "force to grayscale" option, which simply discards the
++ * chrominance channels of a YCbCr image. This is lossless in the sense that
++ * the luminance channel is preserved exactly. It's not the same kind of
++ * thing as the rotate/flip transformations, but it's convenient to handle it
++ * as part of this package, mainly because the transformation routines have to
++ * be aware of the option to know how many components to work on.
++ */
++
++
++/* Short forms of external names for systems with brain-damaged linkers. */
++
++#ifdef NEED_SHORT_EXTERNAL_NAMES
++#define jtransform_parse_crop_spec jTrParCrop
++#define jtransform_request_workspace jTrRequest
++#define jtransform_adjust_parameters jTrAdjust
++#define jtransform_execute_transform jTrExec
++#define jtransform_perfect_transform jTrPerfect
++#define jcopy_markers_setup jCMrkSetup
++#define jcopy_markers_execute jCMrkExec
++#endif /* NEED_SHORT_EXTERNAL_NAMES */
++
++
++/*
++ * Codes for supported types of image transformations.
++ */
++
++typedef enum {
++ JXFORM_NONE, /* no transformation */
++ JXFORM_FLIP_H, /* horizontal flip */
++ JXFORM_FLIP_V, /* vertical flip */
++ JXFORM_TRANSPOSE, /* transpose across UL-to-LR axis */
++ JXFORM_TRANSVERSE, /* transpose across UR-to-LL axis */
++ JXFORM_ROT_90, /* 90-degree clockwise rotation */
++ JXFORM_ROT_180, /* 180-degree rotation */
++ JXFORM_ROT_270 /* 270-degree clockwise (or 90 ccw) */
++} JXFORM_CODE;
++
++/*
++ * Codes for crop parameters, which can individually be unspecified,
++ * positive or negative for xoffset or yoffset,
++ * positive or forced for width or height.
++ */
++
++typedef enum {
++ JCROP_UNSET,
++ JCROP_POS,
++ JCROP_NEG,
++ JCROP_FORCE
++} JCROP_CODE;
++
++/*
++ * Transform parameters struct.
++ * NB: application must not change any elements of this struct after
++ * calling jtransform_request_workspace.
++ */
++
++typedef struct {
++ /* Options: set by caller */
++ JXFORM_CODE transform; /* image transform operator */
++ boolean perfect; /* if TRUE, fail if partial MCUs are requested */
++ boolean trim; /* if TRUE, trim partial MCUs as needed */
++ boolean force_grayscale; /* if TRUE, convert color image to grayscale */
++ boolean crop; /* if TRUE, crop source image */
++ boolean slow_hflip; /* For best performance, the JXFORM_FLIP_H transform
++ normally modifies the source coefficients in place.
++ Setting this to TRUE will instead use a slower,
++ double-buffered algorithm, which leaves the source
++ coefficients in tact (necessary if other transformed
++ images must be generated from the same set of
++ coefficients. */
++
++ /* Crop parameters: application need not set these unless crop is TRUE.
++ * These can be filled in by jtransform_parse_crop_spec().
++ */
++ JDIMENSION crop_width; /* Width of selected region */
++ JCROP_CODE crop_width_set; /* (forced disables adjustment) */
++ JDIMENSION crop_height; /* Height of selected region */
++ JCROP_CODE crop_height_set; /* (forced disables adjustment) */
++ JDIMENSION crop_xoffset; /* X offset of selected region */
++ JCROP_CODE crop_xoffset_set; /* (negative measures from right edge) */
++ JDIMENSION crop_yoffset; /* Y offset of selected region */
++ JCROP_CODE crop_yoffset_set; /* (negative measures from bottom edge) */
++
++ /* Internal workspace: caller should not touch these */
++ int num_components; /* # of components in workspace */
++ jvirt_barray_ptr * workspace_coef_arrays; /* workspace for transformations */
++ JDIMENSION output_width; /* cropped destination dimensions */
++ JDIMENSION output_height;
++ JDIMENSION x_crop_offset; /* destination crop offsets measured in iMCUs */
++ JDIMENSION y_crop_offset;
++ int iMCU_sample_width; /* destination iMCU size */
++ int iMCU_sample_height;
++} jpeg_transform_info;
++
++
++#if TRANSFORMS_SUPPORTED
++
++/* Parse a crop specification (written in X11 geometry style) */
++EXTERN(boolean) jtransform_parse_crop_spec
++ JPP((jpeg_transform_info *info, const char *spec));
++/* Request any required workspace */
++EXTERN(boolean) jtransform_request_workspace
++ JPP((j_decompress_ptr srcinfo, jpeg_transform_info *info));
++/* Adjust output image parameters */
++EXTERN(jvirt_barray_ptr *) jtransform_adjust_parameters
++ JPP((j_decompress_ptr srcinfo, j_compress_ptr dstinfo,
++ jvirt_barray_ptr *src_coef_arrays,
++ jpeg_transform_info *info));
++/* Execute the actual transformation, if any */
++EXTERN(void) jtransform_execute_transform
++ JPP((j_decompress_ptr srcinfo, j_compress_ptr dstinfo,
++ jvirt_barray_ptr *src_coef_arrays,
++ jpeg_transform_info *info));
++/* Determine whether lossless transformation is perfectly
++ * possible for a specified image and transformation.
++ */
++EXTERN(boolean) jtransform_perfect_transform
++ JPP((JDIMENSION image_width, JDIMENSION image_height,
++ int MCU_width, int MCU_height,
++ JXFORM_CODE transform));
++
++/* jtransform_execute_transform used to be called
++ * jtransform_execute_transformation, but some compilers complain about
++ * routine names that long. This macro is here to avoid breaking any
++ * old source code that uses the original name...
++ */
++#define jtransform_execute_transformation jtransform_execute_transform
++
++#endif /* TRANSFORMS_SUPPORTED */
++
++
++/*
++ * Support for copying optional markers from source to destination file.
++ */
++
++typedef enum {
++ JCOPYOPT_NONE, /* copy no optional markers */
++ JCOPYOPT_COMMENTS, /* copy only comment (COM) markers */
++ JCOPYOPT_ALL /* copy all optional markers */
++} JCOPY_OPTION;
++
++#define JCOPYOPT_DEFAULT JCOPYOPT_COMMENTS /* recommended default */
++
++/* Setup decompression object to save desired markers in memory */
++EXTERN(void) jcopy_markers_setup
++ JPP((j_decompress_ptr srcinfo, JCOPY_OPTION option));
++/* Copy markers saved in the given source object to the destination object */
++EXTERN(void) jcopy_markers_execute
++ JPP((j_decompress_ptr srcinfo, j_compress_ptr dstinfo,
++ JCOPY_OPTION option));
+--- freeimage.orig/genfipsrclist.sh
++++ freeimage/genfipsrclist.sh
+@@ -13,7 +13,7 @@ for DIR in $DIRLIST; do
+ egrep 'RelativePath=.*\.(c|cpp)' $DIR/*.2008.vcproj | cut -d'"' -f2 | tr '\\' '/' | awk '{print "'$DIR'/"$0}' | tr '\r\n' ' ' | tr -s ' ' >> fipMakefile.srcs
+ fi
+ done
+-echo -n ' Source/LibJPEG/transupp.c' >> fipMakefile.srcs
++echo -n ' jpeg/transupp.c' >> fipMakefile.srcs
+ echo >> fipMakefile.srcs
+
+ echo -n "INCLUDE =" >> fipMakefile.srcs
diff --git a/debian/patches/disable_embedded_libraries.patch b/debian/patches/disable_embedded_libraries.patch
index 760dea3..603b63d 100644
--- a/debian/patches/disable_embedded_libraries.patch
+++ b/debian/patches/disable_embedded_libraries.patch
@@ -15,10 +15,10 @@ Author: Julien Cristau <jcristau at debian.org>
Author: Evan Broder <evan at ebroder.net>
Last-Update: 2011-12-04
-Index: freeimage/gensrclist.sh
+Index: freeimage-3.15.4/gensrclist.sh
===================================================================
---- freeimage.orig/gensrclist.sh 2014-01-20 00:15:38.278122337 -0500
-+++ freeimage/gensrclist.sh 2014-01-20 00:15:38.270122337 -0500
+--- freeimage-3.15.4.orig/gensrclist.sh
++++ freeimage-3.15.4/gensrclist.sh
@@ -1,6 +1,6 @@
#!/bin/sh
@@ -27,7 +27,7 @@ Index: freeimage/gensrclist.sh
echo "VER_MAJOR = 3" > Makefile.srcs
echo "VER_MINOR = 15.4" >> Makefile.srcs
-@@ -12,15 +12,17 @@
+@@ -12,15 +12,17 @@ for DIR in $DIRLIST; do
egrep 'RelativePath=.*\.(c|cpp)' $DIR/*.2008.vcproj | cut -d'"' -f2 | tr '\\' '/' | awk '{print "'$DIR'/"$0}' | tr '\r\n' ' ' | tr -s ' ' >> Makefile.srcs
fi
done
@@ -46,10 +46,10 @@ Index: freeimage/gensrclist.sh
+echo ' $(shell pkg-config --cflags zlib OpenEXR libraw libpng libtiff-4)' >> Makefile.srcs
echo >> Makefile.srcs
-Index: freeimage/genfipsrclist.sh
+Index: freeimage-3.15.4/genfipsrclist.sh
===================================================================
---- freeimage.orig/genfipsrclist.sh 2014-01-20 00:15:38.278122337 -0500
-+++ freeimage/genfipsrclist.sh 2014-01-20 00:15:38.270122337 -0500
+--- freeimage-3.15.4.orig/genfipsrclist.sh
++++ freeimage-3.15.4/genfipsrclist.sh
@@ -1,6 +1,6 @@
#!/bin/sh
@@ -58,7 +58,7 @@ Index: freeimage/genfipsrclist.sh
echo "VER_MAJOR = 3" > fipMakefile.srcs
-@@ -13,11 +13,13 @@
+@@ -13,11 +13,13 @@ for DIR in $DIRLIST; do
egrep 'RelativePath=.*\.(c|cpp)' $DIR/*.2008.vcproj | cut -d'"' -f2 | tr '\\' '/' | awk '{print "'$DIR'/"$0}' | tr '\r\n' ' ' | tr -s ' ' >> fipMakefile.srcs
fi
done
@@ -72,10 +72,10 @@ Index: freeimage/genfipsrclist.sh
+echo ' $(shell pkg-config --cflags zlib OpenEXR libraw libpng libtiff-4)' >> fipMakefile.srcs
echo >> fipMakefile.srcs
-Index: freeimage/Source/FreeImage/ZLibInterface.cpp
+Index: freeimage-3.15.4/Source/FreeImage/ZLibInterface.cpp
===================================================================
---- freeimage.orig/Source/FreeImage/ZLibInterface.cpp 2014-01-20 00:15:38.278122337 -0500
-+++ freeimage/Source/FreeImage/ZLibInterface.cpp 2014-01-20 00:15:38.270122337 -0500
+--- freeimage-3.15.4.orig/Source/FreeImage/ZLibInterface.cpp
++++ freeimage-3.15.4/Source/FreeImage/ZLibInterface.cpp
@@ -19,10 +19,10 @@
// Use at your own risk!
// ==========================================================
@@ -89,7 +89,7 @@ Index: freeimage/Source/FreeImage/ZLibInterface.cpp
/**
Compresses a source buffer into a target buffer, using the ZLib library.
-@@ -115,7 +115,7 @@
+@@ -115,7 +115,7 @@ FreeImage_ZLibGZip(BYTE *target, DWORD t
return 0;
case Z_OK: {
// patch header, setup crc and length (stolen from mod_trace_output)
@@ -98,11 +98,11 @@ Index: freeimage/Source/FreeImage/ZLibInterface.cpp
crc = crc32(crc, source, source_size);
memcpy(target + 4 + dest_len, &crc, 4);
memcpy(target + 8 + dest_len, &source_size, 4);
-Index: freeimage/Source/FreeImage/PluginJPEG.cpp
+Index: freeimage-3.15.4/Source/FreeImage/PluginJPEG.cpp
===================================================================
---- freeimage.orig/Source/FreeImage/PluginJPEG.cpp 2014-01-20 00:15:38.278122337 -0500
-+++ freeimage/Source/FreeImage/PluginJPEG.cpp 2014-01-20 00:15:38.270122337 -0500
-@@ -35,9 +35,10 @@
+--- freeimage-3.15.4.orig/Source/FreeImage/PluginJPEG.cpp
++++ freeimage-3.15.4/Source/FreeImage/PluginJPEG.cpp
+@@ -35,9 +35,10 @@ extern "C" {
#undef FAR
#include <setjmp.h>
@@ -116,10 +116,10 @@ Index: freeimage/Source/FreeImage/PluginJPEG.cpp
}
#include "FreeImage.h"
-Index: freeimage/Source/FreeImage/PluginEXR.cpp
+Index: freeimage-3.15.4/Source/FreeImage/PluginEXR.cpp
===================================================================
---- freeimage.orig/Source/FreeImage/PluginEXR.cpp 2014-01-20 00:15:38.278122337 -0500
-+++ freeimage/Source/FreeImage/PluginEXR.cpp 2014-01-20 00:15:38.274122337 -0500
+--- freeimage-3.15.4.orig/Source/FreeImage/PluginEXR.cpp
++++ freeimage-3.15.4/Source/FreeImage/PluginEXR.cpp
@@ -22,16 +22,16 @@
#include "FreeImage.h"
@@ -147,10 +147,10 @@ Index: freeimage/Source/FreeImage/PluginEXR.cpp
// ==========================================================
-Index: freeimage/Source/FreeImage/PluginJ2K.cpp
+Index: freeimage-3.15.4/Source/FreeImage/PluginJ2K.cpp
===================================================================
---- freeimage.orig/Source/FreeImage/PluginJ2K.cpp 2014-01-20 00:15:38.278122337 -0500
-+++ freeimage/Source/FreeImage/PluginJ2K.cpp 2014-01-20 00:15:38.274122337 -0500
+--- freeimage-3.15.4.orig/Source/FreeImage/PluginJ2K.cpp
++++ freeimage-3.15.4/Source/FreeImage/PluginJ2K.cpp
@@ -21,7 +21,7 @@
#include "FreeImage.h"
@@ -160,10 +160,10 @@ Index: freeimage/Source/FreeImage/PluginJ2K.cpp
// ==========================================================
// Plugin Interface
-Index: freeimage/Source/FreeImage/PluginPNG.cpp
+Index: freeimage-3.15.4/Source/FreeImage/PluginPNG.cpp
===================================================================
---- freeimage.orig/Source/FreeImage/PluginPNG.cpp 2014-01-20 00:15:38.278122337 -0500
-+++ freeimage/Source/FreeImage/PluginPNG.cpp 2014-01-20 00:15:38.274122337 -0500
+--- freeimage-3.15.4.orig/Source/FreeImage/PluginPNG.cpp
++++ freeimage-3.15.4/Source/FreeImage/PluginPNG.cpp
@@ -37,8 +37,7 @@
// ----------------------------------------------------------
@@ -174,7 +174,7 @@ Index: freeimage/Source/FreeImage/PluginPNG.cpp
// ----------------------------------------------------------
-@@ -106,7 +105,10 @@
+@@ -106,7 +105,10 @@ ReadMetadata(png_structp png_ptr, png_in
tag = FreeImage_CreateTag();
if(!tag) return FALSE;
@@ -186,7 +186,7 @@ Index: freeimage/Source/FreeImage/PluginPNG.cpp
FreeImage_SetTagLength(tag, tag_length);
FreeImage_SetTagCount(tag, tag_length);
-@@ -149,13 +151,19 @@
+@@ -149,13 +151,19 @@ WriteMetadata(png_structp png_ptr, png_i
if(mdhandle) {
do {
memset(&text_metadata, 0, sizeof(png_text));
@@ -206,7 +206,7 @@ Index: freeimage/Source/FreeImage/PluginPNG.cpp
// set the tag
png_set_text(png_ptr, info_ptr, &text_metadata, 1);
-@@ -175,9 +183,11 @@
+@@ -175,9 +183,11 @@ WriteMetadata(png_structp png_ptr, png_i
text_metadata.key = (char*)g_png_xmp_keyword; // keyword, 1-79 character description of "text"
text_metadata.text = (char*)FreeImage_GetTagValue(tag); // comment, may be an empty string (ie "")
text_metadata.text_length = FreeImage_GetTagLength(tag);// length of the text string
@@ -218,7 +218,7 @@ Index: freeimage/Source/FreeImage/PluginPNG.cpp
// set the tag
png_set_text(png_ptr, info_ptr, &text_metadata, 1);
-@@ -559,7 +569,7 @@
+@@ -559,7 +569,7 @@ Load(FreeImageIO *io, fi_handle handle,
if (png_get_valid(png_ptr, info_ptr, PNG_INFO_iCCP)) {
png_charp profile_name = NULL;
@@ -227,7 +227,7 @@ Index: freeimage/Source/FreeImage/PluginPNG.cpp
png_uint_32 profile_length = 0;
int compression_type;
-@@ -599,7 +609,9 @@
+@@ -599,7 +609,9 @@ Load(FreeImageIO *io, fi_handle handle,
row_pointers[height - 1 - k] = FreeImage_GetScanLine(dib, k);
}
@@ -237,7 +237,7 @@ Index: freeimage/Source/FreeImage/PluginPNG.cpp
png_read_image(png_ptr, row_pointers);
// check if the bitmap contains transparency, if so enable it in the header
-@@ -843,7 +855,7 @@
+@@ -843,7 +855,7 @@ Save(FreeImageIO *io, FIBITMAP *dib, fi_
FIICCPROFILE *iccProfile = FreeImage_GetICCProfile(dib);
if (iccProfile->size && iccProfile->data) {
@@ -246,10 +246,10 @@ Index: freeimage/Source/FreeImage/PluginPNG.cpp
}
// write metadata
-Index: freeimage/Source/FreeImage/J2KHelper.cpp
+Index: freeimage-3.15.4/Source/FreeImage/J2KHelper.cpp
===================================================================
---- freeimage.orig/Source/FreeImage/J2KHelper.cpp 2014-01-20 00:15:38.278122337 -0500
-+++ freeimage/Source/FreeImage/J2KHelper.cpp 2014-01-20 00:15:38.274122337 -0500
+--- freeimage-3.15.4.orig/Source/FreeImage/J2KHelper.cpp
++++ freeimage-3.15.4/Source/FreeImage/J2KHelper.cpp
@@ -21,7 +21,7 @@
#include "FreeImage.h"
@@ -259,10 +259,10 @@ Index: freeimage/Source/FreeImage/J2KHelper.cpp
/**
Divide an integer by a power of 2 and round upwards
-Index: freeimage/Source/FreeImage/PluginJP2.cpp
+Index: freeimage-3.15.4/Source/FreeImage/PluginJP2.cpp
===================================================================
---- freeimage.orig/Source/FreeImage/PluginJP2.cpp 2014-01-20 00:15:38.278122337 -0500
-+++ freeimage/Source/FreeImage/PluginJP2.cpp 2014-01-20 00:15:38.274122337 -0500
+--- freeimage-3.15.4.orig/Source/FreeImage/PluginJP2.cpp
++++ freeimage-3.15.4/Source/FreeImage/PluginJP2.cpp
@@ -21,7 +21,7 @@
#include "FreeImage.h"
@@ -272,10 +272,10 @@ Index: freeimage/Source/FreeImage/PluginJP2.cpp
// ==========================================================
// Plugin Interface
-Index: freeimage/Source/FreeImage/PluginRAW.cpp
+Index: freeimage-3.15.4/Source/FreeImage/PluginRAW.cpp
===================================================================
---- freeimage.orig/Source/FreeImage/PluginRAW.cpp 2014-01-20 00:15:38.278122337 -0500
-+++ freeimage/Source/FreeImage/PluginRAW.cpp 2014-01-20 00:15:38.274122337 -0500
+--- freeimage-3.15.4.orig/Source/FreeImage/PluginRAW.cpp
++++ freeimage-3.15.4/Source/FreeImage/PluginRAW.cpp
@@ -19,7 +19,7 @@
// Use at your own risk!
// ==========================================================
@@ -285,11 +285,11 @@ Index: freeimage/Source/FreeImage/PluginRAW.cpp
#include "FreeImage.h"
#include "Utilities.h"
-Index: freeimage/Source/FreeImageToolkit/JPEGTransform.cpp
+Index: freeimage-3.15.4/Source/FreeImageToolkit/JPEGTransform.cpp
===================================================================
---- freeimage.orig/Source/FreeImageToolkit/JPEGTransform.cpp 2014-01-20 00:15:38.278122337 -0500
-+++ freeimage/Source/FreeImageToolkit/JPEGTransform.cpp 2014-01-20 00:15:38.274122337 -0500
-@@ -25,9 +25,10 @@
+--- freeimage-3.15.4.orig/Source/FreeImageToolkit/JPEGTransform.cpp
++++ freeimage-3.15.4/Source/FreeImageToolkit/JPEGTransform.cpp
+@@ -25,9 +25,10 @@ extern "C" {
#undef FAR
#include <setjmp.h>
@@ -303,11 +303,11 @@ Index: freeimage/Source/FreeImageToolkit/JPEGTransform.cpp
#include "../LibJPEG/transupp.h"
}
-Index: freeimage/Makefile.fip
+Index: freeimage-3.15.4/Makefile.fip
===================================================================
---- freeimage.orig/Makefile.fip 2014-01-20 00:15:38.278122337 -0500
-+++ freeimage/Makefile.fip 2014-01-20 00:15:38.274122337 -0500
-@@ -11,7 +11,7 @@
+--- freeimage-3.15.4.orig/Makefile.fip
++++ freeimage-3.15.4/Makefile.fip
+@@ -11,7 +11,7 @@ INSTALLDIR ?= $(DESTDIR)/usr/lib
# Converts cr/lf to just lf
DOS2UNIX = dos2unix
@@ -316,11 +316,11 @@ Index: freeimage/Makefile.fip
MODULES = $(SRCS:.c=.o)
MODULES := $(MODULES:.cpp=.o)
-Index: freeimage/Makefile.gnu
+Index: freeimage-3.15.4/Makefile.gnu
===================================================================
---- freeimage.orig/Makefile.gnu 2014-01-20 00:15:38.278122337 -0500
-+++ freeimage/Makefile.gnu 2014-01-20 00:15:38.274122337 -0500
-@@ -11,7 +11,7 @@
+--- freeimage-3.15.4.orig/Makefile.gnu
++++ freeimage-3.15.4/Makefile.gnu
+@@ -11,7 +11,7 @@ INSTALLDIR ?= $(DESTDIR)/usr/lib
# Converts cr/lf to just lf
DOS2UNIX = dos2unix
@@ -329,10 +329,10 @@ Index: freeimage/Makefile.gnu
MODULES = $(SRCS:.c=.o)
MODULES := $(MODULES:.cpp=.o)
-Index: freeimage/Source/FreeImage/PluginTIFF.cpp
+Index: freeimage-3.15.4/Source/FreeImage/PluginTIFF.cpp
===================================================================
---- freeimage.orig/Source/FreeImage/PluginTIFF.cpp 2014-01-20 00:15:38.278122337 -0500
-+++ freeimage/Source/FreeImage/PluginTIFF.cpp 2014-01-20 00:15:38.274122337 -0500
+--- freeimage-3.15.4.orig/Source/FreeImage/PluginTIFF.cpp
++++ freeimage-3.15.4/Source/FreeImage/PluginTIFF.cpp
@@ -39,7 +39,7 @@
#include "Utilities.h"
#include "../LibTIFF4/tiffiop.h"
@@ -342,10 +342,10 @@ Index: freeimage/Source/FreeImage/PluginTIFF.cpp
#include "FreeImageIO.h"
#include "PSDParser.h"
-Index: freeimage/Source/LibTIFF4/tiffiop.h
+Index: freeimage-3.15.4/Source/LibTIFF4/tiffiop.h
===================================================================
---- freeimage.orig/Source/LibTIFF4/tiffiop.h 2014-01-20 00:15:19.530121892 -0500
-+++ freeimage/Source/LibTIFF4/tiffiop.h 2014-01-20 00:17:42.314125285 -0500
+--- freeimage-3.15.4.orig/Source/LibTIFF4/tiffiop.h
++++ freeimage-3.15.4/Source/LibTIFF4/tiffiop.h
@@ -30,7 +30,9 @@
* ``Library-private'' definitions.
*/
diff --git a/debian/patches/fix-big-endian-detection.patch b/debian/patches/fix-big-endian-detection.patch
new file mode 100644
index 0000000..69d4838
--- /dev/null
+++ b/debian/patches/fix-big-endian-detection.patch
@@ -0,0 +1,48 @@
+Date: Wed, 1 Oct 2014 11:12:37 +0100
+From: Dejan Latinovic <Dejan.Latinovic at imgtec.com>
+Subject: fix for skimage
+
+Package skimage FTBFS on mips (and other BE arch except ppc), on testing.
+
+> ======================================================================
+> FAIL: test_freeimage.test_imread
+> ----------------------------------------------------------------------
+> Traceback (most recent call last):
+> File "/usr/lib/python2.7/dist-packages/nose/case.py", line 197, in runTest
+> self.test(*self.arg)
+> File "/usr/lib/python2.7/dist-packages/numpy/testing/decorators.py", line 146, in skipper_func
+> return f(*args, **kwargs)
+> File "/�PKGBUILDDIR�/debian/tmp/usr/lib/python2.7/dist-packages/skimage/io/tests/test_freeimage.py", line 38, in
+test_imread
+> assert all(img[274, 135] == [0, 130, 253])
+> AssertionError
+>
+> ----------------------------------------------------------------------
+> Ran 1033 tests in 1239.576s
+>
+> FAILED (SKIP=20, failures=1)
+
+Test reads info from color.png with coordinates [274, 135]. Obtained result is
+[253 130 0], instead of expected [0, 130, 253]. I seems that color format is
+twisted (RGB -> BGR) during loading of PNG. The reason for that is a fact that
+big endian was not detected right in FreeImage.h.
+
+Patch that improves big endian detection in freeimage is attached.
+
+Beside that, freeimage FTBFS on amd64, mips, mipsel and probably other archs
+because of missing build dependency. Patch that adds this dependency is
+attached.
+
+Using freeimage built with patches below, I was able to build skimage
+successfully with all tests passing.
+
+--- freeimage.orig/Source/FreeImage.h
++++ freeimage/Source/FreeImage.h
+@@ -73,6 +73,7 @@
+ // If your big endian system isn't being detected, add an OS specific check
+ #if (defined(BYTE_ORDER) && BYTE_ORDER==BIG_ENDIAN) || \
+ (defined(__BYTE_ORDER) && __BYTE_ORDER==__BIG_ENDIAN) || \
++ (defined(__BYTE_ORDER__) && __BYTE_ORDER__==__ORDER_BIG_ENDIAN__) || \
+ defined(__BIG_ENDIAN__)
+ #define FREEIMAGE_BIGENDIAN
+ #endif // BYTE_ORDER
diff --git a/debian/patches/fix_ftbfs_amd64.patch b/debian/patches/fix_ftbfs_amd64.patch
index 463905e..81ee72f 100644
--- a/debian/patches/fix_ftbfs_amd64.patch
+++ b/debian/patches/fix_ftbfs_amd64.patch
@@ -1,10 +1,8 @@
Patch that fixes several problems for building on amd64. Thanks Fedora guys.
=====================================================================
-Index: freeimage/Source/FreeImage/PluginBMP.cpp
-===================================================================
---- freeimage.orig/Source/FreeImage/PluginBMP.cpp 2014-01-14 11:43:25.776431191 -0500
-+++ freeimage/Source/FreeImage/PluginBMP.cpp 2014-01-14 11:43:25.768431191 -0500
-@@ -192,6 +192,8 @@
+--- freeimage.orig/Source/FreeImage/PluginBMP.cpp
++++ freeimage/Source/FreeImage/PluginBMP.cpp
+@@ -192,6 +192,8 @@ LoadPixelData(FreeImageIO *io, fi_handle
return TRUE;
}
@@ -13,11 +11,9 @@ Index: freeimage/Source/FreeImage/PluginBMP.cpp
/**
Load image pixels for 4-bit RLE compressed dib
@param io FreeImage IO
-Index: freeimage/Source/FreeImage.h
-===================================================================
---- freeimage.orig/Source/FreeImage.h 2014-01-13 17:15:32.449041339 -0500
-+++ freeimage/Source/FreeImage.h 2014-01-14 11:51:29.864428839 -0500
-@@ -141,8 +141,10 @@
+--- freeimage.orig/Source/FreeImage.h
++++ freeimage/Source/FreeImage.h
+@@ -141,8 +141,10 @@ typedef uint8_t BYTE;
typedef uint16_t WORD;
typedef uint32_t DWORD;
typedef int32_t LONG;
diff --git a/debian/patches/makefile_modifications.patch b/debian/patches/makefile_modifications.patch
index b4d5cf2..f1df7aa 100644
--- a/debian/patches/makefile_modifications.patch
+++ b/debian/patches/makefile_modifications.patch
@@ -2,11 +2,9 @@ Some modificatoins to the makefiles to help in build Debian packages.
Also removed -s (strip) option so we can make debug package. With the compiler
options we're using by default, debugging should still be possible.
==========================================================================
-Index: freeimage/Makefile.fip
-===================================================================
---- freeimage.orig/Makefile.fip 2014-01-13 17:29:48.737061690 -0500
-+++ freeimage/Makefile.fip 2014-01-13 17:29:48.729061689 -0500
-@@ -15,10 +15,12 @@
+--- freeimage.orig/Makefile.fip
++++ freeimage/Makefile.fip
+@@ -15,10 +15,12 @@ LIBRARIES = -lstdc++ -lmng -ljpeg -lopen
MODULES = $(SRCS:.c=.o)
MODULES := $(MODULES:.cpp=.o)
@@ -23,7 +21,7 @@ Index: freeimage/Makefile.fip
ifeq ($(shell sh -c 'uname -m 2>/dev/null || echo not'),x86_64)
CFLAGS += -fPIC
-@@ -59,7 +61,7 @@
+@@ -59,7 +61,7 @@ $(STATICLIB): $(MODULES)
$(AR) r $@ $(MODULES)
$(SHAREDLIB): $(MODULES)
@@ -32,7 +30,7 @@ Index: freeimage/Makefile.fip
install:
install -d $(INCDIR) $(INSTALLDIR)
-@@ -67,6 +69,8 @@
+@@ -67,6 +69,8 @@ install:
install -m 644 -o root -g root $(HEADERFIP) $(INCDIR)
install -m 644 -o root -g root $(STATICLIB) $(INSTALLDIR)
install -m 755 -o root -g root $(SHAREDLIB) $(INSTALLDIR)
@@ -41,11 +39,9 @@ Index: freeimage/Makefile.fip
clean:
rm -f core Dist/*.* u2dtmp* $(MODULES) $(STATICLIB) $(SHAREDLIB) $(LIBNAME)
-Index: freeimage/Makefile.gnu
-===================================================================
---- freeimage.orig/Makefile.gnu 2014-01-13 17:29:48.737061690 -0500
-+++ freeimage/Makefile.gnu 2014-01-13 17:29:48.729061689 -0500
-@@ -15,10 +15,12 @@
+--- freeimage.orig/Makefile.gnu
++++ freeimage/Makefile.gnu
+@@ -15,10 +15,12 @@ LIBRARIES = -lstdc++ -ljpeg -lmng -lopen
MODULES = $(SRCS:.c=.o)
MODULES := $(MODULES:.cpp=.o)
@@ -62,7 +58,7 @@ Index: freeimage/Makefile.gnu
ifeq ($(shell sh -c 'uname -m 2>/dev/null || echo not'),x86_64)
CFLAGS += -fPIC
-@@ -58,7 +60,7 @@
+@@ -58,7 +60,7 @@ $(STATICLIB): $(MODULES)
$(AR) r $@ $(MODULES)
$(SHAREDLIB): $(MODULES)
diff --git a/debian/patches/series b/debian/patches/series
index 46bcb26..dcf9c6a 100644
--- a/debian/patches/series
+++ b/debian/patches/series
@@ -2,3 +2,5 @@ disable_embedded_libraries.patch
fix_ftbfs_amd64.patch
makefile_modifications.patch
tag_truncation.patch
+fix-big-endian-detection.patch
+build_using_libjpeg62_transupp.c.patch
diff --git a/debian/patches/tag_truncation.patch b/debian/patches/tag_truncation.patch
index 6c9ee8c..8d6ca05 100644
--- a/debian/patches/tag_truncation.patch
+++ b/debian/patches/tag_truncation.patch
@@ -3,11 +3,9 @@ Origin: http://sourceforge.net/p/freeimage/discussion/36110/thread/3738788c/
http://freeimage.cvs.sourceforge.net/viewvc/freeimage/FreeImage/Source/Metadata/XTIFF.cpp?r1=1.23&r2=1.24&view=patch
Bug-Debian: http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=735847
-Index: freeimage/Source/Metadata/XTIFF.cpp
-===================================================================
---- freeimage.orig/Source/Metadata/XTIFF.cpp 2014-01-20 13:15:11.093762169 -0500
-+++ freeimage/Source/Metadata/XTIFF.cpp 2014-01-20 13:15:11.085766168 -0500
-@@ -451,10 +451,20 @@
+--- freeimage.orig/Source/Metadata/XTIFF.cpp
++++ freeimage/Source/Metadata/XTIFF.cpp
+@@ -451,10 +451,20 @@ tiff_read_exif_tag(TIFF *tif, TagLib::MD
FreeImage_SetTagValue(fitag, raw_data);
break;
--
Alioth's /usr/local/bin/git-commit-notice on /srv/git.debian.org/git/debian-science/packages/freeimage.git
More information about the debian-science-commits
mailing list