GIT_SILENT Upgrade ECM and KF5 version requirements for 5.73.0 release.

According to relicensecheck Brad is OK with changing LGPLv2 to LGPLv2+,
which is required to be compatible with the LGPL-2.1-or-later licensed
source files.

.gitignore

@@ -0,0 +1,22 @@
+# Ignore the following files
+*~
+*.[oa]
+*.diff
+*.kate-swp
+*.kdev4
+.kdev_include_paths
+*.kdevelop.pcs
+*.moc
+*.moc.cpp
+*.orig
+*.user
+.*.swp
+.swp.*
+Doxyfile
+Makefile
+avail
+random_seed
+/build*/
+CMakeLists.txt.user*
+*.unc-backup*
+.cmake/

.reviewboardrc

@@ -1,5 +0,0 @@
-REVIEWBOARD_URL = "https://git.reviewboard.kde.org"
-REPOSITORY = 'git://anongit.kde.org/kimageformats'
-BRANCH = 'master'
-TARGET_GROUPS = 'kdeframeworks'
-TARGET_PEOPLE = 'alexmerry'

CMakeLists.txt

@@ -1,26 +1,38 @@
-cmake_minimum_required(VERSION 2.8.12)
+cmake_minimum_required(VERSION 3.5)
 
 project(KImageFormats)
 
-find_package(ECM 1.2.0 REQUIRED NO_MODULE)
-
-set(CMAKE_MODULE_PATH ${ECM_MODULE_PATH} ${ECM_KDE_MODULE_DIR})
-
-include(KDEInstallDirs)
-include(KDEFrameworkCompilerSettings)
-include(KDECMakeSettings)
+set (CMAKE_CXX_STANDARD 14)
 
 include(FeatureSummary)
+find_package(ECM 5.73.0  NO_MODULE)
+set_package_properties(ECM PROPERTIES TYPE REQUIRED DESCRIPTION "Extra CMake Modules." URL "https://commits.kde.org/extra-cmake-modules")
+feature_summary(WHAT REQUIRED_PACKAGES_NOT_FOUND FATAL_ON_MISSING_REQUIRED_PACKAGES)
+
+
+set(CMAKE_MODULE_PATH ${ECM_MODULE_PATH})
+
+include(KDEInstallDirs)
+include(KDEFrameworkCompilerSettings NO_POLICY_SCOPE)
+include(KDECMakeSettings)
+
+
 include(CheckIncludeFiles)
 
-set(REQUIRED_QT_VERSION 5.2.0)
+set(REQUIRED_QT_VERSION 5.12.0)
 find_package(Qt5Gui ${REQUIRED_QT_VERSION} REQUIRED NO_MODULE)
 
+find_package(KF5Archive)
+set_package_properties(KF5Archive PROPERTIES
+    TYPE OPTIONAL
+    PURPOSE "Required for the QImage plugin for Krita and OpenRaster images"
+)
+
 # EPS support depends on the gs utility; non-UNIX systems are unlikely to have
 # this available in PATH
 set(BUILD_EPS_PLUGIN FALSE)
 if (UNIX)
-    find_package(Qt5PrintSupport 5.2.0 NO_MODULE)
+    find_package(Qt5PrintSupport ${REQUIRED_QT_VERSION} NO_MODULE)
     set_package_properties(Qt5PrintSupport PROPERTIES
         PURPOSE "Required for the QImage plugin for EPS images"
         TYPE OPTIONAL
@@ -30,24 +42,16 @@ if (UNIX)
     endif()
 endif()
 
-# QtImageFormats 5.3 comes with a JPEG-2000 plugin; don't duplicate it here
-# TODO: remove our JPEG-2000 plugin when we depend on Qt 5.3.
-if (Qt5Gui_VERSION VERSION_LESS 5.3.0)
-    find_package(Jasper)
-    set_package_properties(Jasper PROPERTIES
-        DESCRIPTION "A library for handling JPEG-2000 images"
-        PURPOSE "Required for the QImage plugin for JPEG-2000 images"
-        URL "http://www.ece.uvic.ca/~mdadams/jasper"
-        TYPE OPTIONAL
-    )
-endif()
-
 find_package(OpenEXR)
 set_package_properties(OpenEXR PROPERTIES
     TYPE OPTIONAL
     PURPOSE "Required for the QImage plugin for OpenEXR images"
 )
-
+add_definitions(-DQT_NO_FOREACH)
+# 050d00 (5.13) triggers a BIC in qimageiohandler.h, in Qt 5.13, so do not enable that until we can require 5.14
+# https://codereview.qt-project.org/c/qt/qtbase/+/279215
+add_definitions(-DQT_DISABLE_DEPRECATED_BEFORE=0x050c00)
+add_definitions(-DKF_DISABLE_DEPRECATED_BEFORE_AND_AT=0x054700)
 add_subdirectory(src)
 if (BUILD_TESTING)
     add_subdirectory(autotests)

LICENSES/LGPL-2.0-or-later.txt

@@ -0,0 +1,446 @@
+GNU LIBRARY GENERAL PUBLIC LICENSE
+
+Version 2, June 1991 Copyright (C) 1991 Free Software Foundation, Inc.
+
+51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
+
+Everyone is permitted to copy and distribute verbatim copies of this license
+document, but changing it is not allowed.
+
+[This is the first released version of the library GPL. It is numbered 2 because
+it goes with version 2 of the ordinary GPL.]
+
+Preamble
+
+The licenses for most software are designed to take away your freedom to share
+and change it. By contrast, the GNU General Public Licenses are intended to
+guarantee your freedom to share and change free software--to make sure the
+software is free for all its users.
+
+This license, the Library General Public License, applies to some specially
+designated Free Software Foundation software, and to any other libraries whose
+authors decide to use it. You can use it for your libraries, too.
+
+When we speak of free software, we are referring to freedom, not price. Our
+General Public Licenses are designed to make sure that you have the freedom
+to distribute copies of free software (and charge for this service if you
+wish), that you receive source code or can get it if you want it, that you
+can change the software or use pieces of it in new free programs; and that
+you know you can do these things.
+
+To protect your rights, we need to make restrictions that forbid anyone to
+deny you these rights or to ask you to surrender the rights. These restrictions
+translate to certain responsibilities for you if you distribute copies of
+the library, or if you modify it.
+
+For example, if you distribute copies of the library, whether gratis or for
+a fee, you must give the recipients all the rights that we gave you. You must
+make sure that they, too, receive or can get the source code. If you link
+a program with the library, you must provide complete object files to the
+recipients so that they can relink them with the library, after making changes
+to the library and recompiling it. And you must show them these terms so they
+know their rights.
+
+Our method of protecting your rights has two steps: (1) copyright the library,
+and (2) offer you this license which gives you legal permission to copy, distribute
+and/or modify the library.
+
+Also, for each distributor's protection, we want to make certain that everyone
+understands that there is no warranty for this free library. If the library
+is modified by someone else and passed on, we want its recipients to know
+that what they have is not the original version, so that any problems introduced
+by others will not reflect on the original authors' reputations.
+
+Finally, any free program is threatened constantly by software patents. We
+wish to avoid the danger that companies distributing free software will individually
+obtain patent licenses, thus in effect transforming the program into proprietary
+software. To prevent this, we have made it clear that any patent must be licensed
+for everyone's free use or not licensed at all.
+
+Most GNU software, including some libraries, is covered by the ordinary GNU
+General Public License, which was designed for utility programs. This license,
+the GNU Library General Public License, applies to certain designated libraries.
+This license is quite different from the ordinary one; be sure to read it
+in full, and don't assume that anything in it is the same as in the ordinary
+license.
+
+The reason we have a separate public license for some libraries is that they
+blur the distinction we usually make between modifying or adding to a program
+and simply using it. Linking a program with a library, without changing the
+library, is in some sense simply using the library, and is analogous to running
+a utility program or application program. However, in a textual and legal
+sense, the linked executable is a combined work, a derivative of the original
+library, and the ordinary General Public License treats it as such.
+
+Because of this blurred distinction, using the ordinary General Public License
+for libraries did not effectively promote software sharing, because most developers
+did not use the libraries. We concluded that weaker conditions might promote
+sharing better.
+
+However, unrestricted linking of non-free programs would deprive the users
+of those programs of all benefit from the free status of the libraries themselves.
+This Library General Public License is intended to permit developers of non-free
+programs to use free libraries, while preserving your freedom as a user of
+such programs to change the free libraries that are incorporated in them.
+(We have not seen how to achieve this as regards changes in header files,
+but we have achieved it as regards changes in the actual functions of the
+Library.) The hope is that this will lead to faster development of free libraries.
+
+The precise terms and conditions for copying, distribution and modification
+follow. Pay close attention to the difference between a "work based on the
+library" and a "work that uses the library". The former contains code derived
+from the library, while the latter only works together with the library.
+
+Note that it is possible for a library to be covered by the ordinary General
+Public License rather than by this special one.
+
+TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+
+0. This License Agreement applies to any software library which contains a
+notice placed by the copyright holder or other authorized party saying it
+may be distributed under the terms of this Library General Public License
+(also called "this License"). Each licensee is addressed as "you".
+
+A "library" means a collection of software functions and/or data prepared
+so as to be conveniently linked with application programs (which use some
+of those functions and data) to form executables.
+
+The "Library", below, refers to any such software library or work which has
+been distributed under these terms. A "work based on the Library" means either
+the Library or any derivative work under copyright law: that is to say, a
+work containing the Library or a portion of it, either verbatim or with modifications
+and/or translated straightforwardly into another language. (Hereinafter, translation
+is included without limitation in the term "modification".)
+
+"Source code" for a work means the preferred form of the work for making modifications
+to it. For a library, complete source code means all the source code for all
+modules it contains, plus any associated interface definition files, plus
+the scripts used to control compilation and installation of the library.
+
+Activities other than copying, distribution and modification are not covered
+by this License; they are outside its scope. The act of running a program
+using the Library is not restricted, and output from such a program is covered
+only if its contents constitute a work based on the Library (independent of
+the use of the Library in a tool for writing it). Whether that is true depends
+on what the Library does and what the program that uses the Library does.
+
+1. You may copy and distribute verbatim copies of the Library's complete source
+code as you receive it, in any medium, provided that you conspicuously and
+appropriately publish on each copy an appropriate copyright notice and disclaimer
+of warranty; keep intact all the notices that refer to this License and to
+the absence of any warranty; and distribute a copy of this License along with
+the Library.
+
+You may charge a fee for the physical act of transferring a copy, and you
+may at your option offer warranty protection in exchange for a fee.
+
+2. You may modify your copy or copies of the Library or any portion of it,
+thus forming a work based on the Library, and copy and distribute such modifications
+or work under the terms of Section 1 above, provided that you also meet all
+of these conditions:
+
+      a) The modified work must itself be a software library.
+
+b) You must cause the files modified to carry prominent notices stating that
+you changed the files and the date of any change.
+
+c) You must cause the whole of the work to be licensed at no charge to all
+third parties under the terms of this License.
+
+d) If a facility in the modified Library refers to a function or a table of
+data to be supplied by an application program that uses the facility, other
+than as an argument passed when the facility is invoked, then you must make
+a good faith effort to ensure that, in the event an application does not supply
+such function or table, the facility still operates, and performs whatever
+part of its purpose remains meaningful.
+
+(For example, a function in a library to compute square roots has a purpose
+that is entirely well-defined independent of the application. Therefore, Subsection
+2d requires that any application-supplied function or table used by this function
+must be optional: if the application does not supply it, the square root function
+must still compute square roots.)
+
+These requirements apply to the modified work as a whole. If identifiable
+sections of that work are not derived from the Library, and can be reasonably
+considered independent and separate works in themselves, then this License,
+and its terms, do not apply to those sections when you distribute them as
+separate works. But when you distribute the same sections as part of a whole
+which is a work based on the Library, the distribution of the whole must be
+on the terms of this License, whose permissions for other licensees extend
+to the entire whole, and thus to each and every part regardless of who wrote
+it.
+
+Thus, it is not the intent of this section to claim rights or contest your
+rights to work written entirely by you; rather, the intent is to exercise
+the right to control the distribution of derivative or collective works based
+on the Library.
+
+In addition, mere aggregation of another work not based on the Library with
+the Library (or with a work based on the Library) on a volume of a storage
+or distribution medium does not bring the other work under the scope of this
+License.
+
+3. You may opt to apply the terms of the ordinary GNU General Public License
+instead of this License to a given copy of the Library. To do this, you must
+alter all the notices that refer to this License, so that they refer to the
+ordinary GNU General Public License, version 2, instead of to this License.
+(If a newer version than version 2 of the ordinary GNU General Public License
+has appeared, then you can specify that version instead if you wish.) Do not
+make any other change in these notices.
+
+Once this change is made in a given copy, it is irreversible for that copy,
+so the ordinary GNU General Public License applies to all subsequent copies
+and derivative works made from that copy.
+
+This option is useful when you wish to copy part of the code of the Library
+into a program that is not a library.
+
+4. You may copy and distribute the Library (or a portion or derivative of
+it, under Section 2) in object code or executable form under the terms of
+Sections 1 and 2 above provided that you accompany it with the complete corresponding
+machine-readable source code, which must be distributed under the terms of
+Sections 1 and 2 above on a medium customarily used for software interchange.
+
+If distribution of object code is made by offering access to copy from a designated
+place, then offering equivalent access to copy the source code from the same
+place satisfies the requirement to distribute the source code, even though
+third parties are not compelled to copy the source along with the object code.
+
+5. A program that contains no derivative of any portion of the Library, but
+is designed to work with the Library by being compiled or linked with it,
+is called a "work that uses the Library". Such a work, in isolation, is not
+a derivative work of the Library, and therefore falls outside the scope of
+this License.
+
+However, linking a "work that uses the Library" with the Library creates an
+executable that is a derivative of the Library (because it contains portions
+of the Library), rather than a "work that uses the library". The executable
+is therefore covered by this License. Section 6 states terms for distribution
+of such executables.
+
+When a "work that uses the Library" uses material from a header file that
+is part of the Library, the object code for the work may be a derivative work
+of the Library even though the source code is not. Whether this is true is
+especially significant if the work can be linked without the Library, or if
+the work is itself a library. The threshold for this to be true is not precisely
+defined by law.
+
+If such an object file uses only numerical parameters, data structure layouts
+and accessors, and small macros and small inline functions (ten lines or less
+in length), then the use of the object file is unrestricted, regardless of
+whether it is legally a derivative work. (Executables containing this object
+code plus portions of the Library will still fall under Section 6.)
+
+Otherwise, if the work is a derivative of the Library, you may distribute
+the object code for the work under the terms of Section 6. Any executables
+containing that work also fall under Section 6, whether or not they are linked
+directly with the Library itself.
+
+6. As an exception to the Sections above, you may also compile or link a "work
+that uses the Library" with the Library to produce a work containing portions
+of the Library, and distribute that work under terms of your choice, provided
+that the terms permit modification of the work for the customer's own use
+and reverse engineering for debugging such modifications.
+
+You must give prominent notice with each copy of the work that the Library
+is used in it and that the Library and its use are covered by this License.
+You must supply a copy of this License. If the work during execution displays
+copyright notices, you must include the copyright notice for the Library among
+them, as well as a reference directing the user to the copy of this License.
+Also, you must do one of these things:
+
+a) Accompany the work with the complete corresponding machine-readable source
+code for the Library including whatever changes were used in the work (which
+must be distributed under Sections 1 and 2 above); and, if the work is an
+executable linked with the Library, with the complete machine-readable "work
+that uses the Library", as object code and/or source code, so that the user
+can modify the Library and then relink to produce a modified executable containing
+the modified Library. (It is understood that the user who changes the contents
+of definitions files in the Library will not necessarily be able to recompile
+the application to use the modified definitions.)
+
+b) Accompany the work with a written offer, valid for at least three years,
+to give the same user the materials specified in Subsection 6a, above, for
+a charge no more than the cost of performing this distribution.
+
+c) If distribution of the work is made by offering access to copy from a designated
+place, offer equivalent access to copy the above specified materials from
+the same place.
+
+d) Verify that the user has already received a copy of these materials or
+that you have already sent this user a copy.
+
+For an executable, the required form of the "work that uses the Library" must
+include any data and utility programs needed for reproducing the executable
+from it. However, as a special exception, the source code distributed need
+not include anything that is normally distributed (in either source or binary
+form) with the major components (compiler, kernel, and so on) of the operating
+system on which the executable runs, unless that component itself accompanies
+the executable.
+
+It may happen that this requirement contradicts the license restrictions of
+other proprietary libraries that do not normally accompany the operating system.
+Such a contradiction means you cannot use both them and the Library together
+in an executable that you distribute.
+
+7. You may place library facilities that are a work based on the Library side-by-side
+in a single library together with other library facilities not covered by
+this License, and distribute such a combined library, provided that the separate
+distribution of the work based on the Library and of the other library facilities
+is otherwise permitted, and provided that you do these two things:
+
+a) Accompany the combined library with a copy of the same work based on the
+Library, uncombined with any other library facilities. This must be distributed
+under the terms of the Sections above.
+
+b) Give prominent notice with the combined library of the fact that part of
+it is a work based on the Library, and explaining where to find the accompanying
+uncombined form of the same work.
+
+8. You may not copy, modify, sublicense, link with, or distribute the Library
+except as expressly provided under this License. Any attempt otherwise to
+copy, modify, sublicense, link with, or distribute the Library is void, and
+will automatically terminate your rights under this License. However, parties
+who have received copies, or rights, from you under this License will not
+have their licenses terminated so long as such parties remain in full compliance.
+
+9. You are not required to accept this License, since you have not signed
+it. However, nothing else grants you permission to modify or distribute the
+Library or its derivative works. These actions are prohibited by law if you
+do not accept this License. Therefore, by modifying or distributing the Library
+(or any work based on the Library), you indicate your acceptance of this License
+to do so, and all its terms and conditions for copying, distributing or modifying
+the Library or works based on it.
+
+10. Each time you redistribute the Library (or any work based on the Library),
+the recipient automatically receives a license from the original licensor
+to copy, distribute, link with or modify the Library subject to these terms
+and conditions. You may not impose any further restrictions on the recipients'
+exercise of the rights granted herein. You are not responsible for enforcing
+compliance by third parties to this License.
+
+11. If, as a consequence of a court judgment or allegation of patent infringement
+or for any other reason (not limited to patent issues), conditions are imposed
+on you (whether by court order, agreement or otherwise) that contradict the
+conditions of this License, they do not excuse you from the conditions of
+this License. If you cannot distribute so as to satisfy simultaneously your
+obligations under this License and any other pertinent obligations, then as
+a consequence you may not distribute the Library at all. For example, if a
+patent license would not permit royalty-free redistribution of the Library
+by all those who receive copies directly or indirectly through you, then the
+only way you could satisfy both it and this License would be to refrain entirely
+from distribution of the Library.
+
+If any portion of this section is held invalid or unenforceable under any
+particular circumstance, the balance of the section is intended to apply,
+and the section as a whole is intended to apply in other circumstances.
+
+It is not the purpose of this section to induce you to infringe any patents
+or other property right claims or to contest validity of any such claims;
+this section has the sole purpose of protecting the integrity of the free
+software distribution system which is implemented by public license practices.
+Many people have made generous contributions to the wide range of software
+distributed through that system in reliance on consistent application of that
+system; it is up to the author/donor to decide if he or she is willing to
+distribute software through any other system and a licensee cannot impose
+that choice.
+
+This section is intended to make thoroughly clear what is believed to be a
+consequence of the rest of this License.
+
+12. If the distribution and/or use of the Library is restricted in certain
+countries either by patents or by copyrighted interfaces, the original copyright
+holder who places the Library under this License may add an explicit geographical
+distribution limitation excluding those countries, so that distribution is
+permitted only in or among countries not thus excluded. In such case, this
+License incorporates the limitation as if written in the body of this License.
+
+13. The Free Software Foundation may publish revised and/or new versions of
+the Library General Public License from time to time. Such new versions will
+be similar in spirit to the present version, but may differ in detail to address
+new problems or concerns.
+
+Each version is given a distinguishing version number. If the Library specifies
+a version number of this License which applies to it and "any later version",
+you have the option of following the terms and conditions either of that version
+or of any later version published by the Free Software Foundation. If the
+Library does not specify a license version number, you may choose any version
+ever published by the Free Software Foundation.
+
+14. If you wish to incorporate parts of the Library into other free programs
+whose distribution conditions are incompatible with these, write to the author
+to ask for permission. For software which is copyrighted by the Free Software
+Foundation, write to the Free Software Foundation; we sometimes make exceptions
+for this. Our decision will be guided by the two goals of preserving the free
+status of all derivatives of our free software and of promoting the sharing
+and reuse of software generally.
+
+   NO WARRANTY
+
+15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY FOR
+THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN OTHERWISE
+STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES PROVIDE THE LIBRARY
+"AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING,
+BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE
+OF THE LIBRARY IS WITH YOU. SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME
+THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+
+16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR REDISTRIBUTE
+THE LIBRARY AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
+GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE
+OR INABILITY TO USE THE LIBRARY (INCLUDING BUT NOT LIMITED TO LOSS OF DATA
+OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES
+OR A FAILURE OF THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF SUCH
+HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+END OF TERMS AND CONDITIONS
+
+How to Apply These Terms to Your New Libraries
+
+If you develop a new library, and you want it to be of the greatest possible
+use to the public, we recommend making it free software that everyone can
+redistribute and change. You can do so by permitting redistribution under
+these terms (or, alternatively, under the terms of the ordinary General Public
+License).
+
+To apply these terms, attach the following notices to the library. It is safest
+to attach them to the start of each source file to most effectively convey
+the exclusion of warranty; and each file should have at least the "copyright"
+line and a pointer to where the full notice is found.
+
+one line to give the library's name and an idea of what it does.
+
+Copyright (C) year name of author
+
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Library General Public License as published by the Free
+Software Foundation; either version 2 of the License, or (at your option)
+any later version.
+
+This library 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 Library General Public License for more
+details.
+
+You should have received a copy of the GNU Library General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA.
+
+Also add information on how to contact you by electronic and paper mail.
+
+You should also get your employer (if you work as a programmer) or your school,
+if any, to sign a "copyright disclaimer" for the library, if necessary. Here
+is a sample; alter the names:
+
+Yoyodyne, Inc., hereby disclaims all copyright interest in
+
+the library `Frob' (a library for tweaking knobs) written
+
+by James Random Hacker.
+
+signature of Ty Coon, 1 April 1990
+
+Ty Coon, President of Vice
+
+That's all there is to it!

LICENSES/LGPL-2.1-only.txt

@@ -0,0 +1,467 @@
+GNU LESSER GENERAL PUBLIC LICENSE
+
+Version 2.1, February 1999
+
+Copyright (C) 1991, 1999 Free Software Foundation, Inc.
+
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+
+Everyone is permitted to copy and distribute verbatim copies of this license
+document, but changing it is not allowed.
+
+[This is the first released version of the Lesser GPL. It also counts as the
+successor of the GNU Library Public License, version 2, hence the version
+number 2.1.]
+
+Preamble
+
+The licenses for most software are designed to take away your freedom to share
+and change it. By contrast, the GNU General Public Licenses are intended to
+guarantee your freedom to share and change free software--to make sure the
+software is free for all its users.
+
+This license, the Lesser General Public License, applies to some specially
+designated software packages--typically libraries--of the Free Software Foundation
+and other authors who decide to use it. You can use it too, but we suggest
+you first think carefully about whether this license or the ordinary General
+Public License is the better strategy to use in any particular case, based
+on the explanations below.
+
+When we speak of free software, we are referring to freedom of use, not price.
+Our General Public Licenses are designed to make sure that you have the freedom
+to distribute copies of free software (and charge for this service if you
+wish); that you receive source code or can get it if you want it; that you
+can change the software and use pieces of it in new free programs; and that
+you are informed that you can do these things.
+
+To protect your rights, we need to make restrictions that forbid distributors
+to deny you these rights or to ask you to surrender these rights. These restrictions
+translate to certain responsibilities for you if you distribute copies of
+the library or if you modify it.
+
+For example, if you distribute copies of the library, whether gratis or for
+a fee, you must give the recipients all the rights that we gave you. You must
+make sure that they, too, receive or can get the source code. If you link
+other code with the library, you must provide complete object files to the
+recipients, so that they can relink them with the library after making changes
+to the library and recompiling it. And you must show them these terms so they
+know their rights.
+
+We protect your rights with a two-step method: (1) we copyright the library,
+and (2) we offer you this license, which gives you legal permission to copy,
+distribute and/or modify the library.
+
+To protect each distributor, we want to make it very clear that there is no
+warranty for the free library. Also, if the library is modified by someone
+else and passed on, the recipients should know that what they have is not
+the original version, so that the original author's reputation will not be
+affected by problems that might be introduced by others.
+
+Finally, software patents pose a constant threat to the existence of any free
+program. We wish to make sure that a company cannot effectively restrict the
+users of a free program by obtaining a restrictive license from a patent holder.
+Therefore, we insist that any patent license obtained for a version of the
+library must be consistent with the full freedom of use specified in this
+license.
+
+Most GNU software, including some libraries, is covered by the ordinary GNU
+General Public License. This license, the GNU Lesser General Public License,
+applies to certain designated libraries, and is quite different from the ordinary
+General Public License. We use this license for certain libraries in order
+to permit linking those libraries into non-free programs.
+
+When a program is linked with a library, whether statically or using a shared
+library, the combination of the two is legally speaking a combined work, a
+derivative of the original library. The ordinary General Public License therefore
+permits such linking only if the entire combination fits its criteria of freedom.
+The Lesser General Public License permits more lax criteria for linking other
+code with the library.
+
+We call this license the "Lesser" General Public License because it does Less
+to protect the user's freedom than the ordinary General Public License. It
+also provides other free software developers Less of an advantage over competing
+non-free programs. These disadvantages are the reason we use the ordinary
+General Public License for many libraries. However, the Lesser license provides
+advantages in certain special circumstances.
+
+For example, on rare occasions, there may be a special need to encourage the
+widest possible use of a certain library, so that it becomes a de-facto standard.
+To achieve this, non-free programs must be allowed to use the library. A more
+frequent case is that a free library does the same job as widely used non-free
+libraries. In this case, there is little to gain by limiting the free library
+to free software only, so we use the Lesser General Public License.
+
+In other cases, permission to use a particular library in non-free programs
+enables a greater number of people to use a large body of free software. For
+example, permission to use the GNU C Library in non-free programs enables
+many more people to use the whole GNU operating system, as well as its variant,
+the GNU/Linux operating system.
+
+Although the Lesser General Public License is Less protective of the users'
+freedom, it does ensure that the user of a program that is linked with the
+Library has the freedom and the wherewithal to run that program using a modified
+version of the Library.
+
+The precise terms and conditions for copying, distribution and modification
+follow. Pay close attention to the difference between a "work based on the
+library" and a "work that uses the library". The former contains code derived
+from the library, whereas the latter must be combined with the library in
+order to run.
+
+TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+
+0. This License Agreement applies to any software library or other program
+which contains a notice placed by the copyright holder or other authorized
+party saying it may be distributed under the terms of this Lesser General
+Public License (also called "this License"). Each licensee is addressed as
+"you".
+
+A "library" means a collection of software functions and/or data prepared
+so as to be conveniently linked with application programs (which use some
+of those functions and data) to form executables.
+
+The "Library", below, refers to any such software library or work which has
+been distributed under these terms. A "work based on the Library" means either
+the Library or any derivative work under copyright law: that is to say, a
+work containing the Library or a portion of it, either verbatim or with modifications
+and/or translated straightforwardly into another language. (Hereinafter, translation
+is included without limitation in the term "modification".)
+
+"Source code" for a work means the preferred form of the work for making modifications
+to it. For a library, complete source code means all the source code for all
+modules it contains, plus any associated interface definition files, plus
+the scripts used to control compilation and installation of the library.
+
+Activities other than copying, distribution and modification are not covered
+by this License; they are outside its scope. The act of running a program
+using the Library is not restricted, and output from such a program is covered
+only if its contents constitute a work based on the Library (independent of
+the use of the Library in a tool for writing it). Whether that is true depends
+on what the Library does and what the program that uses the Library does.
+
+1. You may copy and distribute verbatim copies of the Library's complete source
+code as you receive it, in any medium, provided that you conspicuously and
+appropriately publish on each copy an appropriate copyright notice and disclaimer
+of warranty; keep intact all the notices that refer to this License and to
+the absence of any warranty; and distribute a copy of this License along with
+the Library.
+
+You may charge a fee for the physical act of transferring a copy, and you
+may at your option offer warranty protection in exchange for a fee.
+
+2. You may modify your copy or copies of the Library or any portion of it,
+thus forming a work based on the Library, and copy and distribute such modifications
+or work under the terms of Section 1 above, provided that you also meet all
+of these conditions:
+
+      a) The modified work must itself be a software library.
+
+b) You must cause the files modified to carry prominent notices stating that
+you changed the files and the date of any change.
+
+c) You must cause the whole of the work to be licensed at no charge to all
+third parties under the terms of this License.
+
+d) If a facility in the modified Library refers to a function or a table of
+data to be supplied by an application program that uses the facility, other
+than as an argument passed when the facility is invoked, then you must make
+a good faith effort to ensure that, in the event an application does not supply
+such function or table, the facility still operates, and performs whatever
+part of its purpose remains meaningful.
+
+(For example, a function in a library to compute square roots has a purpose
+that is entirely well-defined independent of the application. Therefore, Subsection
+2d requires that any application-supplied function or table used by this function
+must be optional: if the application does not supply it, the square root function
+must still compute square roots.)
+
+These requirements apply to the modified work as a whole. If identifiable
+sections of that work are not derived from the Library, and can be reasonably
+considered independent and separate works in themselves, then this License,
+and its terms, do not apply to those sections when you distribute them as
+separate works. But when you distribute the same sections as part of a whole
+which is a work based on the Library, the distribution of the whole must be
+on the terms of this License, whose permissions for other licensees extend
+to the entire whole, and thus to each and every part regardless of who wrote
+it.
+
+Thus, it is not the intent of this section to claim rights or contest your
+rights to work written entirely by you; rather, the intent is to exercise
+the right to control the distribution of derivative or collective works based
+on the Library.
+
+In addition, mere aggregation of another work not based on the Library with
+the Library (or with a work based on the Library) on a volume of a storage
+or distribution medium does not bring the other work under the scope of this
+License.
+
+3. You may opt to apply the terms of the ordinary GNU General Public License
+instead of this License to a given copy of the Library. To do this, you must
+alter all the notices that refer to this License, so that they refer to the
+ordinary GNU General Public License, version 2, instead of to this License.
+(If a newer version than version 2 of the ordinary GNU General Public License
+has appeared, then you can specify that version instead if you wish.) Do not
+make any other change in these notices.
+
+Once this change is made in a given copy, it is irreversible for that copy,
+so the ordinary GNU General Public License applies to all subsequent copies
+and derivative works made from that copy.
+
+This option is useful when you wish to copy part of the code of the Library
+into a program that is not a library.
+
+4. You may copy and distribute the Library (or a portion or derivative of
+it, under Section 2) in object code or executable form under the terms of
+Sections 1 and 2 above provided that you accompany it with the complete corresponding
+machine-readable source code, which must be distributed under the terms of
+Sections 1 and 2 above on a medium customarily used for software interchange.
+
+If distribution of object code is made by offering access to copy from a designated
+place, then offering equivalent access to copy the source code from the same
+place satisfies the requirement to distribute the source code, even though
+third parties are not compelled to copy the source along with the object code.
+
+5. A program that contains no derivative of any portion of the Library, but
+is designed to work with the Library by being compiled or linked with it,
+is called a "work that uses the Library". Such a work, in isolation, is not
+a derivative work of the Library, and therefore falls outside the scope of
+this License.
+
+However, linking a "work that uses the Library" with the Library creates an
+executable that is a derivative of the Library (because it contains portions
+of the Library), rather than a "work that uses the library". The executable
+is therefore covered by this License. Section 6 states terms for distribution
+of such executables.
+
+When a "work that uses the Library" uses material from a header file that
+is part of the Library, the object code for the work may be a derivative work
+of the Library even though the source code is not. Whether this is true is
+especially significant if the work can be linked without the Library, or if
+the work is itself a library. The threshold for this to be true is not precisely
+defined by law.
+
+If such an object file uses only numerical parameters, data structure layouts
+and accessors, and small macros and small inline functions (ten lines or less
+in length), then the use of the object file is unrestricted, regardless of
+whether it is legally a derivative work. (Executables containing this object
+code plus portions of the Library will still fall under Section 6.)
+
+Otherwise, if the work is a derivative of the Library, you may distribute
+the object code for the work under the terms of Section 6. Any executables
+containing that work also fall under Section 6, whether or not they are linked
+directly with the Library itself.
+
+6. As an exception to the Sections above, you may also combine or link a "work
+that uses the Library" with the Library to produce a work containing portions
+of the Library, and distribute that work under terms of your choice, provided
+that the terms permit modification of the work for the customer's own use
+and reverse engineering for debugging such modifications.
+
+You must give prominent notice with each copy of the work that the Library
+is used in it and that the Library and its use are covered by this License.
+You must supply a copy of this License. If the work during execution displays
+copyright notices, you must include the copyright notice for the Library among
+them, as well as a reference directing the user to the copy of this License.
+Also, you must do one of these things:
+
+a) Accompany the work with the complete corresponding machine-readable source
+code for the Library including whatever changes were used in the work (which
+must be distributed under Sections 1 and 2 above); and, if the work is an
+executable linked with the Library, with the complete machine-readable "work
+that uses the Library", as object code and/or source code, so that the user
+can modify the Library and then relink to produce a modified executable containing
+the modified Library. (It is understood that the user who changes the contents
+of definitions files in the Library will not necessarily be able to recompile
+the application to use the modified definitions.)
+
+b) Use a suitable shared library mechanism for linking with the Library. A
+suitable mechanism is one that (1) uses at run time a copy of the library
+already present on the user's computer system, rather than copying library
+functions into the executable, and (2) will operate properly with a modified
+version of the library, if the user installs one, as long as the modified
+version is interface-compatible with the version that the work was made with.
+
+c) Accompany the work with a written offer, valid for at least three years,
+to give the same user the materials specified in Subsection 6a, above, for
+a charge no more than the cost of performing this distribution.
+
+d) If distribution of the work is made by offering access to copy from a designated
+place, offer equivalent access to copy the above specified materials from
+the same place.
+
+e) Verify that the user has already received a copy of these materials or
+that you have already sent this user a copy.
+
+For an executable, the required form of the "work that uses the Library" must
+include any data and utility programs needed for reproducing the executable
+from it. However, as a special exception, the materials to be distributed
+need not include anything that is normally distributed (in either source or
+binary form) with the major components (compiler, kernel, and so on) of the
+operating system on which the executable runs, unless that component itself
+accompanies the executable.
+
+It may happen that this requirement contradicts the license restrictions of
+other proprietary libraries that do not normally accompany the operating system.
+Such a contradiction means you cannot use both them and the Library together
+in an executable that you distribute.
+
+7. You may place library facilities that are a work based on the Library side-by-side
+in a single library together with other library facilities not covered by
+this License, and distribute such a combined library, provided that the separate
+distribution of the work based on the Library and of the other library facilities
+is otherwise permitted, and provided that you do these two things:
+
+a) Accompany the combined library with a copy of the same work based on the
+Library, uncombined with any other library facilities. This must be distributed
+under the terms of the Sections above.
+
+b) Give prominent notice with the combined library of the fact that part of
+it is a work based on the Library, and explaining where to find the accompanying
+uncombined form of the same work.
+
+8. You may not copy, modify, sublicense, link with, or distribute the Library
+except as expressly provided under this License. Any attempt otherwise to
+copy, modify, sublicense, link with, or distribute the Library is void, and
+will automatically terminate your rights under this License. However, parties
+who have received copies, or rights, from you under this License will not
+have their licenses terminated so long as such parties remain in full compliance.
+
+9. You are not required to accept this License, since you have not signed
+it. However, nothing else grants you permission to modify or distribute the
+Library or its derivative works. These actions are prohibited by law if you
+do not accept this License. Therefore, by modifying or distributing the Library
+(or any work based on the Library), you indicate your acceptance of this License
+to do so, and all its terms and conditions for copying, distributing or modifying
+the Library or works based on it.
+
+10. Each time you redistribute the Library (or any work based on the Library),
+the recipient automatically receives a license from the original licensor
+to copy, distribute, link with or modify the Library subject to these terms
+and conditions. You may not impose any further restrictions on the recipients'
+exercise of the rights granted herein. You are not responsible for enforcing
+compliance by third parties with this License.
+
+11. If, as a consequence of a court judgment or allegation of patent infringement
+or for any other reason (not limited to patent issues), conditions are imposed
+on you (whether by court order, agreement or otherwise) that contradict the
+conditions of this License, they do not excuse you from the conditions of
+this License. If you cannot distribute so as to satisfy simultaneously your
+obligations under this License and any other pertinent obligations, then as
+a consequence you may not distribute the Library at all. For example, if a
+patent license would not permit royalty-free redistribution of the Library
+by all those who receive copies directly or indirectly through you, then the
+only way you could satisfy both it and this License would be to refrain entirely
+from distribution of the Library.
+
+If any portion of this section is held invalid or unenforceable under any
+particular circumstance, the balance of the section is intended to apply,
+and the section as a whole is intended to apply in other circumstances.
+
+It is not the purpose of this section to induce you to infringe any patents
+or other property right claims or to contest validity of any such claims;
+this section has the sole purpose of protecting the integrity of the free
+software distribution system which is implemented by public license practices.
+Many people have made generous contributions to the wide range of software
+distributed through that system in reliance on consistent application of that
+system; it is up to the author/donor to decide if he or she is willing to
+distribute software through any other system and a licensee cannot impose
+that choice.
+
+This section is intended to make thoroughly clear what is believed to be a
+consequence of the rest of this License.
+
+12. If the distribution and/or use of the Library is restricted in certain
+countries either by patents or by copyrighted interfaces, the original copyright
+holder who places the Library under this License may add an explicit geographical
+distribution limitation excluding those countries, so that distribution is
+permitted only in or among countries not thus excluded. In such case, this
+License incorporates the limitation as if written in the body of this License.
+
+13. The Free Software Foundation may publish revised and/or new versions of
+the Lesser General Public License from time to time. Such new versions will
+be similar in spirit to the present version, but may differ in detail to address
+new problems or concerns.
+
+Each version is given a distinguishing version number. If the Library specifies
+a version number of this License which applies to it and "any later version",
+you have the option of following the terms and conditions either of that version
+or of any later version published by the Free Software Foundation. If the
+Library does not specify a license version number, you may choose any version
+ever published by the Free Software Foundation.
+
+14. If you wish to incorporate parts of the Library into other free programs
+whose distribution conditions are incompatible with these, write to the author
+to ask for permission. For software which is copyrighted by the Free Software
+Foundation, write to the Free Software Foundation; we sometimes make exceptions
+for this. Our decision will be guided by the two goals of preserving the free
+status of all derivatives of our free software and of promoting the sharing
+and reuse of software generally.
+
+   NO WARRANTY
+
+15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY FOR
+THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN OTHERWISE
+STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES PROVIDE THE LIBRARY
+"AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING,
+BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE
+OF THE LIBRARY IS WITH YOU. SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME
+THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+
+16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR REDISTRIBUTE
+THE LIBRARY AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
+GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE
+OR INABILITY TO USE THE LIBRARY (INCLUDING BUT NOT LIMITED TO LOSS OF DATA
+OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES
+OR A FAILURE OF THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF SUCH
+HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+END OF TERMS AND CONDITIONS
+
+How to Apply These Terms to Your New Libraries
+
+If you develop a new library, and you want it to be of the greatest possible
+use to the public, we recommend making it free software that everyone can
+redistribute and change. You can do so by permitting redistribution under
+these terms (or, alternatively, under the terms of the ordinary General Public
+License).
+
+To apply these terms, attach the following notices to the library. It is safest
+to attach them to the start of each source file to most effectively convey
+the exclusion of warranty; and each file should have at least the "copyright"
+line and a pointer to where the full notice is found.
+
+< one line to give the library's name and an idea of what it does. >
+
+Copyright (C) < year > < name of author >
+
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the Free
+Software Foundation; either version 2.1 of the License, or (at your option)
+any later version.
+
+This library 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 Lesser General Public License for more
+details.
+
+You should have received a copy of the GNU Lesser General Public License along
+with this library; if not, write to the Free Software Foundation, Inc., 51
+Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA Also add information
+on how to contact you by electronic and paper mail.
+
+You should also get your employer (if you work as a programmer) or your school,
+if any, to sign a "copyright disclaimer" for the library, if necessary. Here
+is a sample; alter the names:
+
+Yoyodyne, Inc., hereby disclaims all copyright interest in
+
+the library `Frob' (a library for tweaking knobs) written
+
+by James Random Hacker.
+
+< signature of Ty Coon > , 1 April 1990
+
+Ty Coon, President of Vice
+
+That's all there is to it!

LICENSES/LGPL-2.1-or-later.txt

@@ -0,0 +1,468 @@
+GNU LESSER GENERAL PUBLIC LICENSE
+
+Version 2.1, February 1999
+
+Copyright (C) 1991, 1999 Free Software Foundation, Inc.
+
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+
+Everyone is permitted to copy and distribute verbatim copies of this license
+document, but changing it is not allowed.
+
+[This is the first released version of the Lesser GPL. It also counts as the
+successor of the GNU Library Public License, version 2, hence the version
+number 2.1.]
+
+Preamble
+
+The licenses for most software are designed to take away your freedom to share
+and change it. By contrast, the GNU General Public Licenses are intended to
+guarantee your freedom to share and change free software--to make sure the
+software is free for all its users.
+
+This license, the Lesser General Public License, applies to some specially
+designated software packages--typically libraries--of the Free Software Foundation
+and other authors who decide to use it. You can use it too, but we suggest
+you first think carefully about whether this license or the ordinary General
+Public License is the better strategy to use in any particular case, based
+on the explanations below.
+
+When we speak of free software, we are referring to freedom of use, not price.
+Our General Public Licenses are designed to make sure that you have the freedom
+to distribute copies of free software (and charge for this service if you
+wish); that you receive source code or can get it if you want it; that you
+can change the software and use pieces of it in new free programs; and that
+you are informed that you can do these things.
+
+To protect your rights, we need to make restrictions that forbid distributors
+to deny you these rights or to ask you to surrender these rights. These restrictions
+translate to certain responsibilities for you if you distribute copies of
+the library or if you modify it.
+
+For example, if you distribute copies of the library, whether gratis or for
+a fee, you must give the recipients all the rights that we gave you. You must
+make sure that they, too, receive or can get the source code. If you link
+other code with the library, you must provide complete object files to the
+recipients, so that they can relink them with the library after making changes
+to the library and recompiling it. And you must show them these terms so they
+know their rights.
+
+We protect your rights with a two-step method: (1) we copyright the library,
+and (2) we offer you this license, which gives you legal permission to copy,
+distribute and/or modify the library.
+
+To protect each distributor, we want to make it very clear that there is no
+warranty for the free library. Also, if the library is modified by someone
+else and passed on, the recipients should know that what they have is not
+the original version, so that the original author's reputation will not be
+affected by problems that might be introduced by others.
+
+Finally, software patents pose a constant threat to the existence of any free
+program. We wish to make sure that a company cannot effectively restrict the
+users of a free program by obtaining a restrictive license from a patent holder.
+Therefore, we insist that any patent license obtained for a version of the
+library must be consistent with the full freedom of use specified in this
+license.
+
+Most GNU software, including some libraries, is covered by the ordinary GNU
+General Public License. This license, the GNU Lesser General Public License,
+applies to certain designated libraries, and is quite different from the ordinary
+General Public License. We use this license for certain libraries in order
+to permit linking those libraries into non-free programs.
+
+When a program is linked with a library, whether statically or using a shared
+library, the combination of the two is legally speaking a combined work, a
+derivative of the original library. The ordinary General Public License therefore
+permits such linking only if the entire combination fits its criteria of freedom.
+The Lesser General Public License permits more lax criteria for linking other
+code with the library.
+
+We call this license the "Lesser" General Public License because it does Less
+to protect the user's freedom than the ordinary General Public License. It
+also provides other free software developers Less of an advantage over competing
+non-free programs. These disadvantages are the reason we use the ordinary
+General Public License for many libraries. However, the Lesser license provides
+advantages in certain special circumstances.
+
+For example, on rare occasions, there may be a special need to encourage the
+widest possible use of a certain library, so that it becomes a de-facto standard.
+To achieve this, non-free programs must be allowed to use the library. A more
+frequent case is that a free library does the same job as widely used non-free
+libraries. In this case, there is little to gain by limiting the free library
+to free software only, so we use the Lesser General Public License.
+
+In other cases, permission to use a particular library in non-free programs
+enables a greater number of people to use a large body of free software. For
+example, permission to use the GNU C Library in non-free programs enables
+many more people to use the whole GNU operating system, as well as its variant,
+the GNU/Linux operating system.
+
+Although the Lesser General Public License is Less protective of the users'
+freedom, it does ensure that the user of a program that is linked with the
+Library has the freedom and the wherewithal to run that program using a modified
+version of the Library.
+
+The precise terms and conditions for copying, distribution and modification
+follow. Pay close attention to the difference between a "work based on the
+library" and a "work that uses the library". The former contains code derived
+from the library, whereas the latter must be combined with the library in
+order to run.
+
+TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+
+0. This License Agreement applies to any software library or other program
+which contains a notice placed by the copyright holder or other authorized
+party saying it may be distributed under the terms of this Lesser General
+Public License (also called "this License"). Each licensee is addressed as
+"you".
+
+A "library" means a collection of software functions and/or data prepared
+so as to be conveniently linked with application programs (which use some
+of those functions and data) to form executables.
+
+The "Library", below, refers to any such software library or work which has
+been distributed under these terms. A "work based on the Library" means either
+the Library or any derivative work under copyright law: that is to say, a
+work containing the Library or a portion of it, either verbatim or with modifications
+and/or translated straightforwardly into another language. (Hereinafter, translation
+is included without limitation in the term "modification".)
+
+"Source code" for a work means the preferred form of the work for making modifications
+to it. For a library, complete source code means all the source code for all
+modules it contains, plus any associated interface definition files, plus
+the scripts used to control compilation and installation of the library.
+
+Activities other than copying, distribution and modification are not covered
+by this License; they are outside its scope. The act of running a program
+using the Library is not restricted, and output from such a program is covered
+only if its contents constitute a work based on the Library (independent of
+the use of the Library in a tool for writing it). Whether that is true depends
+on what the Library does and what the program that uses the Library does.
+
+1. You may copy and distribute verbatim copies of the Library's complete source
+code as you receive it, in any medium, provided that you conspicuously and
+appropriately publish on each copy an appropriate copyright notice and disclaimer
+of warranty; keep intact all the notices that refer to this License and to
+the absence of any warranty; and distribute a copy of this License along with
+the Library.
+
+You may charge a fee for the physical act of transferring a copy, and you
+may at your option offer warranty protection in exchange for a fee.
+
+2. You may modify your copy or copies of the Library or any portion of it,
+thus forming a work based on the Library, and copy and distribute such modifications
+or work under the terms of Section 1 above, provided that you also meet all
+of these conditions:
+
+      a) The modified work must itself be a software library.
+
+b) You must cause the files modified to carry prominent notices stating that
+you changed the files and the date of any change.
+
+c) You must cause the whole of the work to be licensed at no charge to all
+third parties under the terms of this License.
+
+d) If a facility in the modified Library refers to a function or a table of
+data to be supplied by an application program that uses the facility, other
+than as an argument passed when the facility is invoked, then you must make
+a good faith effort to ensure that, in the event an application does not supply
+such function or table, the facility still operates, and performs whatever
+part of its purpose remains meaningful.
+
+(For example, a function in a library to compute square roots has a purpose
+that is entirely well-defined independent of the application. Therefore, Subsection
+2d requires that any application-supplied function or table used by this function
+must be optional: if the application does not supply it, the square root function
+must still compute square roots.)
+
+These requirements apply to the modified work as a whole. If identifiable
+sections of that work are not derived from the Library, and can be reasonably
+considered independent and separate works in themselves, then this License,
+and its terms, do not apply to those sections when you distribute them as
+separate works. But when you distribute the same sections as part of a whole
+which is a work based on the Library, the distribution of the whole must be
+on the terms of this License, whose permissions for other licensees extend
+to the entire whole, and thus to each and every part regardless of who wrote
+it.
+
+Thus, it is not the intent of this section to claim rights or contest your
+rights to work written entirely by you; rather, the intent is to exercise
+the right to control the distribution of derivative or collective works based
+on the Library.
+
+In addition, mere aggregation of another work not based on the Library with
+the Library (or with a work based on the Library) on a volume of a storage
+or distribution medium does not bring the other work under the scope of this
+License.
+
+3. You may opt to apply the terms of the ordinary GNU General Public License
+instead of this License to a given copy of the Library. To do this, you must
+alter all the notices that refer to this License, so that they refer to the
+ordinary GNU General Public License, version 2, instead of to this License.
+(If a newer version than version 2 of the ordinary GNU General Public License
+has appeared, then you can specify that version instead if you wish.) Do not
+make any other change in these notices.
+
+Once this change is made in a given copy, it is irreversible for that copy,
+so the ordinary GNU General Public License applies to all subsequent copies
+and derivative works made from that copy.
+
+This option is useful when you wish to copy part of the code of the Library
+into a program that is not a library.
+
+4. You may copy and distribute the Library (or a portion or derivative of
+it, under Section 2) in object code or executable form under the terms of
+Sections 1 and 2 above provided that you accompany it with the complete corresponding
+machine-readable source code, which must be distributed under the terms of
+Sections 1 and 2 above on a medium customarily used for software interchange.
+
+If distribution of object code is made by offering access to copy from a designated
+place, then offering equivalent access to copy the source code from the same
+place satisfies the requirement to distribute the source code, even though
+third parties are not compelled to copy the source along with the object code.
+
+5. A program that contains no derivative of any portion of the Library, but
+is designed to work with the Library by being compiled or linked with it,
+is called a "work that uses the Library". Such a work, in isolation, is not
+a derivative work of the Library, and therefore falls outside the scope of
+this License.
+
+However, linking a "work that uses the Library" with the Library creates an
+executable that is a derivative of the Library (because it contains portions
+of the Library), rather than a "work that uses the library". The executable
+is therefore covered by this License. Section 6 states terms for distribution
+of such executables.
+
+When a "work that uses the Library" uses material from a header file that
+is part of the Library, the object code for the work may be a derivative work
+of the Library even though the source code is not. Whether this is true is
+especially significant if the work can be linked without the Library, or if
+the work is itself a library. The threshold for this to be true is not precisely
+defined by law.
+
+If such an object file uses only numerical parameters, data structure layouts
+and accessors, and small macros and small inline functions (ten lines or less
+in length), then the use of the object file is unrestricted, regardless of
+whether it is legally a derivative work. (Executables containing this object
+code plus portions of the Library will still fall under Section 6.)
+
+Otherwise, if the work is a derivative of the Library, you may distribute
+the object code for the work under the terms of Section 6. Any executables
+containing that work also fall under Section 6, whether or not they are linked
+directly with the Library itself.
+
+6. As an exception to the Sections above, you may also combine or link a "work
+that uses the Library" with the Library to produce a work containing portions
+of the Library, and distribute that work under terms of your choice, provided
+that the terms permit modification of the work for the customer's own use
+and reverse engineering for debugging such modifications.
+
+You must give prominent notice with each copy of the work that the Library
+is used in it and that the Library and its use are covered by this License.
+You must supply a copy of this License. If the work during execution displays
+copyright notices, you must include the copyright notice for the Library among
+them, as well as a reference directing the user to the copy of this License.
+Also, you must do one of these things:
+
+a) Accompany the work with the complete corresponding machine-readable source
+code for the Library including whatever changes were used in the work (which
+must be distributed under Sections 1 and 2 above); and, if the work is an
+executable linked with the Library, with the complete machine-readable "work
+that uses the Library", as object code and/or source code, so that the user
+can modify the Library and then relink to produce a modified executable containing
+the modified Library. (It is understood that the user who changes the contents
+of definitions files in the Library will not necessarily be able to recompile
+the application to use the modified definitions.)
+
+b) Use a suitable shared library mechanism for linking with the Library. A
+suitable mechanism is one that (1) uses at run time a copy of the library
+already present on the user's computer system, rather than copying library
+functions into the executable, and (2) will operate properly with a modified
+version of the library, if the user installs one, as long as the modified
+version is interface-compatible with the version that the work was made with.
+
+c) Accompany the work with a written offer, valid for at least three years,
+to give the same user the materials specified in Subsection 6a, above, for
+a charge no more than the cost of performing this distribution.
+
+d) If distribution of the work is made by offering access to copy from a designated
+place, offer equivalent access to copy the above specified materials from
+the same place.
+
+e) Verify that the user has already received a copy of these materials or
+that you have already sent this user a copy.
+
+For an executable, the required form of the "work that uses the Library" must
+include any data and utility programs needed for reproducing the executable
+from it. However, as a special exception, the materials to be distributed
+need not include anything that is normally distributed (in either source or
+binary form) with the major components (compiler, kernel, and so on) of the
+operating system on which the executable runs, unless that component itself
+accompanies the executable.
+
+It may happen that this requirement contradicts the license restrictions of
+other proprietary libraries that do not normally accompany the operating system.
+Such a contradiction means you cannot use both them and the Library together
+in an executable that you distribute.
+
+7. You may place library facilities that are a work based on the Library side-by-side
+in a single library together with other library facilities not covered by
+this License, and distribute such a combined library, provided that the separate
+distribution of the work based on the Library and of the other library facilities
+is otherwise permitted, and provided that you do these two things:
+
+a) Accompany the combined library with a copy of the same work based on the
+Library, uncombined with any other library facilities. This must be distributed
+under the terms of the Sections above.
+
+b) Give prominent notice with the combined library of the fact that part of
+it is a work based on the Library, and explaining where to find the accompanying
+uncombined form of the same work.
+
+8. You may not copy, modify, sublicense, link with, or distribute the Library
+except as expressly provided under this License. Any attempt otherwise to
+copy, modify, sublicense, link with, or distribute the Library is void, and
+will automatically terminate your rights under this License. However, parties
+who have received copies, or rights, from you under this License will not
+have their licenses terminated so long as such parties remain in full compliance.
+
+9. You are not required to accept this License, since you have not signed
+it. However, nothing else grants you permission to modify or distribute the
+Library or its derivative works. These actions are prohibited by law if you
+do not accept this License. Therefore, by modifying or distributing the Library
+(or any work based on the Library), you indicate your acceptance of this License
+to do so, and all its terms and conditions for copying, distributing or modifying
+the Library or works based on it.
+
+10. Each time you redistribute the Library (or any work based on the Library),
+the recipient automatically receives a license from the original licensor
+to copy, distribute, link with or modify the Library subject to these terms
+and conditions. You may not impose any further restrictions on the recipients'
+exercise of the rights granted herein. You are not responsible for enforcing
+compliance by third parties with this License.
+
+11. If, as a consequence of a court judgment or allegation of patent infringement
+or for any other reason (not limited to patent issues), conditions are imposed
+on you (whether by court order, agreement or otherwise) that contradict the
+conditions of this License, they do not excuse you from the conditions of
+this License. If you cannot distribute so as to satisfy simultaneously your
+obligations under this License and any other pertinent obligations, then as
+a consequence you may not distribute the Library at all. For example, if a
+patent license would not permit royalty-free redistribution of the Library
+by all those who receive copies directly or indirectly through you, then the
+only way you could satisfy both it and this License would be to refrain entirely
+from distribution of the Library.
+
+If any portion of this section is held invalid or unenforceable under any
+particular circumstance, the balance of the section is intended to apply,
+and the section as a whole is intended to apply in other circumstances.
+
+It is not the purpose of this section to induce you to infringe any patents
+or other property right claims or to contest validity of any such claims;
+this section has the sole purpose of protecting the integrity of the free
+software distribution system which is implemented by public license practices.
+Many people have made generous contributions to the wide range of software
+distributed through that system in reliance on consistent application of that
+system; it is up to the author/donor to decide if he or she is willing to
+distribute software through any other system and a licensee cannot impose
+that choice.
+
+This section is intended to make thoroughly clear what is believed to be a
+consequence of the rest of this License.
+
+12. If the distribution and/or use of the Library is restricted in certain
+countries either by patents or by copyrighted interfaces, the original copyright
+holder who places the Library under this License may add an explicit geographical
+distribution limitation excluding those countries, so that distribution is
+permitted only in or among countries not thus excluded. In such case, this
+License incorporates the limitation as if written in the body of this License.
+
+13. The Free Software Foundation may publish revised and/or new versions of
+the Lesser General Public License from time to time. Such new versions will
+be similar in spirit to the present version, but may differ in detail to address
+new problems or concerns.
+
+Each version is given a distinguishing version number. If the Library specifies
+a version number of this License which applies to it and "any later version",
+you have the option of following the terms and conditions either of that version
+or of any later version published by the Free Software Foundation. If the
+Library does not specify a license version number, you may choose any version
+ever published by the Free Software Foundation.
+
+14. If you wish to incorporate parts of the Library into other free programs
+whose distribution conditions are incompatible with these, write to the author
+to ask for permission. For software which is copyrighted by the Free Software
+Foundation, write to the Free Software Foundation; we sometimes make exceptions
+for this. Our decision will be guided by the two goals of preserving the free
+status of all derivatives of our free software and of promoting the sharing
+and reuse of software generally.
+
+   NO WARRANTY
+
+15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY FOR
+THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN OTHERWISE
+STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES PROVIDE THE LIBRARY
+"AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING,
+BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE
+OF THE LIBRARY IS WITH YOU. SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME
+THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+
+16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR REDISTRIBUTE
+THE LIBRARY AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
+GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE
+OR INABILITY TO USE THE LIBRARY (INCLUDING BUT NOT LIMITED TO LOSS OF DATA
+OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES
+OR A FAILURE OF THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF SUCH
+HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+END OF TERMS AND CONDITIONS
+
+How to Apply These Terms to Your New Libraries
+
+If you develop a new library, and you want it to be of the greatest possible
+use to the public, we recommend making it free software that everyone can
+redistribute and change. You can do so by permitting redistribution under
+these terms (or, alternatively, under the terms of the ordinary General Public
+License).
+
+To apply these terms, attach the following notices to the library. It is safest
+to attach them to the start of each source file to most effectively convey
+the exclusion of warranty; and each file should have at least the "copyright"
+line and a pointer to where the full notice is found.
+
+<one line to give the library's name and an idea of what it does.>
+
+Copyright (C) <year> <name of author>
+
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the Free
+Software Foundation; either version 2.1 of the License, or (at your option)
+any later version.
+
+This library 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 Lesser General Public License for more
+details.
+
+You should have received a copy of the GNU Lesser General Public License along
+with this library; if not, write to the Free Software Foundation, Inc., 51
+Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+
+Also add information on how to contact you by electronic and paper mail.
+
+You should also get your employer (if you work as a programmer) or your school,
+if any, to sign a "copyright disclaimer" for the library, if necessary. Here
+is a sample; alter the names:
+
+Yoyodyne, Inc., hereby disclaims all copyright interest in
+
+the library `Frob' (a library for tweaking knobs) written
+
+by James Random Hacker.
+
+< signature of Ty Coon > , 1 April 1990
+
+Ty Coon, President of Vice
+
+That's all there is to it!

LICENSES/LGPL-3.0-only.txt

@@ -0,0 +1,163 @@
+GNU LESSER GENERAL PUBLIC LICENSE
+
+Version 3, 29 June 2007
+
+Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/>
+
+Everyone is permitted to copy and distribute verbatim copies of this license
+document, but changing it is not allowed.
+
+This version of the GNU Lesser General Public License incorporates the terms
+and conditions of version 3 of the GNU General Public License, supplemented
+by the additional permissions listed below.
+
+   0. Additional Definitions.
+
+      
+
+As used herein, "this License" refers to version 3 of the GNU Lesser General
+Public License, and the "GNU GPL" refers to version 3 of the GNU General Public
+License.
+
+      
+
+"The Library" refers to a covered work governed by this License, other than
+an Application or a Combined Work as defined below.
+
+      
+
+An "Application" is any work that makes use of an interface provided by the
+Library, but which is not otherwise based on the Library. Defining a subclass
+of a class defined by the Library is deemed a mode of using an interface provided
+by the Library.
+
+      
+
+A "Combined Work" is a work produced by combining or linking an Application
+with the Library. The particular version of the Library with which the Combined
+Work was made is also called the "Linked Version".
+
+      
+
+The "Minimal Corresponding Source" for a Combined Work means the Corresponding
+Source for the Combined Work, excluding any source code for portions of the
+Combined Work that, considered in isolation, are based on the Application,
+and not on the Linked Version.
+
+      
+
+The "Corresponding Application Code" for a Combined Work means the object
+code and/or source code for the Application, including any data and utility
+programs needed for reproducing the Combined Work from the Application, but
+excluding the System Libraries of the Combined Work.
+
+   1. Exception to Section 3 of the GNU GPL.
+
+You may convey a covered work under sections 3 and 4 of this License without
+being bound by section 3 of the GNU GPL.
+
+   2. Conveying Modified Versions.
+
+If you modify a copy of the Library, and, in your modifications, a facility
+refers to a function or data to be supplied by an Application that uses the
+facility (other than as an argument passed when the facility is invoked),
+then you may convey a copy of the modified version:
+
+a) under this License, provided that you make a good faith effort to ensure
+that, in the event an Application does not supply the function or data, the
+facility still operates, and performs whatever part of its purpose remains
+meaningful, or
+
+b) under the GNU GPL, with none of the additional permissions of this License
+applicable to that copy.
+
+   3. Object Code Incorporating Material from Library Header Files.
+
+The object code form of an Application may incorporate material from a header
+file that is part of the Library. You may convey such object code under terms
+of your choice, provided that, if the incorporated material is not limited
+to numerical parameters, data structure layouts and accessors, or small macros,
+inline functions and templates (ten or fewer lines in length), you do both
+of the following:
+
+a) Give prominent notice with each copy of the object code that the Library
+is used in it and that the Library and its use are covered by this License.
+
+b) Accompany the object code with a copy of the GNU GPL and this license document.
+
+   4. Combined Works.
+
+You may convey a Combined Work under terms of your choice that, taken together,
+effectively do not restrict modification of the portions of the Library contained
+in the Combined Work and reverse engineering for debugging such modifications,
+if you also do each of the following:
+
+a) Give prominent notice with each copy of the Combined Work that the Library
+is used in it and that the Library and its use are covered by this License.
+
+b) Accompany the Combined Work with a copy of the GNU GPL and this license
+document.
+
+c) For a Combined Work that displays copyright notices during execution, include
+the copyright notice for the Library among these notices, as well as a reference
+directing the user to the copies of the GNU GPL and this license document.
+
+      d) Do one of the following:
+
+0) Convey the Minimal Corresponding Source under the terms of this License,
+and the Corresponding Application Code in a form suitable for, and under terms
+that permit, the user to recombine or relink the Application with a modified
+version of the Linked Version to produce a modified Combined Work, in the
+manner specified by section 6 of the GNU GPL for conveying Corresponding Source.
+
+1) Use a suitable shared library mechanism for linking with the Library. A
+suitable mechanism is one that (a) uses at run time a copy of the Library
+already present on the user's computer system, and (b) will operate properly
+with a modified version of the Library that is interface-compatible with the
+Linked Version.
+
+e) Provide Installation Information, but only if you would otherwise be required
+to provide such information under section 6 of the GNU GPL, and only to the
+extent that such information is necessary to install and execute a modified
+version of the Combined Work produced by recombining or relinking the Application
+with a modified version of the Linked Version. (If you use option 4d0, the
+Installation Information must accompany the Minimal Corresponding Source and
+Corresponding Application Code. If you use option 4d1, you must provide the
+Installation Information in the manner specified by section 6 of the GNU GPL
+for conveying Corresponding Source.)
+
+   5. Combined Libraries.
+
+You may place library facilities that are a work based on the Library side
+by side in a single library together with other library facilities that are
+not Applications and are not covered by this License, and convey such a combined
+library under terms of your choice, if you do both of the following:
+
+a) Accompany the combined library with a copy of the same work based on the
+Library, uncombined with any other library facilities, conveyed under the
+terms of this License.
+
+b) Give prominent notice with the combined library that part of it is a work
+based on the Library, and explaining where to find the accompanying uncombined
+form of the same work.
+
+   6. Revised Versions of the GNU Lesser General Public License.
+
+The Free Software Foundation may publish revised and/or new versions of the
+GNU Lesser General Public License from time to time. Such new versions will
+be similar in spirit to the present version, but may differ in detail to address
+new problems or concerns.
+
+Each version is given a distinguishing version number. If the Library as you
+received it specifies that a certain numbered version of the GNU Lesser General
+Public License "or any later version" applies to it, you have the option of
+following the terms and conditions either of that published version or of
+any later version published by the Free Software Foundation. If the Library
+as you received it does not specify a version number of the GNU Lesser General
+Public License, you may choose any version of the GNU Lesser General Public
+License ever published by the Free Software Foundation.
+
+If the Library as you received it specifies that a proxy can decide whether
+future versions of the GNU Lesser General Public License shall apply, that
+proxy's public statement of acceptance of any version is permanent authorization
+for you to choose that version for the Library.

LICENSES/LicenseRef-KDE-Accepted-LGPL.txt

@@ -0,0 +1,12 @@
+This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Lesser General Public
+License as published by the Free Software Foundation; either
+version 3 of the license or (at your option) any later version
+that is accepted by the membership of KDE e.V. (or its successor
+approved by the membership of KDE e.V.), which shall act as a
+proxy as defined in Section 6 of version 3 of the license.
+
+This program 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.

README.md

@@ -13,7 +13,6 @@ image formats.
 
 The following image formats have read-only support:
 
-- DirectDraw Surface (dds)
 - Gimp (xcf)
 - OpenEXR (exr)
 - Photoshop documents (psd)
@@ -22,7 +21,6 @@ The following image formats have read-only support:
 The following image formats have read and write support:
 
 - Encapsulated PostScript (eps)
-- JPEG-2000 (jp2)
 - Personal Computer Exchange (pcx)
 - SGI images (rgb, rgba, sgi, bw)
 - Softimage PIC (pic)

autotests/CMakeLists.txt

@@ -3,7 +3,7 @@
 include(ECMMarkAsTest)
 include(CMakeParseArguments)
 
-add_definitions(-DPLUGIN_DIR="${CMAKE_CURRENT_BINARY_DIR}/../src")
+add_definitions(-DPLUGIN_DIR="${CMAKE_CURRENT_BINARY_DIR}/../bin")
 remove_definitions(-DQT_NO_CAST_FROM_ASCII)
 
 macro(kimageformats_read_tests)
@@ -55,12 +55,21 @@ endmacro()
 # Loads each <format> image in read/<format>/, and compares the
 # result against the data read from the corresponding png file
 kimageformats_read_tests(
+    hdr
     pcx
     psd
     ras
     rgb
     tga
 )
+
+if (KF5Archive_FOUND)
+    kimageformats_read_tests(
+        kra
+        ora
+    )
+endif()
+
 # Allow some fuzziness when reading this formats, to allow for
 # rounding errors (eg: in alpha blending).
 kimageformats_read_tests(FUZZ 1
@@ -86,22 +95,10 @@ kimageformats_write_tests(
 #    kimageformats_read_tests(eps)
 #    kimageformats_write_tests(eps)
 #endif()
-if (JASPER_FOUND)
-    # FIXME: when we read JPEG2000 files on different architectures
-    # (specifically x86_64 and i386), we get off-by-one errors. The
-    # jasper utility does not have the same problem, so it is not a
-    # problem inherent in the jasper library. For now, we just allow
-    # a little fuzziness to make sure it does not get any worse (being
-    # off by one in an image value is not noticable to the human eye,
-    # so it is not a release-blocking issue).
-    kimageformats_read_tests(FUZZ 1 jp2)
-    kimageformats_write_tests(jp2)
-endif()
 if (OpenEXR_FOUND)
     # FIXME: OpenEXR tests
 endif()
 
-
 find_package(Qt5Test ${REQUIRED_QT_VERSION} CONFIG QUIET)
 
 if(NOT Qt5Test_FOUND)

autotests/pictest.cpp

@@ -1,23 +1,8 @@
 /*
- * Copyright 2014  Alex Merry <alex.merry@kdemail.net>
- *
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2.1 of the License, or (at your option) version 3, or any
- * later version accepted by the membership of KDE e.V. (or its
- * successor approved by the membership of KDE e.V.), which shall
- * act as a proxy defined in Section 6 of version 3 of the license.
- *
- * This library 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
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library.  If not, see
- * <http://www.gnu.org/licenses/>.
- */
+    SPDX-FileCopyrightText: 2014 Alex Merry <alex.merry@kdemail.net>
+
+    SPDX-License-Identifier: LGPL-2.1-only OR LGPL-3.0-only OR LicenseRef-KDE-Accepted-LGPL
+*/
 
 #include <stdio.h>
 
@@ -210,11 +195,11 @@ private Q_SLOTS:
             QFile picDumpFile(fileNameBase + QStringLiteral("-expected.data"));
             QVERIFY2(picDumpFile.open(QIODevice::WriteOnly), qPrintable(picDumpFile.errorString()));
             picDumpFile.write(reinterpret_cast<const char *>(inputImage.bits()),
-                              inputImage.byteCount());
+                              inputImage.sizeInBytes());
             QFile pngDumpFile(fileNameBase + QStringLiteral("-actual.data"));
             QVERIFY2(pngDumpFile.open(QIODevice::WriteOnly), qPrintable(pngDumpFile.errorString()));
             pngDumpFile.write(reinterpret_cast<const char *>(expImage.bits()),
-                              expImage.byteCount());
+                              expImage.sizeInBytes());
             QString msg = QStringLiteral("Read image (")
                         + picDumpFile.fileName()
                         + QStringLiteral(") differed from expected image (")

autotests/readtest.cpp

@@ -1,23 +1,8 @@
 /*
- * Copyright 2014  Alex Merry <alex.merry@kdemail.net>
- *
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2.1 of the License, or (at your option) version 3, or any
- * later version accepted by the membership of KDE e.V. (or its
- * successor approved by the membership of KDE e.V.), which shall
- * act as a proxy defined in Section 6 of version 3 of the license.
- *
- * This library 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
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library.  If not, see
- * <http://www.gnu.org/licenses/>.
- */
+    SPDX-FileCopyrightText: 2014 Alex Merry <alex.merry@kdemail.net>
+
+    SPDX-License-Identifier: LGPL-2.1-only OR LGPL-3.0-only OR LicenseRef-KDE-Accepted-LGPL
+*/
 
 #include <stdio.h>
 
@@ -35,8 +20,8 @@ static void writeImageData(const char *name, const QString &filename, const QIma
 {
     QFile file(filename);
     if (file.open(QIODevice::WriteOnly)) {
-        qint64 written = file.write(reinterpret_cast<const char *>(image.bits()), image.byteCount());
-        if (written == image.byteCount()) {
+        qint64 written = file.write(reinterpret_cast<const char *>(image.bits()), image.sizeInBytes());
+        if (written == image.sizeInBytes()) {
             QTextStream(stdout) << "       " << name
                                 << " written to " << filename << "\n";
         } else {
@@ -75,6 +60,7 @@ static bool fuzzyeq(const QImage &im1, const QImage &im2, uchar fuzziness)
 int main(int argc, char ** argv)
 {
     QCoreApplication app(argc, argv);
+    QCoreApplication::removeLibraryPath(QStringLiteral(PLUGIN_DIR));
     QCoreApplication::addLibraryPath(QStringLiteral(PLUGIN_DIR));
     QCoreApplication::setApplicationName(QStringLiteral("readtest"));
     QCoreApplication::setApplicationVersion(QStringLiteral("1.0.0"));
@@ -126,13 +112,20 @@ int main(int argc, char ** argv)
         << "Starting basic read tests for "
         << suffix << " images *********\n";
 
-    foreach (QFileInfo fi, imgdir.entryInfoList()) {
+    const QList<QByteArray> formats = QImageReader::supportedImageFormats();
+    QStringList formatStrings;
+    formatStrings.reserve(formats.size());
+    std::transform(formats.begin(), formats.end(), std::back_inserter(formatStrings), [](const QByteArray &format) { return QString(format); });
+    QTextStream(stdout) << "QImageReader::supportedImageFormats: " << formatStrings.join(", ") << "\n";
+
+    const QFileInfoList lstImgDir = imgdir.entryInfoList();
+    for (const QFileInfo &fi : lstImgDir) {
         int suffixPos = fi.filePath().count() - suffix.count();
         QString inputfile = fi.filePath();
-        QString expfile = fi.filePath().replace(suffixPos, suffix.count(), "png");
+        QString expfile = fi.filePath().replace(suffixPos, suffix.count(), QStringLiteral("png"));
         QString expfilename = QFileInfo(expfile).fileName();
 
-        QImageReader inputReader(inputfile, format.constData());
+        QImageReader inputReader(inputfile, format);
         QImageReader expReader(expfile, "png");
 
         QImage inputImage;
@@ -146,6 +139,14 @@ int main(int argc, char ** argv)
             ++failed;
             continue;
         }
+        if (!inputReader.canRead()) {
+            QTextStream(stdout) << "FAIL : " << fi.fileName()
+                << ": failed can read: "
+                << inputReader.errorString()
+                << "\n";
+            ++failed;
+            continue;
+        }
         if (!inputReader.read(&inputImage)) {
             QTextStream(stdout) << "FAIL : " << fi.fileName()
                 << ": failed to load: "

autotests/writetest.cpp

@@ -1,23 +1,8 @@
 /*
- * Copyright 2014  Alex Merry <alex.merry@kdemail.net>
- *
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2.1 of the License, or (at your option) version 3, or any
- * later version accepted by the membership of KDE e.V. (or its
- * successor approved by the membership of KDE e.V.), which shall
- * act as a proxy defined in Section 6 of version 3 of the license.
- *
- * This library 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
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library.  If not, see
- * <http://www.gnu.org/licenses/>.
- */
+    SPDX-FileCopyrightText: 2014 Alex Merry <alex.merry@kdemail.net>
+
+    SPDX-License-Identifier: LGPL-2.1-only OR LGPL-3.0-only OR LicenseRef-KDE-Accepted-LGPL
+*/
 
 #include <stdio.h>
 
@@ -34,6 +19,7 @@
 int main(int argc, char ** argv)
 {
     QCoreApplication app(argc, argv);
+    QCoreApplication::removeLibraryPath(QStringLiteral(PLUGIN_DIR));
     QCoreApplication::addLibraryPath(QStringLiteral(PLUGIN_DIR));
     QCoreApplication::setApplicationName(QStringLiteral("readtest"));
     QCoreApplication::setApplicationVersion(QStringLiteral("1.0.0"));
@@ -72,10 +58,10 @@ int main(int argc, char ** argv)
     QTextStream(stdout) << "********* "
         << "Starting basic write tests for "
         << suffix << " images *********\n";
-
-    foreach (QFileInfo fi, imgdir.entryInfoList()) {
+    const QFileInfoList lstImgDir = imgdir.entryInfoList();
+    for (const QFileInfo &fi : lstImgDir) {
         int suffixPos = fi.filePath().count() - suffix.count();
-        QString pngfile = fi.filePath().replace(suffixPos, suffix.count(), "png");
+        QString pngfile = fi.filePath().replace(suffixPos, suffix.count(), QStringLiteral("png"));
         QString pngfilename = QFileInfo(pngfile).fileName();
 
         QImageReader pngReader(pngfile, "png");

metainfo.yaml

@@ -1,12 +1,18 @@
 maintainer: alexmerry
 description: Image format plugins for Qt
-tier: 1
+tier: 2
 type: functional
 platforms:
     - name: Linux
+    - name: FreeBSD
     - name: MacOSX
     - name: Windows
       note: No EPS support on Windows
+    - name: Android
 portingAid: false
 deprecated: false
 release: true
+
+public_lib: true
+group: Frameworks
+subgroup: Tier 2

src/imageformats/CMakeLists.txt

@@ -2,111 +2,105 @@
 
 ##################################
 
-if (Qt5Gui_VERSION VERSION_LESS 5.3.0)
-    add_library(kimg_dds MODULE dds.cpp)
-    target_link_libraries(kimg_dds Qt5::Gui)
+function(kimageformats_add_plugin plugin)
+    set(options)
+    set(oneValueArgs JSON)
+    set(multiValueArgs SOURCES)
+    cmake_parse_arguments(KIF_ADD_PLUGIN "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN})
+    if(NOT KIF_ADD_PLUGIN_SOURCES)
+        message(FATAL_ERROR "kimageformats_add_plugin called without SOURCES parameter")
+    endif()
+    get_filename_component(json "${KIF_ADD_PLUGIN_JSON}" REALPATH)
+    if(NOT KIF_ADD_PLUGIN_JSON OR NOT EXISTS ${json})
+        message(FATAL_ERROR "JSON file doesn't exist: ${json}")
+    endif()
 
-    install(TARGETS kimg_dds  DESTINATION ${QT_PLUGIN_INSTALL_DIR}/imageformats/)
-    install(FILES dds.desktop DESTINATION ${SERVICES_INSTALL_DIR}/qimageioplugins/)
-else()
-    install(FILES dds-qt.desktop RENAME dds.desktop DESTINATION ${SERVICES_INSTALL_DIR}/qimageioplugins/)
-endif()
+    add_library(${plugin} MODULE ${KIF_ADD_PLUGIN_SOURCES})
+    set_property(TARGET ${plugin} APPEND PROPERTY AUTOGEN_TARGET_DEPENDS ${json})
+    set_target_properties(${plugin} PROPERTIES LIBRARY_OUTPUT_DIRECTORY "${CMAKE_LIBRARY_OUTPUT_DIRECTORY}/imageformats")
+    target_link_libraries(${plugin} Qt5::Gui)
+    install(TARGETS ${plugin} DESTINATION ${KDE_INSTALL_QTPLUGINDIR}/imageformats)
+endfunction()
+
+##################################
+
+install(FILES dds-qt.desktop RENAME dds.desktop DESTINATION ${KDE_INSTALL_KSERVICES5DIR}/qimageioplugins/)
 
 ##################################
 
 if (BUILD_EPS_PLUGIN)
     if (Qt5PrintSupport_FOUND)
-        add_library(kimg_eps MODULE eps.cpp)
-        target_link_libraries(kimg_eps  Qt5::Gui Qt5::PrintSupport)
-
-        install(TARGETS kimg_eps  DESTINATION ${QT_PLUGIN_INSTALL_DIR}/imageformats/)
-        install(FILES eps.desktop DESTINATION ${SERVICES_INSTALL_DIR}/qimageioplugins/)
+        kimageformats_add_plugin(kimg_eps JSON "eps.json" SOURCES eps.cpp)
+        target_link_libraries(kimg_eps Qt5::PrintSupport)
+        install(FILES eps.desktop DESTINATION ${KDE_INSTALL_KSERVICES5DIR}/qimageioplugins/)
     endif()
 endif()
 
 ##################################
 
-check_include_files(sys/types.h   HAVE_SYS_TYPES_H)
-check_include_files(stdint.h      HAVE_STDINT_H)
-configure_file(config-jp2.h.cmake ${CMAKE_CURRENT_BINARY_DIR}/config-jp2.h)
-
-if(JASPER_FOUND)
-    add_library(kimg_jp2 MODULE jp2.cpp)
-    target_compile_options(kimg_jp2 PRIVATE ${JASPER_DEFINITIONS})
-    target_include_directories(kimg_jp2 PRIVATE ${JASPER_INCLUDE_DIR})
-    target_link_libraries(kimg_jp2  Qt5::Gui ${JASPER_LIBRARIES})
-
-    install(TARGETS kimg_jp2  DESTINATION ${QT_PLUGIN_INSTALL_DIR}/imageformats/)
-    install(FILES jp2.desktop DESTINATION ${SERVICES_INSTALL_DIR}/qimageioplugins/)
-elseif (NOT Qt5Gui_VERSION VERSION_LESS 5.3.0)
-    # need this for Qt's version of the plugin
-    install(FILES jp2.desktop DESTINATION ${SERVICES_INSTALL_DIR}/qimageioplugins/)
-endif()
+# need this for Qt's version of the plugin
+install(FILES jp2.desktop DESTINATION ${KDE_INSTALL_KSERVICES5DIR}/qimageioplugins/)
 
 ##################################
 
 if(OpenEXR_FOUND)
-    add_library(kimg_exr MODULE exr.cpp)
-    target_link_libraries(kimg_exr Qt5::Gui OpenEXR::IlmImf)
+    kimageformats_add_plugin(kimg_exr JSON "exr.json" SOURCES exr.cpp)
+    target_link_libraries(kimg_exr OpenEXR::IlmImf)
     kde_target_enable_exceptions(kimg_exr PRIVATE)
 
-    install(TARGETS kimg_exr  DESTINATION ${QT_PLUGIN_INSTALL_DIR}/imageformats/)
-    install(FILES exr.desktop DESTINATION ${SERVICES_INSTALL_DIR}/qimageioplugins/)
+    install(FILES exr.desktop DESTINATION ${KDE_INSTALL_KSERVICES5DIR}/qimageioplugins/)
 endif()
 
 ##################################
 
-add_library(kimg_pcx MODULE pcx.cpp)
-target_link_libraries(kimg_pcx  Qt5::Gui)
-
-install(TARGETS kimg_pcx  DESTINATION ${QT_PLUGIN_INSTALL_DIR}/imageformats/)
-install(FILES pcx.desktop DESTINATION ${SERVICES_INSTALL_DIR}/qimageioplugins/)
+kimageformats_add_plugin(kimg_hdr JSON "hdr.json" SOURCES hdr.cpp)
+install(FILES hdr.desktop DESTINATION ${KDE_INSTALL_KSERVICES5DIR}/qimageioplugins/)
 
 ##################################
 
-add_library(kimg_pic MODULE pic.cpp)
-target_link_libraries(kimg_pic Qt5::Gui)
-
-install(TARGETS kimg_pic  DESTINATION ${QT_PLUGIN_INSTALL_DIR}/imageformats/)
-install(FILES pic.desktop DESTINATION ${SERVICES_INSTALL_DIR}/qimageioplugins/)
+kimageformats_add_plugin(kimg_pcx JSON "pcx.json" SOURCES pcx.cpp)
+install(FILES pcx.desktop DESTINATION ${KDE_INSTALL_KSERVICES5DIR}/qimageioplugins/)
 
 ##################################
 
-add_library(kimg_psd MODULE psd.cpp)
-target_link_libraries(kimg_psd Qt5::Gui)
-
-install(TARGETS kimg_psd  DESTINATION ${QT_PLUGIN_INSTALL_DIR}/imageformats/)
-install(FILES psd.desktop DESTINATION ${SERVICES_INSTALL_DIR}/qimageioplugins/)
+kimageformats_add_plugin(kimg_pic JSON "pic.json" SOURCES pic.cpp)
+install(FILES pic.desktop DESTINATION ${KDE_INSTALL_KSERVICES5DIR}/qimageioplugins/)
 
 ##################################
 
-add_library(kimg_ras MODULE ras.cpp)
-target_link_libraries(kimg_ras  Qt5::Gui)
-
-install(TARGETS kimg_ras  DESTINATION ${QT_PLUGIN_INSTALL_DIR}/imageformats/)
-install(FILES ras.desktop DESTINATION ${SERVICES_INSTALL_DIR}/qimageioplugins/)
+kimageformats_add_plugin(kimg_psd JSON "psd.json" SOURCES psd.cpp)
+install(FILES psd.desktop DESTINATION ${KDE_INSTALL_KSERVICES5DIR}/qimageioplugins/)
 
 ##################################
 
-add_library(kimg_rgb MODULE rgb.cpp)
-target_link_libraries(kimg_rgb  Qt5::Gui)
-
-install(TARGETS kimg_rgb  DESTINATION ${QT_PLUGIN_INSTALL_DIR}/imageformats/)
-install(FILES rgb.desktop DESTINATION ${SERVICES_INSTALL_DIR}/qimageioplugins/)
+kimageformats_add_plugin(kimg_ras JSON "ras.json" SOURCES ras.cpp)
+install(FILES ras.desktop DESTINATION ${KDE_INSTALL_KSERVICES5DIR}/qimageioplugins/)
 
 ##################################
 
-add_library(kimg_tga MODULE tga.cpp)
-target_link_libraries(kimg_tga  Qt5::Gui)
-
-install(TARGETS kimg_tga  DESTINATION ${QT_PLUGIN_INSTALL_DIR}/imageformats/)
-install(FILES tga.desktop DESTINATION ${SERVICES_INSTALL_DIR}/qimageioplugins/)
+kimageformats_add_plugin(kimg_rgb JSON "rgb.json" SOURCES rgb.cpp)
+install(FILES rgb.desktop DESTINATION ${KDE_INSTALL_KSERVICES5DIR}/qimageioplugins/)
 
 ##################################
 
-add_library(kimg_xcf MODULE xcf.cpp)
-target_link_libraries(kimg_xcf Qt5::Gui)
+kimageformats_add_plugin(kimg_tga JSON "tga.json" SOURCES tga.cpp)
+install(FILES tga.desktop DESTINATION ${KDE_INSTALL_KSERVICES5DIR}/qimageioplugins/)
 
-install(TARGETS kimg_xcf  DESTINATION ${QT_PLUGIN_INSTALL_DIR}/imageformats/)
-install(FILES xcf.desktop DESTINATION ${SERVICES_INSTALL_DIR}/qimageioplugins/)
+##################################
 
+kimageformats_add_plugin(kimg_xcf JSON "xcf.json" SOURCES xcf.cpp)
+install(FILES xcf.desktop DESTINATION ${KDE_INSTALL_KSERVICES5DIR}/qimageioplugins/)
+
+##################################
+
+if (KF5Archive_FOUND)
+
+    kimageformats_add_plugin(kimg_kra JSON "kra.json" SOURCES kra.cpp)
+    target_link_libraries(kimg_kra KF5::Archive)
+    install(FILES kra.desktop DESTINATION ${KDE_INSTALL_KSERVICES5DIR}/qimageioplugins/)
+
+    kimageformats_add_plugin(kimg_ora JSON "ora.json" SOURCES ora.cpp)
+    target_link_libraries(kimg_ora KF5::Archive)
+    install(FILES ora.desktop DESTINATION ${KDE_INSTALL_KSERVICES5DIR}/qimageioplugins/)
+
+endif()

src/imageformats/config-jp2.h.cmake

@@ -1,2 +0,0 @@
-#cmakedefine01 HAVE_STDINT_H
-#cmakedefine01 HAVE_SYS_TYPES_H

src/imageformats/dds.json

@@ -1,4 +0,0 @@
-{
-    "Keys": [ "dds" ],
-    "MimeTypes": [ "image/x-dds" ]
-}

src/imageformats/dds_p.h

@@ -1,37 +0,0 @@
-/* This file is part of the KDE project
-   Copyright (C) 2003 Ignacio Castaño <castano@ludicon.com>
-
-   This program is free software; you can redistribute it and/or
-   modify it under the terms of the Lesser GNU General Public
-   License as published by the Free Software Foundation; either
-   version 2 of the License, or (at your option) any later version.
-*/
-
-#ifndef KIMG_DDS_H
-#define KIMG_DDS_H
-
-#include <QImageIOPlugin>
-
-class DDSHandler : public QImageIOHandler
-{
-public:
-    DDSHandler();
-
-    virtual bool canRead() const;
-    virtual bool read(QImage *image);
-
-    static bool canRead(QIODevice *device);
-};
-
-class DDSPlugin : public QImageIOPlugin
-{
-    Q_OBJECT
-    Q_PLUGIN_METADATA(IID "org.qt-project.Qt.QImageIOHandlerFactoryInterface" FILE "dds.json")
-
-public:
-    virtual Capabilities capabilities(QIODevice *device, const QByteArray &format) const;
-    virtual QImageIOHandler *create(QIODevice *device, const QByteArray &format = QByteArray()) const;
-};
-
-#endif // KIMG_DDS_H
-

src/imageformats/eps.cpp

@@ -1,23 +1,25 @@
 /*
-* QImageIO Routines to read/write EPS images.
-* copyright (c) 1998 Dirk Schoenberger <dirk.schoenberger@freenet.de>
-* Copyright (c) 2013 Alex Merry <alex.merry@kdemail.net>
-* Includes code by Sven Wiegand <SWiegand@tfh-berlin.de> from KSnapshot
-*
-* This library is distributed under the conditions of the GNU LGPL.
+    QImageIO Routines to read/write EPS images.
+    SPDX-FileCopyrightText: 1998 Dirk Schoenberger <dirk.schoenberger@freenet.de>
+    SPDX-FileCopyrightText: 2013 Alex Merry <alex.merry@kdemail.net>
+
+    Includes code by Sven Wiegand <SWiegand@tfh-berlin.de> from KSnapshot
+
+    SPDX-License-Identifier: LGPL-2.0-or-later
 */
 #include "eps_p.h"
 
-#include <QDebug>
 #include <QImage>
 #include <QImageReader>
-#include <QLoggingCategory>
 #include <QPainter>
 #include <QPrinter>
 #include <QProcess>
 #include <QTemporaryFile>
+#include <QCoreApplication>
+
+// logging category for this framework, default: log stuff >= warning
+Q_LOGGING_CATEGORY(EPSPLUGIN, "kf.imageformats.plugins.eps", QtWarningMsg)
 
-Q_LOGGING_CATEGORY(EPSPLUGIN, "epsplugin")
 //#define EPS_PERFORMANCE_DEBUG 1
 
 #define BBOX_BUFLEN 200
@@ -156,7 +158,7 @@ bool EPSHandler::read(QImage *image)
 
     QTemporaryFile tmpFile;
     if (!tmpFile.open()) {
-        qWarning() << "Could not create the temporary file" << tmpFile.fileName();
+        qCWarning(EPSPLUGIN) << "Could not create the temporary file" << tmpFile.fileName();
         return false;
     }
     qCDebug(EPSPLUGIN) << "temporary file:" << tmpFile.fileName();
@@ -177,7 +179,7 @@ bool EPSHandler::read(QImage *image)
     QStringList gsArgs;
     gsArgs << QLatin1String("-sOutputFile=") + tmpFile.fileName()
            << QStringLiteral("-q")
-           << QString(QStringLiteral("-g%1x%2")).arg(wantedWidth).arg(wantedHeight)
+           << QStringLiteral("-g%1x%2").arg(wantedWidth).arg(wantedHeight)
            << QStringLiteral("-dSAFER")
            << QStringLiteral("-dPARANOIDSAFER")
            << QStringLiteral("-dNOPAUSE")
@@ -198,7 +200,7 @@ bool EPSHandler::read(QImage *image)
     converter.setProcessChannelMode(QProcess::ForwardedErrorChannel);
     converter.start(QStringLiteral("gs"), gsArgs);
     if (!converter.waitForStarted(3000)) {
-        qWarning() << "Reading EPS files requires gs (from GhostScript)";
+        qCWarning(EPSPLUGIN) << "Reading EPS files requires gs (from GhostScript)";
         return false;
     }
 
@@ -297,7 +299,7 @@ bool EPSHandler::write(const QImage &image)
         converter.start(QStringLiteral("gs"), gsArgs);
 
         if (!converter.waitForStarted(3000)) {
-            qWarning() << "Creating EPS files requires pdftops (from Poppler) or gs (from GhostScript)";
+            qCWarning(EPSPLUGIN) << "Creating EPS files requires pdftops (from Poppler) or gs (from GhostScript)";
             return false;
         }
     }
@@ -312,7 +314,7 @@ bool EPSHandler::write(const QImage &image)
 bool EPSHandler::canRead(QIODevice *device)
 {
     if (!device) {
-        qWarning("EPSHandler::canRead() called with no device");
+        qCWarning(EPSPLUGIN) << "EPSHandler::canRead() called with no device";
         return false;
     }
 
@@ -333,14 +335,23 @@ bool EPSHandler::canRead(QIODevice *device)
 
 QImageIOPlugin::Capabilities EPSPlugin::capabilities(QIODevice *device, const QByteArray &format) const
 {
+    // prevent bug #397040: when on app shutdown the clipboard content is to be copied to survive end of the app,
+    // QXcbIntegration looks for some QImageIOHandler to apply, querying the capabilities and picking any first.
+    // At that point this plugin no longer has its requirements e.g. to run the external process, so we have to deny.
+    // The capabilities seem to be queried on demand in Qt code and not cached, so it's fine to report based
+    // in current dynamic state
+    if (!QCoreApplication::instance()) {
+        return {};
+    }
+
     if (format == "eps" || format == "epsi" || format == "epsf") {
         return Capabilities(CanRead | CanWrite);
     }
     if (!format.isEmpty()) {
-        return 0;
+        return {};
     }
     if (!device->isOpen()) {
-        return 0;
+        return {};
     }
 
     Capabilities cap;

src/imageformats/eps_p.h

@@ -1,22 +1,23 @@
 /*
-* QImageIO Routines to read/write EPS images.
-* copyright (c) 1998 Dirk Schoenberger <dirk.schoenberger@freenet.de>
-*
-* This library is distributed under the conditions of the GNU LGPL.
+    QImageIO Routines to read/write EPS images.
+    SPDX-FileCopyrightText: 1998 Dirk Schoenberger <dirk.schoenberger@freenet.de>
+
+    SPDX-License-Identifier: LGPL-2.0-or-later
 */
-#ifndef KIMG_EPS_H
-#define KIMG_EPS_H
+#ifndef KIMG_EPS_P_H
+#define KIMG_EPS_P_H
 
 #include <QImageIOPlugin>
+#include <QLoggingCategory>
 
 class EPSHandler : public QImageIOHandler
 {
 public:
     EPSHandler();
 
-    virtual bool canRead() const;
-    virtual bool read(QImage *image);
-    virtual bool write(const QImage &image);
+    bool canRead() const override;
+    bool read(QImage *image) override;
+    bool write(const QImage &image) override;
 
     static bool canRead(QIODevice *device);
 };
@@ -27,9 +28,11 @@ class EPSPlugin : public QImageIOPlugin
     Q_PLUGIN_METADATA(IID "org.qt-project.Qt.QImageIOHandlerFactoryInterface" FILE "eps.json")
 
 public:
-    virtual Capabilities capabilities(QIODevice *device, const QByteArray &format) const;
-    virtual QImageIOHandler *create(QIODevice *device, const QByteArray &format = QByteArray()) const;
+    Capabilities capabilities(QIODevice *device, const QByteArray &format) const override;
+    QImageIOHandler *create(QIODevice *device, const QByteArray &format = QByteArray()) const override;
 };
 
-#endif // KIMG_EPS_H
+Q_DECLARE_LOGGING_CATEGORY(EPSPLUGIN)
+
+#endif // KIMG_EPS_P_H
 

src/imageformats/exr.cpp

@@ -1,10 +1,10 @@
-
 /*
-* KImageIO Routines to read (and perhaps in the future, write) images
-* in the high dynamic range EXR format.
-* Copyright (c) 2003, Brad Hards <bradh@frogmouth.net>
-*
-* This library is distributed under the conditions of the GNU LGPL.
+    KImageIO Routines to read (and perhaps in the future, write) images
+    in the high dynamic range EXR format.
+
+    SPDX-FileCopyrightText: 2003 Brad Hards <bradh@frogmouth.net>
+
+    SPDX-License-Identifier: LGPL-2.0-or-later
 */
 
 #include "exr_p.h"
@@ -30,7 +30,7 @@
 
 #include <QImage>
 #include <QDataStream>
-// #include <QDebug>
+#include <QDebug>
 #include <QImageIOPlugin>
 
 class K_IStream: public Imf::IStream
@@ -41,10 +41,10 @@ public:
     {
     }
 
-    virtual bool  read(char c[], int n);
-    virtual Imf::Int64 tellg();
-    virtual void seekg(Imf::Int64 pos);
-    virtual void clear();
+    bool  read(char c[], int n) override;
+    Imf::Int64 tellg() override;
+    void seekg(Imf::Int64 pos) override;
+    void clear() override;
 
 private:
     QIODevice *m_dev;
@@ -82,7 +82,7 @@ void K_IStream::clear()
  * format into the normal 32 bit pixel format. Process is from the
  * ILM code.
  */
-QRgb RgbaToQrgba(struct Imf::Rgba imagePixel)
+QRgb RgbaToQrgba(struct Imf::Rgba &imagePixel)
 {
     float r, g, b, a;
 
@@ -172,17 +172,18 @@ bool EXRHandler::read(QImage *outImage)
         width  = dw.max.x - dw.min.x + 1;
         height = dw.max.y - dw.min.y + 1;
 
+        QImage image(width, height, QImage::Format_RGB32);
+        if (image.isNull()) {
+            qWarning() << "Failed to allocate image, invalid size?" << QSize(width, height);
+            return false;
+        }
+
         Imf::Array2D<Imf::Rgba> pixels;
         pixels.resizeErase(height, width);
 
         file.setFrameBuffer(&pixels[0][0] - dw.min.x - dw.min.y * width, 1, width);
         file.readPixels(dw.min.y, dw.max.y);
 
-        QImage image(width, height, QImage::Format_RGB32);
-        if (image.isNull()) {
-            return false;
-        }
-
         // somehow copy pixels into image
         for (int y = 0; y < height; y++) {
             for (int x = 0; x < width; x++) {
@@ -218,10 +219,10 @@ QImageIOPlugin::Capabilities EXRPlugin::capabilities(QIODevice *device, const QB
         return Capabilities(CanRead);
     }
     if (!format.isEmpty()) {
-        return 0;
+        return {};
     }
     if (!device->isOpen()) {
-        return 0;
+        return {};
     }
 
     Capabilities cap;

src/imageformats/exr_p.h

@@ -1,15 +1,14 @@
 /*
-* QImageIO Routines to read (and perhaps in the future, write) images
-* in the high definition EXR format.
-*
-* Copyright (c) 2003, Brad Hards <bradh@frogmouth.net>
-*
-* This library is distributed under the conditions of the GNU LGPL.
-*
+    QImageIO Routines to read (and perhaps in the future, write) images
+    in the high definition EXR format.
+
+    SPDX-FileCopyrightText: 2003 Brad Hards <bradh@frogmouth.net>
+
+    SPDX-License-Identifier: LGPL-2.0-or-later
 */
 
-#ifndef KIMG_EXR_H
-#define KIMG_EXR_H
+#ifndef KIMG_EXR_P_H
+#define KIMG_EXR_P_H
 
 #include <QImageIOPlugin>
 
@@ -18,8 +17,8 @@ class EXRHandler : public QImageIOHandler
 public:
     EXRHandler();
 
-    virtual bool canRead() const;
-    virtual bool read(QImage *outImage);
+    bool canRead() const override;
+    bool read(QImage *outImage) override;
 
     static bool canRead(QIODevice *device);
 };
@@ -30,8 +29,8 @@ class EXRPlugin : public QImageIOPlugin
     Q_PLUGIN_METADATA(IID "org.qt-project.Qt.QImageIOHandlerFactoryInterface" FILE "exr.json")
 
 public:
-    virtual Capabilities capabilities(QIODevice *device, const QByteArray &format) const;
-    virtual QImageIOHandler *create(QIODevice *device, const QByteArray &format = QByteArray()) const;
+    Capabilities capabilities(QIODevice *device, const QByteArray &format) const override;
+    QImageIOHandler *create(QIODevice *device, const QByteArray &format = QByteArray()) const override;
 };
 
-#endif // KIMG_EXR_H
+#endif // KIMG_EXR_P_H

src/imageformats/gimp_p.h

@@ -1,25 +1,13 @@
+/* -*- c++ -*-
+    gimp.h: Header for a Qt 3 plug-in for reading GIMP XCF image files
+    SPDX-FileCopyrightText: 2001 lignum Computing Inc. <allen@lignumcomputing.com>
+    SPDX-FileCopyrightText: 2004 Melchior FRANZ <mfranz@kde.org>
+
+    SPDX-License-Identifier: LGPL-2.1-or-later
+*/
+
 #ifndef GIMP_H
 #define GIMP_H
-/* -*- c++ -*-
- * gimp.h: Header for a Qt 3 plug-in for reading GIMP XCF image files
- * Copyright (C) 2001 lignum Computing, Inc. <allen@lignumcomputing.com>
- * Copyright (C) 2004 Melchior FRANZ <mfranz@kde.org>
- *
- * This plug-in is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2.1 of the License, or (at your option) any later version.
- *
- * This library 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
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
- *
- */
 
 typedef unsigned char uchar;
 
@@ -56,16 +44,6 @@ typedef enum {
     INDEXED
 } GimpImageBaseType;
 
-//! Type of individual layers in an XCF file.
-
-typedef enum {
-    RGB_GIMAGE,
-    RGBA_GIMAGE,
-    GRAY_GIMAGE,
-    GRAYA_GIMAGE,
-    INDEXED_GIMAGE,
-    INDEXEDA_GIMAGE
-} GimpImageType;
 
 // From GIMP "libgimp/gimpenums.h" v2.4
 
@@ -96,48 +74,6 @@ typedef enum {
     GRAIN_MERGE_MODE
 } LayerModeEffects;
 
-// From GIMP "xcf.c" v1.2
-
-//! Properties which can be stored in an XCF file.
-
-typedef enum {
-    PROP_END = 0,
-    PROP_COLORMAP = 1,
-    PROP_ACTIVE_LAYER = 2,
-    PROP_ACTIVE_CHANNEL = 3,
-    PROP_SELECTION = 4,
-    PROP_FLOATING_SELECTION = 5,
-    PROP_OPACITY = 6,
-    PROP_MODE = 7,
-    PROP_VISIBLE = 8,
-    PROP_LINKED = 9,
-    PROP_PRESERVE_TRANSPARENCY = 10,
-    PROP_APPLY_MASK = 11,
-    PROP_EDIT_MASK = 12,
-    PROP_SHOW_MASK = 13,
-    PROP_SHOW_MASKED = 14,
-    PROP_OFFSETS = 15,
-    PROP_COLOR = 16,
-    PROP_COMPRESSION = 17,
-    PROP_GUIDES = 18,
-    PROP_RESOLUTION = 19,
-    PROP_TATTOO = 20,
-    PROP_PARASITES = 21,
-    PROP_UNIT = 22,
-    PROP_PATHS = 23,
-    PROP_USER_UNIT = 24
-} PropType;
-
-// From GIMP "xcf.c" v1.2
-
-//! Compression type used in layer tiles.
-
-typedef enum {
-    COMPRESS_NONE = 0,
-    COMPRESS_RLE = 1,
-    COMPRESS_ZLIB = 2,
-    COMPRESS_FRACTAL = 3  /* Unused. */
-} CompressionType;
 
 // From GIMP "paint_funcs.c" v1.2
 

src/imageformats/hdr.cpp

@@ -1,21 +1,23 @@
-/* This file is part of the KDE project
-   Copyright (C) 2005 Christoph Hormann <chris_hormann@gmx.de>
-   Copyright (C) 2005 Ignacio Castaño <castanyo@yahoo.es>
+/*
+    This file is part of the KDE project
+    SPDX-FileCopyrightText: 2005 Christoph Hormann <chris_hormann@gmx.de>
+    SPDX-FileCopyrightText: 2005 Ignacio Castaño <castanyo@yahoo.es>
 
-   This program is free software; you can redistribute it and/or
-   modify it under the terms of the Lesser GNU General Public
-   License as published by the Free Software Foundation; either
-   version 2 of the License, or (at your option) any later version.
+    SPDX-License-Identifier: LGPL-2.0-or-later
 */
 
 #include "hdr_p.h"
 
 #include <QImage>
-#include <QtCore/QDataStream>
+#include <QDataStream>
+#include <QLoggingCategory>
+#include <QRegularExpressionMatch>
 
 #include <QDebug>
 
-typedef Q_UINT8 uchar;
+typedef unsigned char uchar;
+
+Q_LOGGING_CATEGORY(HDRPLUGIN, "kf.imageformats.plugins.hdr", QtWarningMsg)
 
 namespace   // Private.
 {
@@ -93,19 +95,23 @@ static bool LoadHDR(QDataStream &s, const int width, const int height, QImage &i
     uchar val, code;
 
     // Create dst image.
-    if (!img.create(width, height, 32)) {
+    img = QImage(width, height, QImage::Format_RGB32);
+    if (img.isNull()) {
+        qCDebug(HDRPLUGIN) << "Couldn't create image with size" << width << height << "and format RGB32";
         return false;
     }
 
-    QMemArray<uchar> image(width * 4);
+    QByteArray lineArray;
+    lineArray.resize(4 * width);
+    uchar *image = (uchar *) lineArray.data();
 
     for (int cline = 0; cline < height; cline++) {
         QRgb *scanline = (QRgb *) img.scanLine(cline);
 
         // determine scanline type
         if ((width < MINELEN) || (MAXELEN < width)) {
-            Read_Old_Line(image.data(), width, s);
-            RGBE_To_QRgbLine(image.data(), scanline, width);
+            Read_Old_Line(image, width, s);
+            RGBE_To_QRgbLine(image, scanline, width);
             continue;
         }
 
@@ -116,9 +122,9 @@ static bool LoadHDR(QDataStream &s, const int width, const int height, QImage &i
         }
 
         if (val != 2) {
-            s.device()->at(s.device()->at() - 1);
-            Read_Old_Line(image.data(), width, s);
-            RGBE_To_QRgbLine(image.data(), scanline, width);
+            s.device()->ungetChar(val);
+            Read_Old_Line(image, width, s);
+            RGBE_To_QRgbLine(image, scanline, width);
             continue;
         }
 
@@ -132,12 +138,13 @@ static bool LoadHDR(QDataStream &s, const int width, const int height, QImage &i
 
         if ((image[1] != 2) || (image[2] & 128)) {
             image[0] = 2;
-            Read_Old_Line(image.data() + 4, width - 1, s);
-            RGBE_To_QRgbLine(image.data(), scanline, width);
+            Read_Old_Line(image + 4, width - 1, s);
+            RGBE_To_QRgbLine(image, scanline, width);
             continue;
         }
 
         if ((image[2] << 8 | image[3]) != width) {
+            qCDebug(HDRPLUGIN) << "Line of pixels had width" << (image[2] << 8 | image[3]) << "instead of" << width;
             return false;
         }
 
@@ -146,6 +153,7 @@ static bool LoadHDR(QDataStream &s, const int width, const int height, QImage &i
             for (int j = 0; j < width;) {
                 s >> code;
                 if (s.atEnd()) {
+                    qCDebug(HDRPLUGIN) << "Truncated HDR file";
                     return false;
                 }
                 if (code > 128) {
@@ -168,7 +176,7 @@ static bool LoadHDR(QDataStream &s, const int width, const int height, QImage &i
             }
         }
 
-        RGBE_To_QRgbLine(image.data(), scanline, width);
+        RGBE_To_QRgbLine(image, scanline, width);
     }
 
     return true;
@@ -176,63 +184,110 @@ static bool LoadHDR(QDataStream &s, const int width, const int height, QImage &i
 
 } // namespace
 
-Q_DECL_EXPORT void kimgio_hdr_read(QImageIO *io)
+bool HDRHandler::read(QImage *outImage)
 {
     int len;
-    char line[MAXLINE];
-    //bool validHeader = false;
-    bool validFormat = false;
+    QByteArray line(MAXLINE + 1, Qt::Uninitialized);
+    QByteArray format;
 
     // Parse header
     do {
-        len = io->ioDevice()->readLine(line, MAXLINE);
+        len = device()->readLine(line.data(), MAXLINE);
 
-        /*if (strcmp(line, "#?RADIANCE\n") == 0 || strcmp(line, "#?RGBE\n") == 0)
-        {
-            validHeader = true;
-        }*/
-        if (strcmp(line, "FORMAT=32-bit_rle_rgbe\n") == 0) {
-            validFormat = true;
+        if (line.startsWith("FORMAT=")) {
+            format = line.mid(7, len - 7 - 1 /*\n*/);
         }
 
     } while ((len > 0) && (line[0] != '\n'));
 
-    if (/*!validHeader ||*/ !validFormat) {
-        // qDebug() << "Unknown HDR format.";
-        io->setImage(0);
-        io->setStatus(-1);
-        return;
+    if (format != "32-bit_rle_rgbe") {
+        qCDebug(HDRPLUGIN) << "Unknown HDR format:" << format;
+        return false;
     }
 
-    io->ioDevice()->readLine(line, MAXLINE);
+    len = device()->readLine(line.data(), MAXLINE);
+    line.resize(len);
 
-    char s1[3], s2[3];
-    int width, height;
-    if (sscanf(line, "%2[+-XY] %d %2[+-XY] %d\n", s1, &height, s2, &width) != 4)
-        //if( sscanf(line, "-Y %d +X %d", &height, &width) < 2 )
-    {
-        // qDebug() << "Invalid HDR file.";
-        io->setImage(0);
-        io->setStatus(-1);
-        return;
+    /*
+       TODO: handle flipping and rotation, as per the spec below
+       The single resolution line consists of 4 values, a X and Y label each followed by a numerical
+       integer value. The X and Y are immediately preceded by a sign which can be used to indicate
+       flipping, the order of the X and Y indicate rotation. The standard coordinate system for
+       Radiance images would have the following resolution string -Y N +X N. This indicates that the
+       vertical axis runs down the file and the X axis is to the right (imagining the image as a
+       rectangular block of data). A -X would indicate a horizontal flip of the image. A +Y would
+       indicate a vertical flip. If the X value appears before the Y value then that indicates that
+       the image is stored in column order rather than row order, that is, it is rotated by 90 degrees.
+       The reader can convince themselves that the 8 combinations cover all the possible image orientations
+       and rotations.
+    */
+    QRegularExpression resolutionRegExp(QStringLiteral("([+\\-][XY]) ([0-9]+) ([+\\-][XY]) ([0-9]+)\n"));
+    QRegularExpressionMatch match = resolutionRegExp.match(QString::fromLatin1(line));
+    if (!match.hasMatch()) {
+        qCDebug(HDRPLUGIN) << "Invalid HDR file, the first line after the header didn't have the expected format:" << line;
+        return false;
     }
+    const int width = match.captured(2).toInt();
+    const int height = match.captured(4).toInt();
 
-    QDataStream s(io->ioDevice());
+    QDataStream s(device());
 
     QImage img;
     if (!LoadHDR(s, width, height, img)) {
         // qDebug() << "Error loading HDR file.";
-        io->setImage(0);
-        io->setStatus(-1);
-        return;
+        return false;
     }
 
-    io->setImage(img);
-    io->setStatus(0);
+    *outImage = img;
+    return true;
 }
 
-Q_DECL_EXPORT void kimgio_hdr_write(QImageIO *)
+HDRHandler::HDRHandler()
 {
-    // intentionally not implemented (since writing low dynamic range data to a HDR file is nonsense.)
 }
 
+bool HDRHandler::canRead() const
+{
+    if (canRead(device())) {
+        setFormat("hdr");
+        return true;
+    }
+    return false;
+}
+
+bool HDRHandler::canRead(QIODevice *device)
+{
+    if (!device) {
+        qWarning("HDRHandler::canRead() called with no device");
+        return false;
+    }
+
+    return device->peek(11) == "#?RADIANCE\n" || device->peek(7) == "#?RGBE\n";
+}
+
+QImageIOPlugin::Capabilities HDRPlugin::capabilities(QIODevice *device, const QByteArray &format) const
+{
+    if (format == "hdr") {
+        return Capabilities(CanRead);
+    }
+    if (!format.isEmpty()) {
+        return {};
+    }
+    if (!device->isOpen()) {
+        return {};
+    }
+
+    Capabilities cap;
+    if (device->isReadable() && HDRHandler::canRead(device)) {
+        cap |= CanRead;
+    }
+    return cap;
+}
+
+QImageIOHandler *HDRPlugin::create(QIODevice *device, const QByteArray &format) const
+{
+    QImageIOHandler *handler = new HDRHandler;
+    handler->setDevice(device);
+    handler->setFormat(format);
+    return handler;
+}

src/imageformats/hdr.json

@@ -0,0 +1,4 @@
+{
+    "Keys": [ "hdr" ],
+    "MimeTypes": [ "image/x-hdr", "image/vnd.radiance" ]
+}

src/imageformats/hdr_p.h

@@ -1,21 +1,34 @@
-/* This file is part of the KDE project
-   Copyright (C) 2005 Christoph Hormann <chris_hormann@gmx.de>
+/*
+    This file is part of the KDE project
+    SPDX-FileCopyrightText: 2005 Christoph Hormann <chris_hormann@gmx.de>
 
-   This program is free software; you can redistribute it and/or
-   modify it under the terms of the Lesser GNU General Public
-   License as published by the Free Software Foundation; either
-   version 2 of the License, or (at your option) any later version.
+    SPDX-License-Identifier: LGPL-2.0-or-later
 */
 
-#ifndef KIMG_HDR_H
-#define KIMG_HDR_H
+#ifndef KIMG_HDR_P_H
+#define KIMG_HDR_P_H
 
-class QImageIO;
+#include <QImageIOPlugin>
 
-extern "C" {
-    void kimgio_hdr_read(QImageIO *);
-    void kimgio_hdr_write(QImageIO *);
-}
+class HDRHandler : public QImageIOHandler
+{
+public:
+    HDRHandler();
 
-#endif
+    bool canRead() const override;
+    bool read(QImage *outImage) override;
 
+    static bool canRead(QIODevice *device);
+};
+
+class HDRPlugin : public QImageIOPlugin
+{
+    Q_OBJECT
+    Q_PLUGIN_METADATA(IID "org.qt-project.Qt.QImageIOHandlerFactoryInterface" FILE "hdr.json")
+
+public:
+    Capabilities capabilities(QIODevice *device, const QByteArray &format) const override;
+    QImageIOHandler *create(QIODevice *device, const QByteArray &format = QByteArray()) const override;
+};
+
+#endif // KIMG_HDR_P_H

src/imageformats/jp2.cpp

@@ -1,526 +0,0 @@
-/*
-* QImageIO Routines to read/write JPEG2000 images.
-* copyright (c) 2002 Michael Ritzert <michael@ritzert.de>
-*
-* This library is distributed under the conditions of the GNU LGPL.
-*/
-
-#include "jp2_p.h"
-
-#include <config-jp2.h>
-
-#if HAVE_SYS_TYPES_H
-#include <sys/types.h>
-#endif
-
-#if HAVE_STDINT_H
-#include <stdint.h>
-#endif
-
-#include <QImage>
-#include <QVariant>
-#include <QTextStream>
-
-// dirty, but avoids a warning because jasper.h includes jas_config.h.
-#undef PACKAGE
-#undef VERSION
-#include <jasper/jasper.h>
-
-// code taken in parts from JasPer's jiv.c
-
-#define DEFAULT_RATE 0.10
-#define MAXCMPTS 256
-
-/************************* JasPer QIODevice stream ***********************/
-
-//unfortunately this is declared as static in JasPer libraries
-static jas_stream_t *jas_stream_create()
-{
-    jas_stream_t *stream;
-
-    if (!(stream = (jas_stream_t *)jas_malloc(sizeof(jas_stream_t)))) {
-        return 0;
-    }
-    stream->openmode_ = 0;
-    stream->bufmode_ = 0;
-    stream->flags_ = 0;
-    stream->bufbase_ = 0;
-    stream->bufstart_ = 0;
-    stream->bufsize_ = 0;
-    stream->ptr_ = 0;
-    stream->cnt_ = 0;
-    stream->ops_ = 0;
-    stream->obj_ = 0;
-    stream->rwcnt_ = 0;
-    stream->rwlimit_ = -1;
-
-    return stream;
-}
-
-//unfortunately this is declared as static in JasPer libraries
-static void jas_stream_initbuf(jas_stream_t *stream, int bufmode, char *buf,
-                               int bufsize)
-{
-    /* If this function is being called, the buffer should not have been
-      initialized yet. */
-    assert(!stream->bufbase_);
-
-    if (bufmode != JAS_STREAM_UNBUF) {
-        /* The full- or line-buffered mode is being employed. */
-        if (!buf) {
-            /* The caller has not specified a buffer to employ, so allocate
-              one. */
-            if ((stream->bufbase_ = (unsigned char *)jas_malloc(JAS_STREAM_BUFSIZE +
-                                    JAS_STREAM_MAXPUTBACK))) {
-                stream->bufmode_ |= JAS_STREAM_FREEBUF;
-                stream->bufsize_ = JAS_STREAM_BUFSIZE;
-            } else {
-                /* The buffer allocation has failed.  Resort to unbuffered
-                  operation. */
-                stream->bufbase_ = stream->tinybuf_;
-                stream->bufsize_ = 1;
-            }
-        } else {
-            /* The caller has specified a buffer to employ. */
-            /* The buffer must be large enough to accommodate maximum
-              putback. */
-            assert(bufsize > JAS_STREAM_MAXPUTBACK);
-            stream->bufbase_ = JAS_CAST(uchar *, buf);
-            stream->bufsize_ = bufsize - JAS_STREAM_MAXPUTBACK;
-        }
-    } else {
-        /* The unbuffered mode is being employed. */
-        /* A buffer should not have been supplied by the caller. */
-        assert(!buf);
-        /* Use a trivial one-character buffer. */
-        stream->bufbase_ = stream->tinybuf_;
-        stream->bufsize_ = 1;
-    }
-    stream->bufstart_ = &stream->bufbase_[JAS_STREAM_MAXPUTBACK];
-    stream->ptr_ = stream->bufstart_;
-    stream->cnt_ = 0;
-    stream->bufmode_ |= bufmode & JAS_STREAM_BUFMODEMASK;
-}
-
-static int qiodevice_read(jas_stream_obj_t *obj, char *buf, int cnt)
-{
-    QIODevice *io = (QIODevice *) obj;
-    return io->read(buf, cnt);
-}
-
-static int qiodevice_write(jas_stream_obj_t *obj, char *buf, int cnt)
-{
-    QIODevice *io = (QIODevice *) obj;
-    return io->write(buf, cnt);
-}
-
-static long qiodevice_seek(jas_stream_obj_t *obj, long offset, int origin)
-{
-    QIODevice *io = (QIODevice *) obj;
-    long newpos;
-
-    switch (origin) {
-    case SEEK_SET:
-        newpos = offset;
-        break;
-    case SEEK_END:
-        newpos = io->size() - offset;
-        break;
-    case SEEK_CUR:
-        newpos = io->pos() + offset;
-        break;
-    default:
-        return -1;
-    }
-    if (newpos < 0) {
-        return -1;
-    }
-    if (io->seek(newpos)) {
-        return newpos;
-    } else {
-        return -1;
-    }
-}
-
-static int qiodevice_close(jas_stream_obj_t *)
-{
-    return 0;
-}
-
-static jas_stream_ops_t jas_stream_qiodeviceops = {
-    qiodevice_read,
-    qiodevice_write,
-    qiodevice_seek,
-    qiodevice_close
-};
-
-static jas_stream_t *jas_stream_qiodevice(QIODevice *iodevice)
-{
-    jas_stream_t *stream;
-
-    if (!iodevice) {
-        return 0;
-    }
-    if (!(stream = jas_stream_create())) {
-        return 0;
-    }
-
-    /* A stream associated with a memory buffer is always opened
-    for both reading and writing in binary mode. */
-    stream->openmode_ = JAS_STREAM_READ | JAS_STREAM_WRITE | JAS_STREAM_BINARY;
-
-    jas_stream_initbuf(stream, JAS_STREAM_FULLBUF, 0, 0);
-
-    /* Select the operations for a memory stream. */
-    stream->obj_ = (void *)iodevice;
-    stream->ops_ = &jas_stream_qiodeviceops;
-
-    return stream;
-}
-
-/************************ End of JasPer QIODevice stream ****************/
-
-typedef struct {
-    jas_image_t *image;
-
-    int cmptlut[MAXCMPTS];
-
-    jas_image_t *altimage;
-} gs_t;
-
-static jas_image_t *
-read_image(QIODevice *io)
-{
-    jas_stream_t *in = 0;
-
-    in = jas_stream_qiodevice(io);
-
-    if (!in) {
-        return 0;
-    }
-
-    jas_image_t *image = jas_image_decode(in, -1, 0);
-    jas_stream_close(in);
-
-    // image may be 0, but that's Ok
-    return image;
-} // read_image
-
-static bool
-convert_colorspace(gs_t &gs)
-{
-    jas_cmprof_t *outprof = jas_cmprof_createfromclrspc(JAS_CLRSPC_SRGB);
-    if (!outprof) {
-        return false;
-    }
-
-    gs.altimage = jas_image_chclrspc(gs.image, outprof,
-                                     JAS_CMXFORM_INTENT_PER);
-    if (!gs.altimage) {
-        return false;
-    }
-
-    return true;
-} // convert_colorspace
-
-static bool
-render_view(gs_t &gs, QImage *outImage)
-{
-    if (!gs.altimage) {
-        return false;
-    }
-    QImage qti;
-    if ((gs.cmptlut[0] = jas_image_getcmptbytype(gs.altimage,
-                         JAS_IMAGE_CT_COLOR(JAS_CLRSPC_CHANIND_RGB_R))) < 0 ||
-            (gs.cmptlut[1] = jas_image_getcmptbytype(gs.altimage,
-                             JAS_IMAGE_CT_COLOR(JAS_CLRSPC_CHANIND_RGB_G))) < 0 ||
-            (gs.cmptlut[2] = jas_image_getcmptbytype(gs.altimage,
-                             JAS_IMAGE_CT_COLOR(JAS_CLRSPC_CHANIND_RGB_B))) < 0) {
-        return false;
-    } // if
-
-    const int *cmptlut = gs.cmptlut;
-    int v[3];
-
-    // check that all components have the same size.
-    const int width = jas_image_cmptwidth(gs.altimage, cmptlut[0]);
-    const int height = jas_image_cmptheight(gs.altimage, cmptlut[0]);
-    for (int i = 1; i < 3; ++i) {
-        if (jas_image_cmptwidth(gs.altimage, cmptlut[i]) != width ||
-                jas_image_cmptheight(gs.altimage, cmptlut[i]) != height) {
-            return false;
-        }
-    } // for
-
-    jas_matrix_t *cmptmatrix[3];
-    jas_seqent_t *buf[3];
-    int prec[3];
-
-    for (int k = 0; k < 3; ++k) {
-        prec[k] = jas_image_cmptprec(gs.altimage, cmptlut[k]);
-        if (!(cmptmatrix[k] = jas_matrix_create(1, width))) {
-            return false;
-        }
-    }
-
-    qti = QImage(jas_image_width(gs.altimage), jas_image_height(gs.altimage),
-                 QImage::Format_RGB32);
-    if (qti.isNull()) {
-        return false;
-    }
-    uint32_t *data = (uint32_t *)qti.bits();
-
-    for (int y = 0; y < height; ++y) {
-        for (int k = 0; k < 3; ++k) {
-            if (jas_image_readcmpt(gs.altimage, cmptlut[k], 0, y, width, 1, cmptmatrix[k])) {
-                return false;
-            }
-            buf[k] = jas_matrix_getref(cmptmatrix[k], 0, 0);
-        }
-        for (int x = 0; x < width; ++x) {
-            for (int k = 0; k < 3; ++k) {
-                v[k] = *buf[k];
-                // if the precision of the component is too small, increase
-                // it to use the complete value range.
-                v[k] <<= 8 - prec[k];
-
-                if (v[k] < 0) {
-                    v[k] = 0;
-                } else if (v[k] > 255) {
-                    v[k] = 255;
-                }
-                ++buf[k];
-            } // for k
-
-            *data++ = qRgb(v[0], v[1], v[2]);
-        } // for x
-    } // for y
-
-    for (int k = 0; k < 3; ++k) {
-        if (cmptmatrix[k]) {
-            jas_matrix_destroy(cmptmatrix[k]);
-        }
-    }
-
-    *outImage = qti;
-    return true;
-} // render_view
-
-static jas_image_t *
-create_image(const QImage &qi)
-{
-    // prepare the component parameters
-    jas_image_cmptparm_t *cmptparms = new jas_image_cmptparm_t[ 3 ];
-
-    for (int i = 0; i < 3; ++i) {
-        // x and y offset
-        cmptparms[i].tlx = 0;
-        cmptparms[i].tly = 0;
-
-        // the resulting image will be hstep*width x vstep*height !
-        cmptparms[i].hstep = 1;
-        cmptparms[i].vstep = 1;
-        cmptparms[i].width = qi.width();
-        cmptparms[i].height = qi.height();
-
-        // we write everything as 24bit truecolor ATM
-        cmptparms[i].prec = 8;
-        cmptparms[i].sgnd = false;
-    }
-
-    jas_image_t *ji = jas_image_create(3 /* number components */, cmptparms, JAS_CLRSPC_UNKNOWN);
-    delete[] cmptparms;
-
-    // returning 0 is ok
-    return ji;
-} // create_image
-
-static bool
-write_components(jas_image_t *ji, const QImage &qi)
-{
-    const unsigned height = qi.height();
-    const unsigned width = qi.width();
-
-    jas_matrix_t *m = jas_matrix_create(height, width);
-    if (!m) {
-        return false;
-    }
-
-    jas_image_setclrspc(ji, JAS_CLRSPC_SRGB);
-
-    jas_image_setcmpttype(ji, 0, JAS_IMAGE_CT_RGB_R);
-    for (uint y = 0; y < height; ++y)
-        for (uint x = 0; x < width; ++x) {
-            jas_matrix_set(m, y, x, qRed(qi.pixel(x, y)));
-        }
-    jas_image_writecmpt(ji, 0, 0, 0, width, height, m);
-
-    jas_image_setcmpttype(ji, 1, JAS_IMAGE_CT_RGB_G);
-    for (uint y = 0; y < height; ++y)
-        for (uint x = 0; x < width; ++x) {
-            jas_matrix_set(m, y, x, qGreen(qi.pixel(x, y)));
-        }
-    jas_image_writecmpt(ji, 1, 0, 0, width, height, m);
-
-    jas_image_setcmpttype(ji, 2, JAS_IMAGE_CT_RGB_B);
-    for (uint y = 0; y < height; ++y)
-        for (uint x = 0; x < width; ++x) {
-            jas_matrix_set(m, y, x, qBlue(qi.pixel(x, y)));
-        }
-    jas_image_writecmpt(ji, 2, 0, 0, width, height, m);
-    jas_matrix_destroy(m);
-
-    return true;
-} // write_components
-
-static bool
-write_image(const QImage &image, QIODevice *io, int quality)
-{
-    jas_stream_t *stream = 0;
-    stream = jas_stream_qiodevice(io);
-
-    // by here, a jas_stream_t is open
-    if (!stream) {
-        return false;
-    }
-
-    jas_image_t *ji = create_image(image);
-    if (!ji) {
-        jas_stream_close(stream);
-        return false;
-    } // if
-
-    if (!write_components(ji, image)) {
-        jas_stream_close(stream);
-        jas_image_destroy(ji);
-        return false;
-    } // if
-
-    // optstr:
-    // - rate=#B => the resulting file size is about # bytes
-    // - rate=0.0 .. 1.0 => the resulting file size is about the factor times
-    //                      the uncompressed size
-    // use sprintf for locale-aware string
-    char rateBuffer[16];
-    sprintf(rateBuffer, "rate=%.2g\n", (quality < 0) ? DEFAULT_RATE : quality / 100.0);
-    int i = jp2_encode(ji, stream, rateBuffer);
-
-    jas_image_destroy(ji);
-    jas_stream_close(stream);
-
-    if (i != 0) {
-        return false;
-    }
-
-    return true;
-}
-
-JP2Handler::JP2Handler()
-{
-    quality = 75;
-    jas_init();
-}
-
-JP2Handler::~JP2Handler()
-{
-    jas_cleanup();
-}
-
-bool JP2Handler::canRead() const
-{
-    if (canRead(device())) {
-        setFormat("jp2");
-        return true;
-    }
-    return false;
-}
-
-bool JP2Handler::canRead(QIODevice *device)
-{
-    if (!device) {
-        return false;
-    }
-    return device->peek(6) == QByteArray("\x00\x00\x00\x0C\x6A\x50", 6);
-}
-
-bool JP2Handler::read(QImage *image)
-{
-    if (!canRead()) {
-        return false;
-    }
-
-    gs_t gs;
-    if (!(gs.image = read_image(device()))) {
-        return false;
-    }
-
-    if (!convert_colorspace(gs)) {
-        return false;
-    }
-
-    render_view(gs, image);
-
-    if (gs.image) {
-        jas_image_destroy(gs.image);
-    }
-    if (gs.altimage) {
-        jas_image_destroy(gs.altimage);
-    }
-    return true;
-
-}
-
-bool JP2Handler::write(const QImage &image)
-{
-    return write_image(image, device(), quality);
-}
-
-bool JP2Handler::supportsOption(ImageOption option) const
-{
-    return option == Quality;
-}
-
-QVariant JP2Handler::option(ImageOption option) const
-{
-    if (option == Quality) {
-        return quality;
-    }
-    return QVariant();
-}
-
-void JP2Handler::setOption(ImageOption option, const QVariant &value)
-{
-    if (option == Quality) {
-        quality = qBound(-1, value.toInt(), 100);
-    }
-}
-
-QImageIOPlugin::Capabilities JP2Plugin::capabilities(QIODevice *device, const QByteArray &format) const
-{
-    if (format == "jp2") {
-        return Capabilities(CanRead | CanWrite);
-    }
-    if (!format.isEmpty()) {
-        return 0;
-    }
-    if (!device->isOpen()) {
-        return 0;
-    }
-
-    Capabilities cap;
-    if (device->isReadable() && JP2Handler::canRead(device)) {
-        cap |= CanRead;
-    }
-    if (device->isWritable()) {
-        cap |= CanWrite;
-    }
-    return cap;
-}
-
-QImageIOHandler *JP2Plugin::create(QIODevice *device, const QByteArray &format) const
-{
-    QImageIOHandler *handler = new JP2Handler;
-    handler->setDevice(device);
-    handler->setFormat(format);
-    return handler;
-}

src/imageformats/jp2.json

@@ -1,4 +0,0 @@
-{
-    "Keys": [ "jp2" ],
-    "MimeTypes": [ "image/jp2" ]
-}

src/imageformats/jp2_p.h

@@ -1,42 +0,0 @@
-/*
-* QImageIO Routines to read/write JPEG2000 images.
-* copyright (c) 2002 Michael Ritzert <michael@ritzert.de>
-*
-* This library is distributed under the conditions of the GNU LGPL.
-*/
-#ifndef KIMG_JP2_H
-#define KIMG_JP2_H
-
-#include <QImageIOPlugin>
-
-class JP2Handler : public QImageIOHandler
-{
-public:
-    JP2Handler();
-    virtual ~JP2Handler();
-
-    virtual bool canRead() const;
-    virtual bool read(QImage *image);
-    virtual bool write(const QImage &image);
-
-    virtual bool supportsOption(ImageOption option) const;
-    virtual QVariant option(ImageOption option) const;
-    virtual void setOption(ImageOption option, const QVariant &value);
-
-    static bool canRead(QIODevice *device);
-
-private:
-    int quality;
-};
-
-class JP2Plugin : public QImageIOPlugin
-{
-    Q_OBJECT
-    Q_PLUGIN_METADATA(IID "org.qt-project.Qt.QImageIOHandlerFactoryInterface" FILE "jp2.json")
-
-public:
-    virtual Capabilities capabilities(QIODevice *device, const QByteArray &format) const;
-    virtual QImageIOHandler *create(QIODevice *device, const QByteArray &format = QByteArray()) const;
-};
-
-#endif // KIMG_JP2_H

src/imageformats/kra.cpp

@@ -0,0 +1,89 @@
+/*
+    This file is part of the KDE project
+    SPDX-FileCopyrightText: 2013 Boudewijn Rempt <boud@valdyas.org>
+
+    SPDX-License-Identifier: LGPL-2.0-or-later
+
+    This code is based on Thacher Ulrich PSD loading code released
+    on public domain. See: http://tulrich.com/geekstuff/
+*/
+
+#include "kra.h"
+
+#include <kzip.h>
+
+#include <QImage>
+#include <QIODevice>
+#include <QFile>
+
+static constexpr char s_magic[] = "application/x-krita";
+static constexpr int s_magic_size = sizeof(s_magic) - 1; // -1 to remove the last \0
+
+KraHandler::KraHandler()
+{
+}
+
+bool KraHandler::canRead() const
+{
+    if (canRead(device())) {
+        setFormat("kra");
+        return true;
+    }
+    return false;
+}
+
+bool KraHandler::read(QImage *image)
+{
+    KZip zip(device());
+    if (!zip.open(QIODevice::ReadOnly)) return false;
+
+    const KArchiveEntry *entry = zip.directory()->entry(QStringLiteral("mergedimage.png"));
+    if (!entry || !entry->isFile()) return false;
+
+    const KZipFileEntry* fileZipEntry = static_cast<const KZipFileEntry*>(entry);
+
+    image->loadFromData(fileZipEntry->data(), "PNG");
+
+    return true;
+}
+
+bool KraHandler::canRead(QIODevice *device)
+{
+    if (!device) {
+        qWarning("KraHandler::canRead() called with no device");
+        return false;
+    }
+
+    char buff[57];
+    if (device->peek(buff, sizeof(buff)) == sizeof(buff))
+        return memcmp(buff + 0x26, s_magic, s_magic_size) == 0;
+
+    return false;
+}
+
+QImageIOPlugin::Capabilities KraPlugin::capabilities(QIODevice *device, const QByteArray &format) const
+{
+    if (format == "kra" || format == "KRA") {
+        return Capabilities(CanRead);
+    }
+    if (!format.isEmpty()) {
+        return {};
+    }
+    if (!device->isOpen()) {
+        return {};
+    }
+
+    Capabilities cap;
+    if (device->isReadable() && KraHandler::canRead(device)) {
+        cap |= CanRead;
+    }
+    return cap;
+}
+
+QImageIOHandler *KraPlugin::create(QIODevice *device, const QByteArray &format) const
+{
+    QImageIOHandler *handler = new KraHandler;
+    handler->setDevice(device);
+    handler->setFormat(format);
+    return handler;
+}

src/imageformats/kra.desktop

@@ -1,7 +1,7 @@
 [Desktop Entry]
 Type=Service
 X-KDE-ServiceTypes=QImageIOPlugins
-X-KDE-ImageFormat=pnm
-X-KDE-MimeType=image/x-portable-anymap
+X-KDE-ImageFormat=kra
+X-KDE-MimeType=application/x-krita
 X-KDE-Read=true
 X-KDE-Write=false

src/imageformats/kra.h

@@ -0,0 +1,36 @@
+/*
+    This file is part of the KDE project
+    SPDX-FileCopyrightText: 2013 Boudewijn Rempt <boud@valdyas.org>
+
+    SPDX-License-Identifier: LGPL-2.0-or-later
+*/
+
+#ifndef KIMG_KRA_H
+#define KIMG_KRA_H
+
+#include <QImageIOPlugin>
+
+class KraHandler : public QImageIOHandler
+{
+public:
+    KraHandler();
+
+    bool canRead() const override;
+    bool read(QImage *image)  override;
+
+    static bool canRead(QIODevice *device);
+};
+
+class KraPlugin : public QImageIOPlugin
+{
+    Q_OBJECT
+    Q_PLUGIN_METADATA(IID "org.qt-project.Qt.QImageIOHandlerFactoryInterface" FILE "kra.json")
+
+public:
+    Capabilities capabilities(QIODevice *device, const QByteArray &format) const override;
+    QImageIOHandler *create(QIODevice *device, const QByteArray &format = QByteArray()) const override;
+};
+
+
+
+#endif

src/imageformats/kra.json

@@ -0,0 +1,4 @@
+{
+    "Keys": [ "kra" ],
+    "MimeTypes": [ "application/x-krita" ]
+}

src/imageformats/ora.cpp

@@ -0,0 +1,88 @@
+/*
+    This file is part of the KDE project
+    SPDX-FileCopyrightText: 2013 Boudewijn Rempt <boud@valdyas.org>
+
+    SPDX-License-Identifier: LGPL-2.0-or-later
+
+    This code is based on Thacher Ulrich PSD loading code released
+    on public domain. See: http://tulrich.com/geekstuff/
+*/
+
+#include "ora.h"
+
+#include <QImage>
+#include <QScopedPointer>
+
+#include <kzip.h>
+
+static constexpr char s_magic[] = "image/openraster";
+static constexpr int s_magic_size = sizeof(s_magic) - 1; // -1 to remove the last \0
+
+OraHandler::OraHandler()
+{
+}
+
+bool OraHandler::canRead() const
+{
+    if (canRead(device())) {
+        setFormat("ora");
+        return true;
+    }
+    return false;
+}
+
+bool OraHandler::read(QImage *image)
+{
+    KZip zip(device());
+    if (!zip.open(QIODevice::ReadOnly)) return false;
+
+    const KArchiveEntry *entry = zip.directory()->entry(QStringLiteral("mergedimage.png"));
+    if (!entry || !entry->isFile()) return false;
+
+    const KZipFileEntry* fileZipEntry = static_cast<const KZipFileEntry*>(entry);
+
+    image->loadFromData(fileZipEntry->data(), "PNG");
+
+    return true;
+}
+
+bool OraHandler::canRead(QIODevice *device)
+{
+    if (!device) {
+        qWarning("OraHandler::canRead() called with no device");
+        return false;
+    }
+
+    char buff[54];
+    if (device->peek(buff, sizeof(buff)) == sizeof(buff))
+        return memcmp(buff + 0x26, s_magic, s_magic_size) == 0;
+
+    return false;
+}
+
+QImageIOPlugin::Capabilities OraPlugin::capabilities(QIODevice *device, const QByteArray &format) const
+{
+    if (format == "ora" || format == "ORA") {
+        return Capabilities(CanRead);
+    }
+    if (!format.isEmpty()) {
+        return {};
+    }
+    if (!device->isOpen()) {
+        return {};
+    }
+
+    Capabilities cap;
+    if (device->isReadable() && OraHandler::canRead(device)) {
+        cap |= CanRead;
+    }
+    return cap;
+}
+
+QImageIOHandler *OraPlugin::create(QIODevice *device, const QByteArray &format) const
+{
+    QImageIOHandler *handler = new OraHandler;
+    handler->setDevice(device);
+    handler->setFormat(format);
+    return handler;
+}

src/imageformats/ora.desktop

@@ -1,7 +1,7 @@
 [Desktop Entry]
 Type=Service
 X-KDE-ServiceTypes=QImageIOPlugins
-X-KDE-ImageFormat=dds
-X-KDE-MimeType=image/x-dds
+X-KDE-ImageFormat=ora
+X-KDE-MimeType=image/openraster
 X-KDE-Read=true
 X-KDE-Write=false

src/imageformats/ora.h

@@ -0,0 +1,36 @@
+/*
+    This file is part of the KDE project
+    SPDX-FileCopyrightText: 2013 Boudewijn Rempt <boud@valdyas.org>
+
+    SPDX-License-Identifier: LGPL-2.0-or-later
+*/
+
+#ifndef KIMG_ORA_H
+#define KIMG_ORA_H
+
+#include <QImageIOPlugin>
+
+class OraHandler : public QImageIOHandler
+{
+public:
+    OraHandler();
+
+    bool canRead() const override;
+    bool read(QImage *image)  override;
+
+    static bool canRead(QIODevice *device);
+};
+
+
+class OraPlugin : public QImageIOPlugin
+{
+    Q_OBJECT
+    Q_PLUGIN_METADATA(IID "org.qt-project.Qt.QImageIOHandlerFactoryInterface" FILE "ora.json")
+public:
+    Capabilities capabilities(QIODevice *device, const QByteArray &format) const override;
+    QImageIOHandler *create(QIODevice *device, const QByteArray &format = QByteArray()) const override;
+};
+
+
+#endif
+

src/imageformats/ora.json

@@ -0,0 +1,4 @@
+{
+    "Keys": [ "ora" ],
+    "MimeTypes": [ "image/openraster" ]
+}

src/imageformats/pcx.cpp

@@ -1,17 +1,15 @@
-/* This file is part of the KDE project
-   Copyright (C) 2002-2005 Nadeem Hasan <nhasan@kde.org>
+/*
+    This file is part of the KDE project
+    SPDX-FileCopyrightText: 2002-2005 Nadeem Hasan <nhasan@kde.org>
 
-   This program is free software; you can redistribute it and/or
-   modify it under the terms of the GNU Lesser General Public
-   License (LGPL) as published by the Free Software Foundation; either
-   version 2 of the License, or (at your option) any later version.
+    SPDX-License-Identifier: LGPL-2.0-or-later
 */
 
 #include "pcx_p.h"
 
 #include <QColor>
 #include <QDataStream>
-// #include <QDebug>
+#include <QDebug>
 #include <QImage>
 
 
@@ -23,7 +21,7 @@ public:
     quint8 g;
     quint8 b;
 
-    static RGB from(const QRgb &color)
+    static RGB from(const QRgb color)
     {
         RGB c;
         c.r = qRed(color);
@@ -169,7 +167,7 @@ static QDataStream &operator>>(QDataStream &s, PCXHEADER &ph)
     return s;
 }
 
-static QDataStream &operator<<(QDataStream &s, const RGB &rgb)
+static QDataStream &operator<<(QDataStream &s, const RGB rgb)
 {
     s << rgb.r << rgb.g << rgb.b;
 
@@ -253,6 +251,11 @@ static void readImage1(QImage &img, QDataStream &s, const PCXHEADER &header)
     img = QImage(header.width(), header.height(), QImage::Format_Mono);
     img.setColorCount(2);
 
+    if (img.isNull()) {
+        qWarning() << "Failed to allocate image, invalid dimensions?" << QSize(header.width(), header.height());
+        return;
+    }
+
     for (int y = 0; y < header.height(); ++y) {
         if (s.atEnd()) {
             img = QImage();
@@ -279,6 +282,10 @@ static void readImage4(QImage &img, QDataStream &s, const PCXHEADER &header)
 
     img = QImage(header.width(), header.height(), QImage::Format_Indexed8);
     img.setColorCount(16);
+    if (img.isNull()) {
+        qWarning() << "Failed to allocate image, invalid dimensions?" << QSize(header.width(), header.height());
+        return;
+    }
 
     for (int y = 0; y < header.height(); ++y) {
         if (s.atEnd()) {
@@ -298,6 +305,9 @@ static void readImage4(QImage &img, QDataStream &s, const PCXHEADER &header)
         }
 
         uchar *p = img.scanLine(y);
+        if (!p) {
+            qWarning() << "Failed to get scanline for" << y << "might be out of bounds";
+        }
         for (int x = 0; x < header.width(); ++x) {
             p[ x ] = pixbuf[ x ];
         }
@@ -316,6 +326,11 @@ static void readImage8(QImage &img, QDataStream &s, const PCXHEADER &header)
     img = QImage(header.width(), header.height(), QImage::Format_Indexed8);
     img.setColorCount(256);
 
+    if (img.isNull()) {
+        qWarning() << "Failed to allocate image, invalid dimensions?" << QSize(header.width(), header.height());
+        return;
+    }
+
     for (int y = 0; y < header.height(); ++y) {
         if (s.atEnd()) {
             img = QImage();
@@ -325,6 +340,10 @@ static void readImage8(QImage &img, QDataStream &s, const PCXHEADER &header)
         readLine(s, buf, header);
 
         uchar *p = img.scanLine(y);
+
+        if (!p)
+            return;
+
         unsigned int bpl = qMin(header.BytesPerLine, (quint16)header.width());
         for (unsigned int x = 0; x < bpl; ++x) {
             p[ x ] = buf[ x ];
@@ -353,6 +372,11 @@ static void readImage24(QImage &img, QDataStream &s, const PCXHEADER &header)
 
     img = QImage(header.width(), header.height(), QImage::Format_RGB32);
 
+    if (img.isNull()) {
+        qWarning() << "Failed to allocate image, invalid dimensions?" << QSize(header.width(), header.height());
+        return;
+    }
+
     for (int y = 0; y < header.height(); ++y) {
         if (s.atEnd()) {
             img = QImage();
@@ -667,10 +691,10 @@ QImageIOPlugin::Capabilities PCXPlugin::capabilities(QIODevice *device, const QB
         return Capabilities(CanRead | CanWrite);
     }
     if (!format.isEmpty()) {
-        return 0;
+        return {};
     }
     if (!device->isOpen()) {
-        return 0;
+        return {};
     }
 
     Capabilities cap;

src/imageformats/pcx_p.h

@@ -1,14 +1,12 @@
-/* This file is part of the KDE project
-   Copyright (C) 2002-2003 Nadeem Hasan <nhasan@kde.org>
+/*
+    This file is part of the KDE project
+    SPDX-FileCopyrightText: 2002-2003 Nadeem Hasan <nhasan@kde.org>
 
-   This program is free software; you can redistribute it and/or
-   modify it under the terms of the Lesser GNU General Public
-   License as published by the Free Software Foundation; either
-   version 2 of the License, or (at your option) any later version.
+    SPDX-License-Identifier: LGPL-2.0-or-later
 */
 
-#ifndef KIMG_PCX_H
-#define KIMG_PCX_H
+#ifndef KIMG_PCX_P_H
+#define KIMG_PCX_P_H
 
 #include <QImageIOPlugin>
 
@@ -17,9 +15,9 @@ class PCXHandler : public QImageIOHandler
 public:
     PCXHandler();
 
-    virtual bool canRead() const;
-    virtual bool read(QImage *image);
-    virtual bool write(const QImage &image);
+    bool canRead() const override;
+    bool read(QImage *image) override;
+    bool write(const QImage &image) override;
 
     static bool canRead(QIODevice *device);
 };
@@ -30,8 +28,8 @@ class PCXPlugin : public QImageIOPlugin
     Q_PLUGIN_METADATA(IID "org.qt-project.Qt.QImageIOHandlerFactoryInterface" FILE "pcx.json")
 
 public:
-    virtual Capabilities capabilities(QIODevice *device, const QByteArray &format) const;
-    virtual QImageIOHandler *create(QIODevice *device, const QByteArray &format = QByteArray()) const;
+    Capabilities capabilities(QIODevice *device, const QByteArray &format) const override;
+    QImageIOHandler *create(QIODevice *device, const QByteArray &format = QByteArray()) const override;
 };
 
-#endif // KIMG_PCX_H
+#endif // KIMG_PCX_P_H

src/imageformats/pic.cpp

@@ -1,24 +1,12 @@
 /*
- * Softimage PIC support for QImage
- * Copyright 1998 Halfdan Ingvarsson
- * Copyright 2007 Ruben Lopez <r.lopez@bren.es>
- * Copyright 2014 Alex Merry <alex.merry@kde.org>
- *
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2 of the License, or (at your option) any later version.
- *
- * This library 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
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library; if not, write to the Free Software
- * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
- * ----------------------------------------------------------------------------
- */
+    Softimage PIC support for QImage.
+
+    SPDX-FileCopyrightText: 1998 Halfdan Ingvarsson
+    SPDX-FileCopyrightText: 2007 Ruben Lopez <r.lopez@bren.es>
+    SPDX-FileCopyrightText: 2014 Alex Merry <alex.merry@kde.org>
+
+    SPDX-License-Identifier: LGPL-2.0-or-later
+*/
 
 /* This code is based on the GIMP-PIC plugin by Halfdan Ingvarsson,
  * and relicensed from GPL to LGPL to accommodate the KDE licensing policy
@@ -27,6 +15,8 @@
 
 #include "pic_p.h"
 
+#include "rle_p.h"
+
 #include <QDataStream>
 #include <QDebug>
 #include <QImage>
@@ -56,7 +46,10 @@ static QDataStream &operator>> (QDataStream &s, PicHeader &header)
     header.comment = QByteArray(comment);
 
     header.id.resize(4);
-    s.readRawData(header.id.data(), 4);
+    const int bytesRead = s.readRawData(header.id.data(), 4);
+    if (bytesRead != 4) {
+        header.id.resize(bytesRead);
+    }
 
     s >> header.width;
     s >> header.height;
@@ -124,9 +117,7 @@ static QDataStream &operator>> (QDataStream &s, QList<PicChannel> &channels)
         PicChannel channel;
         s >> chained;
         s >> channel.size;
-        quint8 encoding;
-        s >> encoding;
-        channel.encoding = PicChannelEncoding(encoding);
+        s >> channel.encoding;
         s >> channel.code;
         channels << channel;
         ++count;
@@ -167,85 +158,9 @@ static QDataStream &operator<< (QDataStream &s, const QList<PicChannel> &channel
     return s;
 }
 
-/**
- * Decodes data written in mixed run-length encoding format.
- *
- * This is intended to be used with lambda functions.
- *
- * Note that this functions expects that, at the current location in @p stream,
- * exactly @p length items have been encoded as a unit (and so it will not be
- * partway through a run when it has decoded @p length items). If this is not
- * the case, it will return @c false.
- *
- * @param stream      The stream to read the data from.
- * @param data        The location to write the data.
- * @param length      The number of items to read.
- * @param readItem    A function that takes a QDataStream reference and reads a
- *                    single item.
- * @param updateItem  A function that takes an item from @p data and an item
- *                    read by @p readItem and produces the item that should be
- *                    written to @p data.
- *
- * @returns @c true if @p length items in mixed RLE were successfully read
- *          into @p data, @c false otherwise.
- */
-template<typename Item, typename Func1, typename Func2>
-static bool decodeMixedRLEData(QDataStream &stream,
-                               Item *data,
-                               quint16 length,
-                               Func1 readItem,
-                               Func2 updateItem)
+static bool readRow(QDataStream &stream, QRgb *row, quint16 width, const QList<PicChannel> &channels)
 {
-    unsigned offset = 0; // in data
-    while (offset < length) {
-        unsigned remaining = length - offset;
-        quint8 count1;
-        stream >> count1;
-
-        if (count1 >= 128u) {
-            unsigned length;
-            if (count1 == 128u) {
-                // If the value is exactly 128, it means that it is more than
-                // 127 repetitions
-                quint16 count2;
-                stream >> count2;
-                length = count2;
-            } else {
-                // If last bit is 1, then it is 2 to 127 repetitions
-                length = count1 - 127u;
-            }
-            if (length > remaining) {
-                qDebug() << "Row overrun:" << length << ">" << remaining;
-                return false;
-            }
-            Item item = readItem(stream);
-            for (unsigned i = offset; i < offset + length; ++i) {
-                data[i] = updateItem(data[i], item);
-            }
-            offset += length;
-        } else {
-            // No repetitions
-            unsigned length = count1 + 1u;
-            if (length > remaining) {
-                qDebug() << "Row overrun:" << length << ">" << remaining;
-                return false;
-            }
-            for (unsigned i = offset; i < offset + length; ++i) {
-                Item item = readItem(stream);
-                data[i] = updateItem(data[i], item);
-            }
-            offset += length;
-        }
-    }
-    if (stream.status() != QDataStream::Ok) {
-        qDebug() << "DataStream status was" << stream.status();;;;
-    }
-    return stream.status() == QDataStream::Ok;
-}
-
-static bool readRow(QDataStream &stream, QRgb *row, quint16 width, QList<PicChannel> channels)
-{
-    Q_FOREACH(const PicChannel &channel, channels) {
+    for(const PicChannel &channel : channels) {
         auto readPixel = [&] (QDataStream &str) -> QRgb {
             quint8 red = 0;
             if (channel.code & RED) {
@@ -273,8 +188,10 @@ static bool readRow(QDataStream &stream, QRgb *row, quint16 width, QList<PicChan
                 qAlpha((channel.code & ALPHA) ? newPixel : oldPixel));
         };
         if (channel.encoding == MixedRLE) {
-            if (!decodeMixedRLEData(stream, row, width, readPixel, updatePixel)) {
-                qDebug() << "decodeMixedRLEData failed";
+            bool success = decodeRLEData(RLEVariant::PIC, stream, row, width,
+                                         readPixel, updatePixel);
+            if (!success) {
+                qDebug() << "decodeRLEData failed";
                 return false;
             }
         } else if (channel.encoding == Uncompressed) {
@@ -294,67 +211,6 @@ static bool readRow(QDataStream &stream, QRgb *row, quint16 width, QList<PicChan
     return stream.status() == QDataStream::Ok;
 }
 
-/**
- * Encodes data in mixed run-length encoding format.
- *
- * This is intended to be used with lambda functions.
- *
- * @param stream      The stream to write the data to.
- * @param data        The data to be written.
- * @param length      The number of items to write.
- * @param itemsEqual  A function that takes two items and returns whether
- *                    @p writeItem would write them identically.
- * @param writeItem   A function that takes a QDataStream reference and an item
- *                    and writes the item to the data stream.
- */
-template<typename Item, typename Func1, typename Func2>
-static void encodeMixedRLEData(QDataStream &stream, const Item *data, unsigned length, Func1 itemsEqual, Func2 writeItem)
-{
-    unsigned offset = 0;
-    while (offset < length) {
-        const Item *chunkStart = data + offset;
-        unsigned maxChunk = qMin(length - offset, 65535u);
-
-        const Item *chunkEnd = chunkStart + 1;
-        quint16 chunkLength = 1;
-        while (chunkLength < maxChunk && itemsEqual(*chunkStart, *chunkEnd)) {
-            ++chunkEnd;
-            ++chunkLength;
-        }
-
-        if (chunkLength > 127) {
-            // Sequence of > 127 identical pixels
-            stream << quint8(128);
-            stream << quint16(chunkLength);
-            writeItem(stream, *chunkStart);
-        } else if (chunkLength > 1) {
-            // Sequence of < 128 identical pixels
-            stream << quint8(chunkLength + 127);
-            writeItem(stream, *chunkStart);
-        } else {
-            // find a string of up to 128 values, each different from the one
-            // that follows it
-            if (maxChunk > 128) {
-                maxChunk = 128;
-            }
-            chunkLength = 1;
-            chunkEnd = chunkStart + 1;
-            while (chunkLength < maxChunk &&
-                    (chunkLength + 1u == maxChunk ||
-                     !itemsEqual(*chunkEnd, *(chunkEnd+1))))
-            {
-                ++chunkEnd;
-                ++chunkLength;
-            }
-            stream << quint8(chunkLength - 1);
-            for (unsigned i = 0; i < chunkLength; ++i) {
-                writeItem(stream, *(chunkStart + i));
-            }
-        }
-        offset += chunkLength;
-    }
-}
-
 bool SoftimagePICHandler::canRead() const
 {
     if (!SoftimagePICHandler::canRead(device())) {
@@ -371,7 +227,7 @@ bool SoftimagePICHandler::read(QImage *image)
     }
 
     QImage::Format fmt = QImage::Format_RGB32;
-    Q_FOREACH(const PicChannel &channel, m_channels) {
+    for (const PicChannel &channel : qAsConst(m_channels)) {
         if (channel.size != 8) {
             // we cannot read images that do not come in bytes
             qDebug() << "Channel size was" << channel.size;
@@ -384,6 +240,11 @@ bool SoftimagePICHandler::read(QImage *image)
     }
 
     QImage img(m_header.width, m_header.height, fmt);
+    if (img.isNull()) {
+        qDebug() << "Failed to allocate image, invalid dimensions?" << QSize(m_header.width, m_header.height) << fmt;
+        return false;
+    }
+
     img.fill(qRgb(0,0,0));
 
     for (int y = 0; y < m_header.height; y++) {
@@ -445,7 +306,8 @@ bool SoftimagePICHandler::write(const QImage &_image)
                 << quint8(qBlue(pixel));
         };
         if (m_compression) {
-            encodeMixedRLEData(stream, row, image.width(), rgbEqual, writeRgb);
+            encodeRLEData(RLEVariant::PIC, stream, row, image.width(),
+                          rgbEqual, writeRgb);
         } else {
             for (int i = 0; i < image.width(); ++i) {
                 writeRgb(stream, row[i]);
@@ -461,7 +323,8 @@ bool SoftimagePICHandler::write(const QImage &_image)
                 str << quint8(qAlpha(pixel));
             };
             if (m_compression) {
-                encodeMixedRLEData(stream, row, image.width(), alphaEqual, writeAlpha);
+                encodeRLEData(RLEVariant::PIC, stream, row, image.width(),
+                              alphaEqual, writeAlpha);
             } else {
                 for (int i = 0; i < image.width(); ++i) {
                     writeAlpha(stream, row[i]);
@@ -491,6 +354,7 @@ bool SoftimagePICHandler::readHeader()
             m_state = ReadHeader;
         }
     }
+
     return m_state != Error;
 }
 
@@ -515,8 +379,8 @@ void SoftimagePICHandler::setOption(ImageOption option, const QVariant &value)
             break;
         case Description: {
             m_description.clear();
-            QStringList entries = value.toString().split(QStringLiteral("\n\n"));
-            Q_FOREACH(const QString entry, entries) {
+            const QStringList entries = value.toString().split(QStringLiteral("\n\n"));
+            for (const QString &entry : entries) {
                 if (entry.startsWith(QStringLiteral("Description: "))) {
                     m_description = entry.mid(13).simplified().toUtf8();
                 }
@@ -552,7 +416,7 @@ QVariant SoftimagePICHandler::option(ImageOption option) const
             return QString();
         case ImageFormat:
             if (const_cast<SoftimagePICHandler*>(this)->readChannels()) {
-                Q_FOREACH (const PicChannel &channel, m_channels) {
+                for (const PicChannel &channel : qAsConst(m_channels)) {
                     if (channel.code & ALPHA) {
                         return QImage::Format_ARGB32;
                     }
@@ -579,10 +443,10 @@ QImageIOPlugin::Capabilities SoftimagePICPlugin::capabilities(QIODevice *device,
         return Capabilities(CanRead | CanWrite);
     }
     if (!format.isEmpty()) {
-        return 0;
+        return {};
     }
     if (!device->isOpen()) {
-        return 0;
+        return {};
     }
 
     Capabilities cap;

src/imageformats/pic_p.h

@@ -1,27 +1,15 @@
 /*
- * PIC_RW - Qt PIC Support
- * Copyright (C) 2007 Ruben Lopez <r.lopez@bren.es>
- *
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2 of the License, or (at your option) any later version.
- *
- * This library 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
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library; if not, write to the Free Software
- * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
- * ----------------------------------------------------------------------------
- */
+    PIC_RW - Qt PIC Support
+    SPDX-FileCopyrightText: 2007 Ruben Lopez <r.lopez@bren.es>
 
-#ifndef KIMG_PIC_H
-#define KIMG_PIC_H
+    SPDX-License-Identifier: LGPL-2.0-or-later
+*/
+
+#ifndef KIMG_PIC_P_H
+#define KIMG_PIC_P_H
 
 #include <QImageIOPlugin>
+#include <QDataStream>
 
 /**
  * The magic number at the start of a SoftImage PIC file.
@@ -118,7 +106,7 @@ struct PicHeader {
  */
 struct PicChannel {
     quint8 size; /**< Bits per component per pixel. */
-    PicChannelEncoding encoding; /**< How the channel's data is encoded. */
+    quint8 encoding; /**< How the channel's data is encoded. */
     quint8 code; /**< Flag field to describe which components are encoded in
                       this channel. */
 
@@ -153,13 +141,13 @@ struct PicChannel {
 class SoftimagePICHandler : public QImageIOHandler
 {
 public:
-    bool canRead() const Q_DECL_OVERRIDE;
-    bool read(QImage *image) Q_DECL_OVERRIDE;
-    bool write(const QImage &) Q_DECL_OVERRIDE;
+    bool canRead() const override;
+    bool read(QImage *image) override;
+    bool write(const QImage &) override;
 
-    QVariant option(ImageOption option) const Q_DECL_OVERRIDE;
-    void setOption(ImageOption option, const QVariant &value) Q_DECL_OVERRIDE;
-    bool supportsOption(ImageOption option) const Q_DECL_OVERRIDE;
+    QVariant option(ImageOption option) const override;
+    void setOption(ImageOption option, const QVariant &value) override;
+    bool supportsOption(ImageOption option) const override;
 
     static bool canRead(QIODevice *device);
 
@@ -194,8 +182,8 @@ class SoftimagePICPlugin : public QImageIOPlugin
     Q_PLUGIN_METADATA(IID "org.qt-project.Qt.QImageIOHandlerFactoryInterface" FILE "pic.json")
 
 public:
-    virtual Capabilities capabilities(QIODevice *device, const QByteArray &format) const;
-    virtual QImageIOHandler *create(QIODevice *device, const QByteArray &format = QByteArray()) const;
+    Capabilities capabilities(QIODevice *device, const QByteArray &format) const override;
+    QImageIOHandler *create(QIODevice *device, const QByteArray &format = QByteArray()) const override;
 };
 
-#endif // KIMG_PIC_H
+#endif // KIMG_PIC_P_H

src/imageformats/psd.cpp

@@ -1,27 +1,29 @@
-/* This file is part of the KDE project
-   Copyright (C) 2003 Ignacio Castaño <castano@ludicon.com>
+/*
+    Photoshop File Format support for QImage.
 
-   This program is free software; you can redistribute it and/or
-   modify it under the terms of the Lesser GNU General Public
-   License as published by the Free Software Foundation; either
-   version 2 of the License, or (at your option) any later version.
+    SPDX-FileCopyrightText: 2003 Ignacio Castaño <castano@ludicon.com>
+    SPDX-FileCopyrightText: 2015 Alex Merry <alex.merry@kde.org>
 
-   This code is based on Thacher Ulrich PSD loading code released
-   on public domain. See: http://tulrich.com/geekstuff/
+    SPDX-License-Identifier: LGPL-2.0-or-later
 */
 
-/* this code supports:
- * reading:
- *     rle and raw psd files
- * writing:
- *     not supported
+/*
+ * This code is based on Thacher Ulrich PSD loading code released
+ * into the public domain. See: http://tulrich.com/geekstuff/
+ */
+
+/*
+ * Documentation on this file format is available at
+ * http://www.adobe.com/devnet-apps/photoshop/fileformatashtml/
  */
 
 #include "psd_p.h"
 
+#include "rle_p.h"
+
+#include <QDataStream>
+#include <QDebug>
 #include <QImage>
-#include <QtCore/QDataStream>
-// #include <QDebug>
 
 typedef quint32 uint;
 typedef quint16 ushort;
@@ -66,20 +68,6 @@ static QDataStream &operator>> (QDataStream &s, PSDHeader &header)
     s >> header.color_mode;
     return s;
 }
-static bool seekBy(QDataStream &s, unsigned int bytes)
-{
-    char buf[4096];
-    while (bytes) {
-        unsigned int num = qMin(bytes, (unsigned int)sizeof(buf));
-        unsigned int l = num;
-        s.readRawData(buf, l);
-        if (l != num) {
-            return false;
-        }
-        bytes -= num;
-    }
-    return true;
-}
 
 // Check that the header is a valid PSD.
 static bool IsValid(const PSDHeader &header)
@@ -108,125 +96,121 @@ static bool IsSupported(const PSDHeader &header)
     return true;
 }
 
-// Load the PSD image.
-static bool LoadPSD(QDataStream &s, const PSDHeader &header, QImage &img)
+static void skip_section(QDataStream &s)
 {
-    // Create dst image.
-    img = QImage(header.width, header.height, QImage::Format_RGB32);
-
-    uint tmp;
-
+    quint32 section_length;
     // Skip mode data.
-    s >> tmp;
-    s.device()->seek(s.device()->pos() + tmp);
+    s >> section_length;
+    s.skipRawData(section_length);
+}
 
-    // Skip image resources.
-    s >> tmp;
-    s.device()->seek(s.device()->pos() + tmp);
+static quint8 readPixel(QDataStream &stream) {
+    quint8 pixel;
+    stream >> pixel;
+    return pixel;
+}
+static QRgb updateRed(QRgb oldPixel, quint8 redPixel) {
+    return qRgba(redPixel, qGreen(oldPixel), qBlue(oldPixel), qAlpha(oldPixel));
+}
+static QRgb updateGreen(QRgb oldPixel, quint8 greenPixel) {
+    return qRgba(qRed(oldPixel), greenPixel, qBlue(oldPixel), qAlpha(oldPixel));
+}
+static QRgb updateBlue(QRgb oldPixel, quint8 bluePixel) {
+    return qRgba(qRed(oldPixel), qGreen(oldPixel), bluePixel, qAlpha(oldPixel));
+}
+static QRgb updateAlpha(QRgb oldPixel, quint8 alphaPixel) {
+    return qRgba(qRed(oldPixel), qGreen(oldPixel), qBlue(oldPixel), alphaPixel);
+}
+typedef QRgb(*channelUpdater)(QRgb,quint8);
 
-    // Skip the reserved data.
-    s >> tmp;
-    s.device()->seek(s.device()->pos() + tmp);
+// Load the PSD image.
+static bool LoadPSD(QDataStream &stream, const PSDHeader &header, QImage &img)
+{
+    // Mode data
+    skip_section(stream);
+
+    // Image resources
+    skip_section(stream);
+
+    // Reserved data
+    skip_section(stream);
 
     // Find out if the data is compressed.
     // Known values:
     //   0: no compression
     //   1: RLE compressed
-    ushort compression;
-    s >> compression;
+    quint16 compression;
+    stream >> compression;
 
     if (compression > 1) {
-        // Unknown compression type.
+        qDebug() << "Unknown compression type";
         return false;
     }
 
-    uint channel_num = header.channel_count;
+    quint32 channel_num = header.channel_count;
 
+    QImage::Format fmt = QImage::Format_RGB32;
     // Clear the image.
-    if (channel_num < 4) {
-        img.fill(qRgba(0, 0, 0, 0xFF));
-    } else {
+    if (channel_num >= 4) {
         // Enable alpha.
-        img = img.convertToFormat(QImage::Format_ARGB32);
+        fmt = QImage::Format_ARGB32;
 
         // Ignore the other channels.
         channel_num = 4;
     }
+    img = QImage(header.width, header.height, fmt);
+    if (img.isNull()) {
+        qWarning() << "Failed to allocate image, invalid dimensions?" << QSize(header.width, header.height);
+        return false;
+    }
+    img.fill(qRgb(0,0,0));
 
-    const uint pixel_count = header.height * header.width;
+    const quint32 pixel_count = header.height * header.width;
 
-    static const uint components[4] = {2, 1, 0, 3}; // @@ Is this endian dependant?
+    // Verify this, as this is used to write into the memory of the QImage
+    if (pixel_count > img.sizeInBytes() / sizeof(QRgb)) {
+        qWarning() << "Invalid pixel count!" << pixel_count << "bytes available:" << img.sizeInBytes();
+        return false;
+    }
+
+    QRgb *image_data = reinterpret_cast<QRgb*>(img.bits());
+
+    if (!image_data) {
+        return false;
+    }
+
+    static const channelUpdater updaters[4] = {
+        updateRed,
+        updateGreen,
+        updateBlue,
+        updateAlpha
+    };
 
     if (compression) {
-
         // Skip row lengths.
-        if (!seekBy(s, header.height * header.channel_count * sizeof(ushort))) {
+        int skip_count = header.height * header.channel_count * sizeof(quint16);
+        if (stream.skipRawData(skip_count) != skip_count) {
             return false;
         }
 
-        // Read RLE data.
-        for (uint channel = 0; channel < channel_num; channel++) {
-
-            uchar *ptr = img.bits() + components[channel];
-
-            uint count = 0;
-            while (count < pixel_count) {
-                uchar c;
-                if (s.atEnd()) {
-                    return false;
-                }
-                s >> c;
-                uint len = c;
-
-                if (len < 128) {
-                    // Copy next len+1 bytes literally.
-                    len++;
-                    count += len;
-                    if (count > pixel_count) {
-                        return false;
-                    }
-
-                    while (len != 0) {
-                        s >> *ptr;
-                        ptr += 4;
-                        len--;
-                    }
-                } else if (len > 128) {
-                    // Next -len+1 bytes in the dest are replicated from next source byte.
-                    // (Interpret len as a negative 8-bit int.)
-                    len ^= 0xFF;
-                    len += 2;
-                    count += len;
-                    if (s.atEnd() || count > pixel_count) {
-                        return false;
-                    }
-                    uchar val;
-                    s >> val;
-                    while (len != 0) {
-                        *ptr = val;
-                        ptr += 4;
-                        len--;
-                    }
-                } else if (len == 128) {
-                    // No-op.
-                }
+        for (unsigned short channel = 0; channel < channel_num; channel++) {
+            bool success = decodeRLEData(RLEVariant::PackBits, stream,
+			                 image_data, pixel_count,
+					 &readPixel, updaters[channel]);
+            if (!success) {
+                qDebug() << "decodeRLEData on channel" << channel << "failed";
+                return false;
             }
         }
     } else {
-        // We're at the raw image data.  It's each channel in order (Red, Green, Blue, Alpha, ...)
-        // where each channel consists of an 8-bit value for each pixel in the image.
-
-        // Read the data by channel.
-        for (uint channel = 0; channel < channel_num; channel++) {
-
-            uchar *ptr = img.bits() + components[channel];
-
-            // Read the data.
-            uint count = pixel_count;
-            while (count != 0) {
-                s >> *ptr;
-                ptr += 4;
-                count--;
+        for (unsigned short channel = 0; channel < channel_num; channel++) {
+            for (unsigned i = 0; i < pixel_count; ++i) {
+                image_data[i] = updaters[channel](image_data[i], readPixel(stream));
+            }
+            // make sure we didn't try to read past the end of the stream
+            if (stream.status() != QDataStream::Ok) {
+                qDebug() << "DataStream status was" << stream.status();
+                return false;
             }
         }
     }
@@ -290,6 +274,11 @@ bool PSDHandler::canRead(QIODevice *device)
 
     char head[4];
     qint64 readBytes = device->read(head, sizeof(head));
+    if (readBytes < 0) {
+        qWarning() << "Read failed" << device->errorString();
+        return false;
+    }
+
     if (readBytes != sizeof(head)) {
         if (device->isSequential()) {
             while (readBytes > 0) {
@@ -318,10 +307,10 @@ QImageIOPlugin::Capabilities PSDPlugin::capabilities(QIODevice *device, const QB
         return Capabilities(CanRead);
     }
     if (!format.isEmpty()) {
-        return 0;
+        return {};
     }
     if (!device->isOpen()) {
-        return 0;
+        return {};
     }
 
     Capabilities cap;

src/imageformats/psd.desktop

@@ -2,6 +2,6 @@
 Type=Service
 X-KDE-ServiceTypes=QImageIOPlugins
 X-KDE-ImageFormat=psd
-X-KDE-MimeType=image/x-psd
+X-KDE-MimeType=image/vnd.adobe.photoshop
 X-KDE-Read=true
 X-KDE-Write=false

src/imageformats/psd.json

@@ -1,4 +1,4 @@
 {
     "Keys": [ "psd" ],
-    "MimeTypes": [ "image/x-psd" ]
+    "MimeTypes": [ "image/vnd.adobe.photoshop" ]
 }

src/imageformats/psd_p.h

@@ -1,14 +1,12 @@
-/* This file is part of the KDE project
-   Copyright (C) 2003 Ignacio Castaño <castano@ludicon.com>
+/*
+    This file is part of the KDE project
+    SPDX-FileCopyrightText: 2003 Ignacio Castaño <castano@ludicon.com>
 
-   This program is free software; you can redistribute it and/or
-   modify it under the terms of the Lesser GNU General Public
-   License as published by the Free Software Foundation; either
-   version 2 of the License, or (at your option) any later version.
+    SPDX-License-Identifier: LGPL-2.0-or-later
 */
 
-#ifndef KIMG_PSD_H
-#define KIMG_PSD_H
+#ifndef KIMG_PSD_P_H
+#define KIMG_PSD_P_H
 
 #include <QImageIOPlugin>
 
@@ -17,8 +15,8 @@ class PSDHandler : public QImageIOHandler
 public:
     PSDHandler();
 
-    virtual bool canRead() const;
-    virtual bool read(QImage *image);
+    bool canRead() const override;
+    bool read(QImage *image) override;
 
     static bool canRead(QIODevice *device);
 };
@@ -29,9 +27,9 @@ class PSDPlugin : public QImageIOPlugin
     Q_PLUGIN_METADATA(IID "org.qt-project.Qt.QImageIOHandlerFactoryInterface" FILE "psd.json")
 
 public:
-    virtual Capabilities capabilities(QIODevice *device, const QByteArray &format) const;
-    virtual QImageIOHandler *create(QIODevice *device, const QByteArray &format = QByteArray()) const;
+    Capabilities capabilities(QIODevice *device, const QByteArray &format) const override;
+    QImageIOHandler *create(QIODevice *device, const QByteArray &format = QByteArray()) const override;
 };
 
-#endif // KIMG_PSD_H
+#endif // KIMG_PSD_P_H
 

src/imageformats/ras.cpp

@@ -1,19 +1,17 @@
-/* This file is part of the KDE project
-   Copyright (C) 2003 Dominik Seichter <domseichter@web.de>
-   Copyright (C) 2004 Ignacio Castaño <castano@ludicon.com>
-   Copyright (C) 2010 Troy Unrau <troy@kde.org>
+/*
+    This file is part of the KDE project
+    SPDX-FileCopyrightText: 2003 Dominik Seichter <domseichter@web.de>
+    SPDX-FileCopyrightText: 2004 Ignacio Castaño <castano@ludicon.com>
+    SPDX-FileCopyrightText: 2010 Troy Unrau <troy@kde.org>
 
-   This program is free software; you can redistribute it and/or
-   modify it under the terms of the Lesser GNU General Public
-   License as published by the Free Software Foundation; either
-   version 2 of the License, or (at your option) any later version.
+    SPDX-License-Identifier: LGPL-2.0-or-later
 */
 
 #include "ras_p.h"
 
 #include <QImage>
-#include <QtCore/QDataStream>
-// #include <QDebug>
+#include <QDataStream>
+#include <QDebug>
 
 namespace   // Private.
 {
@@ -102,6 +100,13 @@ static bool IsSupported(const RasHeader &head)
 static bool LoadRAS(QDataStream &s, const RasHeader &ras, QImage &img)
 {
     s.device()->seek(RasHeader::SIZE);
+
+    // QVector uses some extra space for stuff, hence the 32 here suggested by thiago
+    if (ras.ColorMapLength > std::numeric_limits<int>::max() - 32) {
+        qWarning() << "LoadRAS() unsupported image color map length in file header" << ras.ColorMapLength;
+        return false;
+    }
+
     // Read palette if needed.
     QVector<quint8> palette(ras.ColorMapLength);
     if (ras.ColorMapType == 1) {
@@ -110,19 +115,36 @@ static bool LoadRAS(QDataStream &s, const RasHeader &ras, QImage &img)
         }
     }
 
+    const int bpp = ras.Depth / 8;
+    if (ras.Height == 0) {
+        return false;
+    }
+    if (bpp == 0) {
+        return false;
+    }
+    if (ras.Length / ras.Height / bpp < ras.Width) {
+        qWarning() << "LoadRAS() mistmatch between height and width" << ras.Width << ras.Height << ras.Length << ras.Depth;
+        return false;
+    }
+    // QVector uses some extra space for stuff, hence the 32 here suggested by thiago
+    if (ras.Length > std::numeric_limits<int>::max() - 32) {
+        qWarning() << "LoadRAS() unsupported image length in file header" << ras.Length;
+        return false;
+    }
+
     // each line must be a factor of 16 bits, so they may contain padding
     // this will be 1 if padding required, 0 otherwise
-    int paddingrequired = (ras.Width * (ras.Depth / 8) % 2);
+    const int paddingrequired = (ras.Width * bpp % 2);
 
     // qDebug() << "paddingrequired: " << paddingrequired;
     // don't trust ras.Length
     QVector<quint8> input(ras.Length);
 
     int i = 0;
-    while (! s.atEnd()) {
+    while (! s.atEnd() && i < input.size()) {
         s >> input[i];
         // I guess we need to find out if we're at the end of a line
-        if (paddingrequired && i != 0 && !(i % (ras.Width * (ras.Depth / 8)))) {
+        if (paddingrequired && i != 0 && !(i % (ras.Width * bpp))) {
             s >> input[i];
         }
         i++;
@@ -131,15 +153,18 @@ static bool LoadRAS(QDataStream &s, const RasHeader &ras, QImage &img)
     // Allocate image
     img = QImage(ras.Width, ras.Height, QImage::Format_ARGB32);
 
+    if (img.isNull())
+        return false;
+
     // Reconstruct image from RGB palette if we have a palette
     // TODO: make generic so it works with 24bit or 32bit palettes
     if (ras.ColorMapType == 1 && ras.Depth == 8) {
         quint8 red, green, blue;
         for (quint32 y = 0; y < ras.Height; y++) {
             for (quint32 x = 0; x < ras.Width; x++) {
-                red = palette[(int)input[y * ras.Width + x]];
-                green = palette[(int)input[y * ras.Width + x] + (ras.ColorMapLength / 3)];
-                blue = palette[(int)input[y * ras.Width + x] + 2 * (ras.ColorMapLength / 3)];
+                red = palette.value((int)input[y * ras.Width + x]);
+                green = palette.value((int)input[y * ras.Width + x] + (ras.ColorMapLength / 3));
+                blue = palette.value((int)input[y * ras.Width + x] + 2 * (ras.ColorMapLength / 3));
                 img.setPixel(x, y, qRgb(red, green, blue));
             }
         }
@@ -219,7 +244,7 @@ bool RASHandler::canRead(QIODevice *device)
     }
 
     if (device->isSequential()) {
-        qWarning("Reading ras files from sequential devices not supported");
+        // qWarning("Reading ras files from sequential devices not supported");
         return false;
     }
 
@@ -248,6 +273,10 @@ bool RASHandler::read(QImage *outImage)
     // Read image header.
     RasHeader ras;
     s >> ras;
+
+    if (ras.ColorMapLength > std::numeric_limits<int>::max())
+        return false;
+
     // TODO: add support for old versions of RAS where Length may be zero in header
     s.device()->seek(RasHeader::SIZE + ras.Length + ras.ColorMapLength);
 
@@ -282,10 +311,10 @@ QImageIOPlugin::Capabilities RASPlugin::capabilities(QIODevice *device, const QB
         return Capabilities(CanRead);
     }
     if (!format.isEmpty()) {
-        return 0;
+        return {};
     }
     if (!device->isOpen()) {
-        return 0;
+        return {};
     }
 
     Capabilities cap;

src/imageformats/ras_p.h

@@ -1,15 +1,13 @@
-/* This file is part of the KDE project
-   Copyright (C) 2003 Dominik Seichter <domseichter@web.de>
-   Copyright (C) 2010 Troy Unrau <troy@kde.org>
+/*
+    This file is part of the KDE project
+    SPDX-FileCopyrightText: 2003 Dominik Seichter <domseichter@web.de>
+    SPDX-FileCopyrightText: 2010 Troy Unrau <troy@kde.org>
 
-   This program is free software; you can redistribute it and/or
-   modify it under the terms of the Lesser GNU General Public
-   License as published by the Free Software Foundation; either
-   version 2 of the License, or (at your option) any later version.
+    SPDX-License-Identifier: LGPL-2.0-or-later
 */
 
-#ifndef KIMG_RAS_H
-#define KIMG_RAS_H
+#ifndef KIMG_RAS_P_H
+#define KIMG_RAS_P_H
 
 #include <QImageIOPlugin>
 
@@ -18,8 +16,8 @@ class RASHandler : public QImageIOHandler
 public:
     RASHandler();
 
-    virtual bool canRead() const;
-    virtual bool read(QImage *image);
+    bool canRead() const override;
+    bool read(QImage *image) override;
 
     static bool canRead(QIODevice *device);
 };
@@ -30,9 +28,8 @@ class RASPlugin : public QImageIOPlugin
     Q_PLUGIN_METADATA(IID "org.qt-project.Qt.QImageIOHandlerFactoryInterface" FILE "ras.json")
 
 public:
-    virtual Capabilities capabilities(QIODevice *device, const QByteArray &format) const;
-    virtual QImageIOHandler *create(QIODevice *device, const QByteArray &format = QByteArray()) const;
+    Capabilities capabilities(QIODevice *device, const QByteArray &format) const override;
+    QImageIOHandler *create(QIODevice *device, const QByteArray &format = QByteArray()) const override;
 };
 
-#endif // KIMG_RAS_H
-
+#endif // KIMG_RAS_P_H

src/imageformats/rgb.cpp

@@ -1,11 +1,9 @@
-// kimgio module for SGI images
-//
-// Copyright (C) 2004  Melchior FRANZ  <mfranz@kde.org>
-//
-// This program is free software; you can redistribute it and/or
-// modify it under the terms of the Lesser GNU General Public License as
-// published by the Free Software Foundation; either version 2 of the
-// License, or (at your option) any later version.
+/*
+    kimgio module for SGI images
+    SPDX-FileCopyrightText: 2004 Melchior FRANZ <mfranz@kde.org>
+
+    SPDX-License-Identifier: LGPL-2.0-or-later
+*/
 
 /* this code supports:
  * reading:
@@ -23,11 +21,11 @@
 
 #include "rgb_p.h"
 
-#include <QtCore/QMap>
-#include <QtCore/QVector>
+#include <QMap>
+#include <QVector>
 
 #include <QImage>
-// #include <QDebug>
+#include <QDebug>
 
 class RLEData : public QVector<uchar>
 {
@@ -111,8 +109,8 @@ private:
 };
 
 SGIImage::SGIImage(QIODevice *io) :
-    _starttab(0),
-    _lengthtab(0)
+    _starttab(nullptr),
+    _lengthtab(nullptr)
 {
     _dev = io;
     _stream.setDevice(_dev);
@@ -144,13 +142,16 @@ bool SGIImage::getRow(uchar *dest)
         if (_bpc == 2) {
             _pos++;
         }
+        if (_pos >= _data.end()) {
+            return false;
+        }
         n = *_pos & 0x7f;
         if (!n) {
             break;
         }
 
         if (*_pos++ & 0x80) {
-            for (; i < _xsize && n--; i++) {
+            for (; i < _xsize && _pos < _data.end() && n--; i++) {
                 *dest++ = *_pos;
                 _pos += _bpc;
             }
@@ -309,16 +310,27 @@ bool SGIImage::readImage(QImage &img)
         return false;
     }
 
-    _numrows = _ysize * _zsize;
-
     img = QImage(_xsize, _ysize, QImage::Format_RGB32);
+    if (img.isNull()) {
+        qWarning() << "Failed to allocate image, invalid dimensions?" << QSize(_xsize, _ysize);
+        return false;
+    }
+
+    if (_zsize == 0 )
+        return false;
 
     if (_zsize == 2 || _zsize == 4) {
         img = img.convertToFormat(QImage::Format_ARGB32);
     } else if (_zsize > 4) {
 //         qDebug() << "using first 4 of " << _zsize << " channels";
+        // Only let this continue if it won't cause a int overflow later
+        // this is most likely a broken file anyway
+        if (_ysize > std::numeric_limits<int>::max() / _zsize)
+            return false;
     }
 
+    _numrows = _ysize * _zsize;
+
     if (_rle) {
         uint l;
         _starttab = new quint32[_numrows];
@@ -326,6 +338,9 @@ bool SGIImage::readImage(QImage &img)
             _stream >> _starttab[l];
             _starttab[l] -= 512 + _numrows * 2 * sizeof(quint32);
         }
+        for (; l < _numrows; l++) {
+            _starttab[l] = 0;
+        }
 
         _lengthtab = new quint32[_numrows];
         for (l = 0; l < _numrows; l++) {
@@ -457,7 +472,14 @@ bool SGIImage::scanData(const QImage &img)
     uint len;
 
     for (y = 0; y < _ysize; y++) {
-        c = reinterpret_cast<const QRgb *>(img.scanLine(_ysize - y - 1));
+        const int yPos = _ysize - y - 1; // scanline doesn't do any sanity checking
+        if (yPos >= img.height()) {
+            qWarning() << "Failed to get scanline for" << yPos;
+            return false;
+        }
+
+        c = reinterpret_cast<const QRgb *>(img.scanLine(yPos));
+
         for (x = 0; x < _xsize; x++) {
             buf[x] = intensity(qRed(*c++));
         }
@@ -471,7 +493,13 @@ bool SGIImage::scanData(const QImage &img)
 
     if (_zsize != 2) {
         for (y = 0; y < _ysize; y++) {
-            c = reinterpret_cast<const QRgb *>(img.scanLine(_ysize - y - 1));
+            const int yPos = _ysize - y - 1;
+            if (yPos >= img.height()) {
+                qWarning() << "Failed to get scanline for" << yPos;
+                return false;
+            }
+
+            c = reinterpret_cast<const QRgb *>(img.scanLine(yPos));
             for (x = 0; x < _xsize; x++) {
                 buf[x] = intensity(qGreen(*c++));
             }
@@ -480,7 +508,13 @@ bool SGIImage::scanData(const QImage &img)
         }
 
         for (y = 0; y < _ysize; y++) {
-            c = reinterpret_cast<const QRgb *>(img.scanLine(_ysize - y - 1));
+            const int yPos = _ysize - y - 1;
+            if (yPos >= img.height()) {
+                qWarning() << "Failed to get scanline for" << yPos;
+                return false;
+            }
+
+            c = reinterpret_cast<const QRgb *>(img.scanLine(yPos));
             for (x = 0; x < _xsize; x++) {
                 buf[x] = intensity(qBlue(*c++));
             }
@@ -494,7 +528,13 @@ bool SGIImage::scanData(const QImage &img)
     }
 
     for (y = 0; y < _ysize; y++) {
-        c = reinterpret_cast<const QRgb *>(img.scanLine(_ysize - y - 1));
+        const int yPos = _ysize - y - 1;
+        if (yPos >= img.height()) {
+            qWarning() << "Failed to get scanline for" << yPos;
+            return false;
+        }
+
+        c = reinterpret_cast<const QRgb *>(img.scanLine(yPos));
         for (x = 0; x < _xsize; x++) {
             buf[x] = intensity(qAlpha(*c++));
         }
@@ -686,8 +726,8 @@ bool RGBHandler::canRead(QIODevice *device)
         return false;
     }
 
-    qint64 oldPos = device->pos();
-    QByteArray head = device->readLine(64);
+    const qint64 oldPos = device->pos();
+    const QByteArray head = device->readLine(64);
     int readBytes = head.size();
 
     if (device->isSequential()) {
@@ -699,10 +739,7 @@ bool RGBHandler::canRead(QIODevice *device)
         device->seek(oldPos);
     }
 
-    const QRegExp regexp(QLatin1String("^\x01\xda\x01[\x01\x02]"));
-    QString data(QString::fromLocal8Bit(head));
-
-    return data.contains(regexp);
+    return head.size() >= 4 && head.startsWith("\x01\xda") && (head[2] == 0 || head[2] == 1) && (head[3] == 1 || head[3] == 2);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
@@ -714,10 +751,10 @@ QImageIOPlugin::Capabilities RGBPlugin::capabilities(QIODevice *device, const QB
         return Capabilities(CanRead | CanWrite);
     }
     if (!format.isEmpty()) {
-        return 0;
+        return {};
     }
     if (!device->isOpen()) {
-        return 0;
+        return {};
     }
 
     Capabilities cap;

src/imageformats/rgb_p.h

@@ -1,14 +1,12 @@
-// kimgio module for SGI images
-//
-// Copyright (C) 2004  Melchior FRANZ  <mfranz@kde.org>
-//
-// This program is free software; you can redistribute it and/or
-// modify it under the terms of the Lesser GNU General Public License as
-// published by the Free Software Foundation; either version 2 of the
-// License, or (at your option) any later version.
+/*
+    kimgio module for SGI images
+    SPDX-FileCopyrightText: 2004 Melchior FRANZ <mfranz@kde.org>
 
-#ifndef KIMG_RGB_H
-#define KIMG_RGB_H
+    SPDX-License-Identifier: LGPL-2.0-or-later
+*/
+
+#ifndef KIMG_RGB_P_H
+#define KIMG_RGB_P_H
 
 #include <QImageIOPlugin>
 
@@ -17,9 +15,9 @@ class RGBHandler : public QImageIOHandler
 public:
     RGBHandler();
 
-    virtual bool canRead() const;
-    virtual bool read(QImage *image);
-    virtual bool write(const QImage &image);
+    bool canRead() const override;
+    bool read(QImage *image) override;
+    bool write(const QImage &image) override;
 
     static bool canRead(QIODevice *device);
 };
@@ -30,9 +28,9 @@ class RGBPlugin : public QImageIOPlugin
     Q_PLUGIN_METADATA(IID "org.qt-project.Qt.QImageIOHandlerFactoryInterface" FILE "rgb.json")
 
 public:
-    virtual Capabilities capabilities(QIODevice *device, const QByteArray &format) const;
-    virtual QImageIOHandler *create(QIODevice *device, const QByteArray &format = QByteArray()) const;
+    Capabilities capabilities(QIODevice *device, const QByteArray &format) const override;
+    QImageIOHandler *create(QIODevice *device, const QByteArray &format = QByteArray()) const override;
 };
 
-#endif // KIMG_RGB_H
+#endif // KIMG_RGB_P_H
 

src/imageformats/rle_p.h

@@ -0,0 +1,210 @@
+/*
+    Run-Length Encoding utilities.
+    SPDX-FileCopyrightText: 2014-2015 Alex Merry <alex.merry@kde.org>
+
+    SPDX-License-Identifier: LGPL-2.0-or-later
+*/
+
+#ifndef KIMAGEFORMATS_RLE_P_H
+#define KIMAGEFORMATS_RLE_P_H
+
+#include <QDebug>
+#include <QDataStream>
+
+/**
+ * The RLEVariant to use.
+ *
+ * This mostly concerns what to do values >= 128.
+ */
+enum class RLEVariant {
+    /**
+     * PackBits-style RLE
+     *
+     * Value 128 is ignored, 129 indicates a repetition
+     * of size 2, 130 of size 3, up to 255 of size 128.
+     */
+    PackBits,
+    /**
+     * PIC-style RLE
+     *
+     * Value 128 indicates a 16-bit repetition count
+     * follows, while 129 indicates a repetition
+     * of size 128, 130 of size 127, down to 255 of
+     * size 2.
+     */
+    PIC
+};
+
+/**
+ * Decodes data written in run-length encoding format.
+ *
+ * This is intended to be used with lambda functions.
+ *
+ * Note that this functions expects that, at the current location in @p stream,
+ * exactly @p length items have been encoded as a unit (and so it will not be
+ * partway through a run when it has decoded @p length items). If this is not
+ * the case, it will return @c false.
+ *
+ * @param variant     The RLE variant to decode.
+ * @param stream      The stream to read the data from.
+ * @param buf         The location to write the decoded data.
+ * @param length      The number of items to read.
+ * @param readData    A function that takes a QDataStream reference and reads a
+ *                    single value.
+ * @param updateItem  A function that takes an item from @p buf and the result
+ *                    of a readData call, and produces the item that should be
+ *                    written to @p buf.
+ *
+ * @returns @c true if @p length items in mixed RLE were successfully read
+ *          into @p buf, @c false otherwise.
+ */
+template<typename Item, typename Func1, typename Func2>
+static inline bool decodeRLEData(RLEVariant variant,
+                                 QDataStream &stream,
+                                 Item *dest,
+                                 quint32 length,
+                                 Func1 readData,
+                                 Func2 updateItem)
+{
+    unsigned offset = 0; // in dest
+    while (offset < length) {
+        unsigned remaining = length - offset;
+        quint8 count1;
+        stream >> count1;
+
+        if (count1 >= 128u) {
+            unsigned length = 0;
+            if (variant == RLEVariant::PIC) {
+                if (count1 == 128u) {
+                    // If the value is exactly 128, it means that it is more than
+                    // 127 repetitions
+                    quint16 count2;
+                    stream >> count2;
+                    length = count2;
+                } else {
+                    // 2 to 128 repetitions
+                    length = count1 - 127u;
+                }
+            } else if (variant == RLEVariant::PackBits) {
+                if (count1 == 128u) {
+                    // Ignore value 128
+                    continue;
+                } else {
+                    // 128 to 2 repetitions
+                    length = 257u - count1;
+                }
+            } else {
+                Q_ASSERT(false);
+            }
+            if (length > remaining) {
+                qDebug() << "Row overrun:" << length << ">" << remaining;
+                return false;
+            }
+            auto datum = readData(stream);
+            for (unsigned i = offset; i < offset + length; ++i) {
+                dest[i] = updateItem(dest[i], datum);
+            }
+            offset += length;
+        } else {
+            // No repetitions
+            unsigned length = count1 + 1u;
+            if (length > remaining) {
+                qDebug() << "Row overrun:" << length << ">" << remaining;
+                return false;
+            }
+            for (unsigned i = offset; i < offset + length; ++i) {
+                auto datum = readData(stream);
+                dest[i] = updateItem(dest[i], datum);
+            }
+            offset += length;
+        }
+    }
+    if (stream.status() != QDataStream::Ok) {
+        qDebug() << "DataStream status was" << stream.status();
+    }
+    return stream.status() == QDataStream::Ok;
+}
+
+
+/**
+ * Encodes data in run-length encoding format.
+ *
+ * This is intended to be used with lambda functions.
+ *
+ * @param variant     The RLE variant to encode in.
+ * @param stream      The stream to write the data to.
+ * @param data        The data to be written.
+ * @param length      The number of items to write.
+ * @param itemsEqual  A function that takes two items and returns whether
+ *                    @p writeItem would write them identically.
+ * @param writeItem   A function that takes a QDataStream reference and an item
+ *                    and writes the item to the data stream.
+ */
+template<typename Item, typename Func1, typename Func2>
+static inline void encodeRLEData(RLEVariant variant,
+                                 QDataStream &stream,
+		                 const Item *data,
+				 unsigned length,
+				 Func1 itemsEqual,
+				 Func2 writeItem)
+{
+    unsigned offset = 0;
+    const unsigned maxEncodableChunk =
+        (variant == RLEVariant::PIC)
+        ? 65535u
+        : 128;
+    while (offset < length) {
+        const Item *chunkStart = data + offset;
+        unsigned maxChunk = qMin(length - offset, maxEncodableChunk);
+
+        const Item *chunkEnd = chunkStart + 1;
+        quint16 chunkLength = 1;
+        while (chunkLength < maxChunk && itemsEqual(*chunkStart, *chunkEnd)) {
+            ++chunkEnd;
+            ++chunkLength;
+        }
+
+        if (chunkLength > 128) {
+            // Sequence of > 128 identical pixels
+            Q_ASSERT(variant == RLEVariant::PIC);
+            stream << quint8(128);
+            stream << quint16(chunkLength);
+            writeItem(stream, *chunkStart);
+        } else if (chunkLength > 1) {
+            // Sequence of <= 128 identical pixels
+            quint8 encodedLength;
+            if (variant == RLEVariant::PIC) {
+                encodedLength = quint8(chunkLength + 127);
+            } else if (variant == RLEVariant::PackBits) {
+                encodedLength = quint8(257 - chunkLength);
+            } else {
+                Q_ASSERT(false);
+                encodedLength = 0;
+            }
+            stream << encodedLength;
+            writeItem(stream, *chunkStart);
+        } else {
+            // find a string of up to 128 values, each different from the one
+            // that follows it
+            if (maxChunk > 128) {
+                maxChunk = 128;
+            }
+            chunkLength = 1;
+            chunkEnd = chunkStart + 1;
+            while (chunkLength < maxChunk &&
+                    (chunkLength + 1u == maxChunk ||
+                     !itemsEqual(*chunkEnd, *(chunkEnd+1))))
+            {
+                ++chunkEnd;
+                ++chunkLength;
+            }
+            stream << quint8(chunkLength - 1);
+            for (unsigned i = 0; i < chunkLength; ++i) {
+                writeItem(stream, *(chunkStart + i));
+            }
+        }
+        offset += chunkLength;
+    }
+}
+
+#endif // KIMAGEFORMATS_RLE_P_H

src/imageformats/tga.cpp

@@ -1,11 +1,9 @@
-/* This file is part of the KDE project
-   Copyright (C) 2003 Dominik Seichter <domseichter@web.de>
-   Copyright (C) 2004 Ignacio Castaño <castano@ludicon.com>
+/*
+    This file is part of the KDE project
+    SPDX-FileCopyrightText: 2003 Dominik Seichter <domseichter@web.de>
+    SPDX-FileCopyrightText: 2004 Ignacio Castaño <castano@ludicon.com>
 
-   This program is free software; you can redistribute it and/or
-   modify it under the terms of the Lesser GNU General Public
-   License as published by the Free Software Foundation; either
-   version 2 of the License, or (at your option) any later version.
+    SPDX-License-Identifier: LGPL-2.0-or-later
 */
 
 /* this code supports:
@@ -23,8 +21,8 @@
 #include <assert.h>
 
 #include <QImage>
-#include <QtCore/QDataStream>
-// #include <QDebug>
+#include <QDataStream>
+#include <QDebug>
 
 typedef quint32 uint;
 typedef quint16 ushort;
@@ -145,6 +143,7 @@ struct TgaHeaderInfo {
         switch (tga.image_type) {
         case TGA_TYPE_RLE_INDEXED:
             rle = true;
+        Q_FALLTHROUGH();
         // no break is intended!
         case TGA_TYPE_INDEXED:
             pal = true;
@@ -152,6 +151,7 @@ struct TgaHeaderInfo {
 
         case TGA_TYPE_RLE_RGB:
             rle = true;
+        Q_FALLTHROUGH();
         // no break is intended!
         case TGA_TYPE_RGB:
             rgb = true;
@@ -159,6 +159,7 @@ struct TgaHeaderInfo {
 
         case TGA_TYPE_RLE_GREY:
             rle = true;
+        Q_FALLTHROUGH();
         // no break is intended!
         case TGA_TYPE_GREY:
             grey = true;
@@ -175,6 +176,10 @@ static bool LoadTGA(QDataStream &s, const TgaHeader &tga, QImage &img)
 {
     // Create image.
     img = QImage(tga.width, tga.height, QImage::Format_RGB32);
+    if (img.isNull()) {
+        qWarning() << "Failed to allocate image, invalid dimensions?" << QSize(tga.width, tga.height);
+        return false;
+    }
 
     TgaHeaderInfo info(tga);
 
@@ -183,10 +188,18 @@ static bool LoadTGA(QDataStream &s, const TgaHeader &tga, QImage &img)
     // However alpha exists only in the 32 bit format.
     if ((tga.pixel_size == 32) && (tga.flags & 0xf)) {
         img = QImage(tga.width, tga.height, QImage::Format_ARGB32);
+        if (img.isNull()) {
+            qWarning() << "Failed to allocate image, invalid dimensions?" << QSize(tga.width, tga.height);
+            return false;
+        }
+
+        if (numAlphaBits > 8) {
+            return false;
+        }
     }
 
     uint pixel_size = (tga.pixel_size / 8);
-    uint size = tga.width * tga.height * pixel_size;
+    qint64 size = qint64(tga.width) * qint64(tga.height) * pixel_size;
 
     if (size < 1) {
 //          qDebug() << "This TGA file is broken with size " << size;
@@ -194,47 +207,110 @@ static bool LoadTGA(QDataStream &s, const TgaHeader &tga, QImage &img)
     }
 
     // Read palette.
-    char palette[768];
+    static const int max_palette_size = 768;
+    char palette[max_palette_size];
     if (info.pal) {
         // @todo Support palettes in other formats!
-        s.readRawData(palette, 3 * tga.colormap_length);
+        const int palette_size = 3 * tga.colormap_length;
+        if (palette_size > max_palette_size) {
+            return false;
+        }
+        const int dataRead = s.readRawData(palette, palette_size);
+        if (dataRead < 0) {
+            return false;
+        }
+        if (dataRead < max_palette_size) {
+            memset(&palette[dataRead], 0, max_palette_size - dataRead);
+        }
     }
 
     // Allocate image.
-    uchar *const image = new uchar[size];
+    uchar *const image = reinterpret_cast<uchar*>(malloc(size));
+    if (!image) {
+        return false;
+    }
+
+    bool valid = true;
 
     if (info.rle) {
         // Decode image.
         char *dst = (char *)image;
-        int num = size;
+        char *imgEnd = dst + size;
+        qint64 num = size;
+
+        while (num > 0 && valid) {
+            if (s.atEnd()) {
+                valid = false;
+                break;
+            }
 
-        while (num > 0) {
             // Get packet header.
             uchar c;
             s >> c;
 
             uint count = (c & 0x7f) + 1;
             num -= count * pixel_size;
+            if (num < 0) {
+                valid = false;
+                break;
+            }
 
             if (c & 0x80) {
                 // RLE pixels.
                 assert(pixel_size <= 8);
                 char pixel[8];
-                s.readRawData(pixel, pixel_size);
+                const int dataRead = s.readRawData(pixel, pixel_size);
+                if (dataRead < (int)pixel_size) {
+                    memset(&pixel[dataRead], 0, pixel_size - dataRead);
+                }
                 do {
+                    if (dst + pixel_size > imgEnd) {
+                        qWarning() << "Trying to write out of bounds!" << ptrdiff_t(dst) << (ptrdiff_t(imgEnd) - ptrdiff_t(pixel_size));
+                        valid = false;
+                        break;
+                    }
+
                     memcpy(dst, pixel, pixel_size);
                     dst += pixel_size;
                 } while (--count);
             } else {
                 // Raw pixels.
                 count *= pixel_size;
-                s.readRawData(dst, count);
+                const int dataRead = s.readRawData(dst, count);
+                if (dataRead < 0) {
+                    free(image);
+                    return false;
+                }
+
+
+                if ((uint)dataRead < count) {
+                    const size_t toCopy = count - dataRead;
+                    if (&dst[dataRead] + toCopy > imgEnd) {
+                        qWarning() << "Trying to write out of bounds!" << ptrdiff_t(image) << ptrdiff_t(&dst[dataRead]);;
+                        valid = false;
+                        break;
+                    }
+
+                    memset(&dst[dataRead], 0, toCopy);
+                }
                 dst += count;
             }
         }
     } else {
         // Read raw image.
-        s.readRawData((char *)image, size);
+        const int dataRead = s.readRawData((char *)image, size);
+        if (dataRead < 0) {
+            free(image);
+            return false;
+        }
+        if (dataRead < size) {
+            memset(&image[dataRead], 0, size - dataRead);
+        }
+    }
+
+    if (!valid) {
+        free(image);
+        return false;
     }
 
     // Convert image to internal format.
@@ -291,7 +367,7 @@ static bool LoadTGA(QDataStream &s, const TgaHeader &tga, QImage &img)
     }
 
     // Free image.
-    delete [] image;
+    free(image);
 
     return true;
 }
@@ -414,10 +490,10 @@ QImageIOPlugin::Capabilities TGAPlugin::capabilities(QIODevice *device, const QB
         return Capabilities(CanRead | CanWrite);
     }
     if (!format.isEmpty()) {
-        return 0;
+        return {};
     }
     if (!device->isOpen()) {
-        return 0;
+        return {};
     }
 
     Capabilities cap;

src/imageformats/tga_p.h

@@ -1,14 +1,12 @@
-/* This file is part of the KDE project
-   Copyright (C) 2003 Dominik Seichter <domseichter@web.de>
+/*
+    This file is part of the KDE project
+    SPDX-FileCopyrightText: 2003 Dominik Seichter <domseichter@web.de>
 
-   This program is free software; you can redistribute it and/or
-   modify it under the terms of the Lesser GNU General Public
-   License as published by the Free Software Foundation; either
-   version 2 of the License, or (at your option) any later version.
+    SPDX-License-Identifier: LGPL-2.0-or-later
 */
 
-#ifndef KIMG_TGA_H
-#define KIMG_TGA_H
+#ifndef KIMG_TGA_P_H
+#define KIMG_TGA_P_H
 
 #include <QImageIOPlugin>
 
@@ -17,9 +15,9 @@ class TGAHandler : public QImageIOHandler
 public:
     TGAHandler();
 
-    virtual bool canRead() const;
-    virtual bool read(QImage *image);
-    virtual bool write(const QImage &image);
+    bool canRead() const override;
+    bool read(QImage *image) override;
+    bool write(const QImage &image) override;
 
     static bool canRead(QIODevice *device);
 };
@@ -30,8 +28,8 @@ class TGAPlugin : public QImageIOPlugin
     Q_PLUGIN_METADATA(IID "org.qt-project.Qt.QImageIOHandlerFactoryInterface" FILE "tga.json")
 
 public:
-    virtual Capabilities capabilities(QIODevice *device, const QByteArray &format) const;
-    virtual QImageIOHandler *create(QIODevice *device, const QByteArray &format = QByteArray()) const;
+    Capabilities capabilities(QIODevice *device, const QByteArray &format) const override;
+    QImageIOHandler *create(QIODevice *device, const QByteArray &format = QByteArray()) const override;
 };
 
-#endif // KIMG_TGA_H
+#endif // KIMG_TGA_P_H

src/imageformats/xcf_p.h

@@ -1,26 +1,13 @@
 /*
- * xcf.cpp: A Qt 5 plug-in for reading GIMP XCF image files
- * Copyright (C) 2001 lignum Computing, Inc. <allen@lignumcomputing.com>
- * Copyright (C) 2004 Melchior FRANZ <mfranz@kde.org>
- *
- * This plug-in is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2.1 of the License, or (at your option) any later version.
- *
- * This library 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
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
- *
- */
+    xcf.cpp: A Qt 5 plug-in for reading GIMP XCF image files
+    SPDX-FileCopyrightText: 2001 lignum Computing Inc. <allen@lignumcomputing.com>
+    SPDX-FileCopyrightText: 2004 Melchior FRANZ <mfranz@kde.org>
 
-#ifndef KIMG_XCF_H
-#define KIMG_XCF_H
+    SPDX-License-Identifier: LGPL-2.1-or-later
+*/
+
+#ifndef KIMG_XCF_P_H
+#define KIMG_XCF_P_H
 
 #include <QImageIOPlugin>
 
@@ -29,9 +16,9 @@ class XCFHandler : public QImageIOHandler
 public:
     XCFHandler();
 
-    virtual bool canRead() const;
-    virtual bool read(QImage *image);
-    virtual bool write(const QImage &image);
+    bool canRead() const override;
+    bool read(QImage *image) override;
+    bool write(const QImage &image) override;
 
     static bool canRead(QIODevice *device);
 };
@@ -42,8 +29,8 @@ class XCFPlugin : public QImageIOPlugin
     Q_PLUGIN_METADATA(IID "org.qt-project.Qt.QImageIOHandlerFactoryInterface" FILE "xcf.json")
 
 public:
-    virtual Capabilities capabilities(QIODevice *device, const QByteArray &format) const;
-    virtual QImageIOHandler *create(QIODevice *device, const QByteArray &format = QByteArray()) const;
+    Capabilities capabilities(QIODevice *device, const QByteArray &format) const override;
+    QImageIOHandler *create(QIODevice *device, const QByteArray &format = QByteArray()) const override;
 };
 
-#endif // KIMG_XCF_H
+#endif // KIMG_XCF_P_H

tests/format-enum.h

@@ -1,23 +1,11 @@
 /*
- * Copyright 2014 Alex Merry <alex.merry@kde.org>
- *
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2.1 of the License, or (at your option) version 3, or any
- * later version accepted by the membership of KDE e.V. (or its
- * successor approved by the membership of KDE e.V.), which shall
- * act as a proxy defined in Section 6 of version 3 of the license.
- *
- * This library 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
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library.  If not, see
- * <http://www.gnu.org/licenses/>.
- */
+    SPDX-FileCopyrightText: 2014 Alex Merry <alex.merry@kde.org>
+
+    SPDX-License-Identifier: LGPL-2.1-only OR LGPL-3.0-only OR LicenseRef-KDE-Accepted-LGPL
+*/
+
+#ifndef FORMAT_ENUM_H
+#define FORMAT_ENUM_H
 
 #include <QImage>
 
@@ -71,3 +59,4 @@ QString formatToString(QImage::Format format)
         QLatin1String(">");
 }
 
+#endif

tests/imageconverter.cpp

@@ -1,23 +1,8 @@
 /*
- * Copyright 2013  Alex Merry <alex.merry@kdemail.net>
- *
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2.1 of the License, or (at your option) version 3, or any
- * later version accepted by the membership of KDE e.V. (or its
- * successor approved by the membership of KDE e.V.), which shall
- * act as a proxy defined in Section 6 of version 3 of the license.
- *
- * This library 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
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library.  If not, see
- * <http://www.gnu.org/licenses/>.
- */
+    SPDX-FileCopyrightText: 2013 Alex Merry <alex.merry@kdemail.net>
+
+    SPDX-License-Identifier: LGPL-2.1-only OR LGPL-3.0-only OR LicenseRef-KDE-Accepted-LGPL
+*/
 
 #include <stdio.h>
 
@@ -32,29 +17,29 @@
 int main(int argc, char **argv)
 {
     QCoreApplication app(argc, argv);
-    QCoreApplication::addLibraryPath(QLatin1String(PLUGIN_DIR));
-    QCoreApplication::setApplicationName(QLatin1String("imageconverter"));
-    QCoreApplication::setApplicationVersion(QLatin1String("1.01.01.0"));
+    QCoreApplication::addLibraryPath(QStringLiteral(PLUGIN_DIR));
+    QCoreApplication::setApplicationName(QStringLiteral("imageconverter"));
+    QCoreApplication::setApplicationVersion(QStringLiteral("1.01.01.0"));
 
     QCommandLineParser parser;
-    parser.setApplicationDescription(QLatin1String("Converts images from one format to another"));
+    parser.setApplicationDescription(QStringLiteral("Converts images from one format to another"));
     parser.addHelpOption();
     parser.addVersionOption();
-    parser.addPositionalArgument(QLatin1String("in"), QLatin1String("input image file"));
-    parser.addPositionalArgument(QLatin1String("out"), QLatin1String("output image file"));
+    parser.addPositionalArgument(QStringLiteral("in"), QStringLiteral("input image file"));
+    parser.addPositionalArgument(QStringLiteral("out"), QStringLiteral("output image file"));
     QCommandLineOption informat(
-        QStringList() << QLatin1String("i") << QLatin1String("informat"),
-        QLatin1String("Image format for input file"),
-        QLatin1String("format"));
+        QStringList() << QStringLiteral("i") << QStringLiteral("informat"),
+        QStringLiteral("Image format for input file"),
+        QStringLiteral("format"));
     parser.addOption(informat);
     QCommandLineOption outformat(
-        QStringList() << QLatin1String("o") << QLatin1String("outformat"),
-        QLatin1String("Image format for output file"),
-        QLatin1String("format"));
+        QStringList() << QStringLiteral("o") << QStringLiteral("outformat"),
+        QStringLiteral("Image format for output file"),
+        QStringLiteral("format"));
     parser.addOption(outformat);
     QCommandLineOption listformats(
-        QStringList() << QLatin1String("l") << QLatin1String("list"),
-        QLatin1String("List supported image formats"));
+        QStringList() << QStringLiteral("l") << QStringLiteral("list"),
+        QStringLiteral("List supported image formats"));
     parser.addOption(listformats);
 
     parser.process(app);
@@ -64,11 +49,13 @@ int main(int argc, char **argv)
     if (parser.isSet(listformats)) {
         QTextStream out(stdout);
         out << "Input formats:\n";
-        foreach (const QByteArray &fmt, QImageReader::supportedImageFormats()) {
+        const auto lstReaderSupportedFormats = QImageReader::supportedImageFormats();
+        for (const QByteArray &fmt : lstReaderSupportedFormats) {
             out << "  " << fmt << '\n';
         }
         out << "Output formats:\n";
-        foreach (const QByteArray &fmt, QImageWriter::supportedImageFormats()) {
+        const auto lstWriterSupportedFormats = QImageWriter::supportedImageFormats();
+        for (const QByteArray &fmt : lstWriterSupportedFormats) {
             out << "  " << fmt << '\n';
         }
         return 0;

tests/imagedump.cpp

@@ -1,23 +1,8 @@
 /*
- * Copyright 2013  Alex Merry <alex.merry@kdemail.net>
- *
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2.1 of the License, or (at your option) version 3, or any
- * later version accepted by the membership of KDE e.V. (or its
- * successor approved by the membership of KDE e.V.), which shall
- * act as a proxy defined in Section 6 of version 3 of the license.
- *
- * This library 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
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library.  If not, see
- * <http://www.gnu.org/licenses/>.
- */
+    SPDX-FileCopyrightText: 2013 Alex Merry <alex.merry@kdemail.net>
+
+    SPDX-License-Identifier: LGPL-2.1-only OR LGPL-3.0-only OR LicenseRef-KDE-Accepted-LGPL
+*/
 
 #include <stdio.h>
 
@@ -72,7 +57,8 @@ int main(int argc, char **argv)
     if (parser.isSet(listformats)) {
         QTextStream out(stdout);
         out << "File formats:\n";
-        foreach (const QByteArray &fmt, QImageReader::supportedImageFormats()) {
+        const auto lstSupportedFormats = QImageReader::supportedImageFormats();
+        for (const auto &fmt : lstSupportedFormats) {
             out << "  " << fmt << '\n';
         }
         return 0;
@@ -115,8 +101,8 @@ int main(int argc, char **argv)
         }
         img = img.convertToFormat(qformat);
     }
-    qint64 written = output.write(reinterpret_cast<const char *>(img.bits()), img.byteCount());
-    if (written != img.byteCount()) {
+    qint64 written = output.write(reinterpret_cast<const char *>(img.bits()), img.sizeInBytes());
+    if (written != img.sizeInBytes()) {
         QTextStream(stderr) << "Could not write image data to " << files.at(1)
                             << ":" << output.errorString() << "\n";
         return 5;