BUILDING.md

   1 Building libjpeg-turbo
   2 ======================
   3
   4
   5 Build Requirements
   6 ------------------
   7
   8
   9 ### All Systems
  10
  11 - [CMake](http://www.cmake.org) v2.8.12 or later
  12
  13 - [NASM](http://www.nasm.us) or [Yasm](http://yasm.tortall.net)
  14   (if building x86 or x86-64 SIMD extensions)
  15   * If using NASM, 2.13 or later is required.
  16   * If using Yasm, 1.2.0 or later is required.
  17   * If building on macOS, NASM or Yasm can be obtained from
  18     [MacPorts](http://www.macports.org/) or [Homebrew](http://brew.sh/).
  19      - NOTE: Currently, if it is desirable to hide the SIMD function symbols in
  20        Mac executables or shared libraries that statically link with
  21        libjpeg-turbo, then NASM 2.14 or later or Yasm must be used when
  22        building libjpeg-turbo.
  23   * If NASM or Yasm is not in your `PATH`, then you can specify the full path
  24     to the assembler by using either the `CMAKE_ASM_NASM_COMPILER` CMake
  25     variable or the `ASM_NASM` environment variable.  On Windows, use forward
  26     slashes rather than backslashes in the path (for example,
  27     **c:/nasm/nasm.exe**).
  28   * NASM and Yasm are located in the CRB (Code Ready Builder) repository on
  29     Red Hat Enterprise Linux 8 and in the PowerTools repository on RHEL
  30     derivatives, which is not enabled by default.
  31
  32 ### Un*x Platforms (including Linux, Mac, FreeBSD, Solaris, and Cygwin)
  33
  34 - GCC v4.1 (or later) or Clang recommended for best performance
  35
  36 - If building the TurboJPEG Java wrapper, JDK or OpenJDK 1.5 or later is
  37   required.  Most modern Linux distributions, as well as Solaris 10 and later,
  38   include JDK or OpenJDK.  For other systems, you can obtain the Oracle Java
  39   Development Kit from
  40   <http://www.oracle.com/technetwork/java/javase/downloads>.
  41
  42   * If using JDK 11 or later, CMake 3.10.x or later must also be used.
  43
  44 ### Windows
  45
  46 - Microsoft Visual C++ 2005 or later
  47
  48   If you don't already have Visual C++, then the easiest way to get it is by
  49   installing
  50   [Visual Studio Community Edition](https://visualstudio.microsoft.com),
  51   which includes everything necessary to build libjpeg-turbo.
  52
  53   * You can also download and install the standalone Windows SDK (for Windows 7
  54     or later), which includes command-line versions of the 32-bit and 64-bit
  55     Visual C++ compilers.
  56   * If you intend to build libjpeg-turbo from the command line, then add the
  57     appropriate compiler and SDK directories to the `INCLUDE`, `LIB`, and
  58     `PATH` environment variables.  This is generally accomplished by
  59     executing `vcvars32.bat` or `vcvars64.bat`, which are located in the same
  60     directory as the compiler.
  61   * If built with Visual C++ 2015 or later, the libjpeg-turbo static libraries
  62     cannot be used with earlier versions of Visual C++, and vice versa.
  63   * The libjpeg API DLL (**jpeg{version}.dll**) will depend on the C run-time
  64     DLLs corresponding to the version of Visual C++ that was used to build it.
  65
  66    ... OR ...
  67
  68 - MinGW
  69
  70   [MSYS2](http://msys2.github.io/) or [tdm-gcc](http://tdm-gcc.tdragon.net/)
  71   recommended if building on a Windows machine.  Both distributions install a
  72   Start Menu link that can be used to launch a command prompt with the
  73   appropriate compiler paths automatically set.
  74
  75 - If building the TurboJPEG Java wrapper, JDK 1.5 or later is required.  This
  76   can be downloaded from
  77   <http://www.oracle.com/technetwork/java/javase/downloads>.
  78
  79   * If using JDK 11 or later, CMake 3.10.x or later must also be used.
  80
  81
  82 Sub-Project Builds
  83 ------------------
  84
  85 The libjpeg-turbo build system does not support being included as a sub-project
  86 using the CMake `add_subdirectory()` function.  Use the CMake
  87 `ExternalProject_Add()` function instead.
  88
  89
  90 Out-of-Tree Builds
  91 ------------------
  92
  93 Binary objects, libraries, and executables are generated in the directory from
  94 which CMake is executed (the "binary directory"), and this directory need not
  95 necessarily be the same as the libjpeg-turbo source directory.  You can create
  96 multiple independent binary directories, in which different versions of
  97 libjpeg-turbo can be built from the same source tree using different compilers
  98 or settings.  In the sections below, *{build_directory}* refers to the binary
  99 directory, whereas *{source_directory}* refers to the libjpeg-turbo source
 100 directory.  For in-tree builds, these directories are the same.
 101
 102
 103 Ninja
 104 -----
 105
 106 If using Ninja, then replace `make` or `nmake` with `ninja`, and replace the
 107 CMake generator (specified with the `-G` option) with `Ninja`, in all of the
 108 procedures and recipes below.
 109
 110
 111 Build Procedure
 112 ---------------
 113
 114 NOTE: The build procedures below assume that CMake is invoked from the command
 115 line, but all of these procedures can be adapted to the CMake GUI as
 116 well.
 117
 118
 119 ### Un*x
 120
 121 The following procedure will build libjpeg-turbo on Unix and Unix-like systems.
 122 (On Solaris, this generates a 32-bit build.  See "Build Recipes" below for
 123 64-bit build instructions.)
 124
 125     cd {build_directory}
 126     cmake -G"Unix Makefiles" [additional CMake flags] {source_directory}
 127     make
 128
 129 This will generate the following files under *{build_directory}*:
 130
 131 **libjpeg.a**<br>
 132 Static link library for the libjpeg API
 133
 134 **libjpeg.so.{version}** (Linux, Unix)<br>
 135 **libjpeg.{version}.dylib** (Mac)<br>
 136 **cygjpeg-{version}.dll** (Cygwin)<br>
 137 Shared library for the libjpeg API
 138
 139 By default, *{version}* is 62.2.0, 7.2.0, or 8.1.2, depending on whether
 140 libjpeg v6b (default), v7, or v8 emulation is enabled.  If using Cygwin,
 141 *{version}* is 62, 7, or 8.
 142
 143 **libjpeg.so** (Linux, Unix)<br>
 144 **libjpeg.dylib** (Mac)<br>
 145 Development symlink for the libjpeg API
 146
 147 **libjpeg.dll.a** (Cygwin)<br>
 148 Import library for the libjpeg API
 149
 150 **libturbojpeg.a**<br>
 151 Static link library for the TurboJPEG API
 152
 153 **libturbojpeg.so.0.2.0** (Linux, Unix)<br>
 154 **libturbojpeg.0.2.0.dylib** (Mac)<br>
 155 **cygturbojpeg-0.dll** (Cygwin)<br>
 156 Shared library for the TurboJPEG API
 157
 158 **libturbojpeg.so** (Linux, Unix)<br>
 159 **libturbojpeg.dylib** (Mac)<br>
 160 Development symlink for the TurboJPEG API
 161
 162 **libturbojpeg.dll.a** (Cygwin)<br>
 163 Import library for the TurboJPEG API
 164
 165
 166 ### Visual C++ (Command Line)
 167
 168     cd {build_directory}
 169     cmake -G"NMake Makefiles" -DCMAKE_BUILD_TYPE=Release [additional CMake flags] {source_directory}
 170     nmake
 171
 172 This will build either a 32-bit or a 64-bit version of libjpeg-turbo, depending
 173 on which version of **cl.exe** is in the `PATH`.
 174
 175 The following files will be generated under *{build_directory}*:
 176
 177 **jpeg-static.lib**<br>
 178 Static link library for the libjpeg API
 179
 180 **jpeg{version}.dll**<br>
 181 DLL for the libjpeg API
 182
 183 **jpeg.lib**<br>
 184 Import library for the libjpeg API
 185
 186 **turbojpeg-static.lib**<br>
 187 Static link library for the TurboJPEG API
 188
 189 **turbojpeg.dll**<br>
 190 DLL for the TurboJPEG API
 191
 192 **turbojpeg.lib**<br>
 193 Import library for the TurboJPEG API
 194
 195 *{version}* is 62, 7, or 8, depending on whether libjpeg v6b (default), v7, or
 196 v8 emulation is enabled.
 197
 198
 199 ### Visual C++ (IDE)
 200
 201 Choose the appropriate CMake generator option for your version of Visual Studio
 202 (run `cmake` with no arguments for a list of available generators.)  For
 203 instance:
 204
 205     cd {build_directory}
 206     cmake -G"Visual Studio 10" [additional CMake flags] {source_directory}
 207
 208 NOTE: Add "Win64" to the generator name (for example, "Visual Studio 10 Win64")
 209 to build a 64-bit version of libjpeg-turbo.  A separate build directory must be
 210 used for 32-bit and 64-bit builds.
 211
 212 You can then open **ALL_BUILD.vcproj** in Visual Studio and build one of the
 213 configurations in that project ("Debug", "Release", etc.) to generate a full
 214 build of libjpeg-turbo.
 215
 216 This will generate the following files under *{build_directory}*:
 217
 218 **{configuration}/jpeg-static.lib**<br>
 219 Static link library for the libjpeg API
 220
 221 **{configuration}/jpeg{version}.dll**<br>
 222 DLL for the libjpeg API
 223
 224 **{configuration}/jpeg.lib**<br>
 225 Import library for the libjpeg API
 226
 227 **{configuration}/turbojpeg-static.lib**<br>
 228 Static link library for the TurboJPEG API
 229
 230 **{configuration}/turbojpeg.dll**<br>
 231 DLL for the TurboJPEG API
 232
 233 **{configuration}/turbojpeg.lib**<br>
 234 Import library for the TurboJPEG API
 235
 236 *{configuration}* is Debug, Release, RelWithDebInfo, or MinSizeRel, depending
 237 on the configuration you built in the IDE, and *{version}* is 62, 7, or 8,
 238 depending on whether libjpeg v6b (default), v7, or v8 emulation is enabled.
 239
 240
 241 ### MinGW
 242
 243 NOTE: This assumes that you are building on a Windows machine using the MSYS
 244 environment.  If you are cross-compiling on a Un*x platform (including Mac and
 245 Cygwin), then see "Build Recipes" below.
 246
 247     cd {build_directory}
 248     cmake -G"MSYS Makefiles" [additional CMake flags] {source_directory}
 249     make
 250
 251 This will generate the following files under *{build_directory}*:
 252
 253 **libjpeg.a**<br>
 254 Static link library for the libjpeg API
 255
 256 **libjpeg-{version}.dll**<br>
 257 DLL for the libjpeg API
 258
 259 **libjpeg.dll.a**<br>
 260 Import library for the libjpeg API
 261
 262 **libturbojpeg.a**<br>
 263 Static link library for the TurboJPEG API
 264
 265 **libturbojpeg.dll**<br>
 266 DLL for the TurboJPEG API
 267
 268 **libturbojpeg.dll.a**<br>
 269 Import library for the TurboJPEG API
 270
 271 *{version}* is 62, 7, or 8, depending on whether libjpeg v6b (default), v7, or
 272 v8 emulation is enabled.
 273
 274
 275 ### Debug Build
 276
 277 Add `-DCMAKE_BUILD_TYPE=Debug` to the CMake command line.  Or, if building
 278 with NMake, remove `-DCMAKE_BUILD_TYPE=Release` (Debug builds are the default
 279 with NMake.)
 280
 281
 282 ### libjpeg v7 or v8 API/ABI Emulation
 283
 284 Add `-DWITH_JPEG7=1` to the CMake command line to build a version of
 285 libjpeg-turbo that is API/ABI-compatible with libjpeg v7.  Add `-DWITH_JPEG8=1`
 286 to the CMake command line to build a version of libjpeg-turbo that is
 287 API/ABI-compatible with libjpeg v8.  See [README.md](README.md) for more
 288 information about libjpeg v7 and v8 emulation.
 289
 290
 291 ### In-Memory Source/Destination Managers
 292
 293 When using libjpeg v6b or v7 API/ABI emulation, add `-DWITH_MEM_SRCDST=0` to
 294 the CMake command line to build a version of libjpeg-turbo that lacks the
 295 `jpeg_mem_src()` and `jpeg_mem_dest()` functions.  These functions were not
 296 part of the original libjpeg v6b and v7 APIs, so removing them ensures strict
 297 conformance with those APIs.  See [README.md](README.md) for more information.
 298
 299
 300 ### Arithmetic Coding Support
 301
 302 Since the patent on arithmetic coding has expired, this functionality has been
 303 included in this release of libjpeg-turbo.  libjpeg-turbo's implementation is
 304 based on the implementation in libjpeg v8, but it works when emulating libjpeg
 305 v7 or v6b as well.  The default is to enable both arithmetic encoding and
 306 decoding, but those who have philosophical objections to arithmetic coding can
 307 add `-DWITH_ARITH_ENC=0` or `-DWITH_ARITH_DEC=0` to the CMake command line to
 308 disable encoding or decoding (respectively.)
 309
 310
 311 ### TurboJPEG Java Wrapper
 312
 313 Add `-DWITH_JAVA=1` to the CMake command line to incorporate an optional Java
 314 Native Interface (JNI) wrapper into the TurboJPEG shared library and build the
 315 Java front-end classes to support it.  This allows the TurboJPEG shared library
 316 to be used directly from Java applications.  See [java/README](java/README) for
 317 more details.
 318
 319 If Java is not in your `PATH`, or if you wish to use an alternate JDK to
 320 build/test libjpeg-turbo, then (prior to running CMake) set the `JAVA_HOME`
 321 environment variable to the location of the JDK that you wish to use.  The
 322 `Java_JAVAC_EXECUTABLE`, `Java_JAVA_EXECUTABLE`, and `Java_JAR_EXECUTABLE`
 323 CMake variables can also be used to specify alternate commands or locations for
 324 javac, jar, and java (respectively.)  You can also set the
 325 `CMAKE_JAVA_COMPILE_FLAGS` CMake variable or the `JAVAFLAGS` environment
 326 variable to specify arguments that should be passed to the Java compiler when
 327 building the TurboJPEG classes, and the `JAVAARGS` CMake variable to specify
 328 arguments that should be passed to the JRE when running the TurboJPEG Java unit
 329 tests.
 330
 331
 332 Build Recipes
 333 -------------
 334
 335
 336 ### 32-bit Build on 64-bit Linux/Unix
 337
 338 Use export/setenv to set the following environment variables before running
 339 CMake:
 340
 341     CFLAGS=-m32
 342     LDFLAGS=-m32
 343
 344
 345 ### 64-bit Build on Solaris
 346
 347 Use export/setenv to set the following environment variables before running
 348 CMake:
 349
 350     CFLAGS=-m64
 351     LDFLAGS=-m64
 352
 353
 354 ### Other Compilers
 355
 356 On Un*x systems, prior to running CMake, you can set the `CC` environment
 357 variable to the command used to invoke the C compiler.
 358
 359
 360 ### 32-bit MinGW Build on Un*x (including Mac and Cygwin)
 361
 362 Create a file called **toolchain.cmake** under *{build_directory}*, with the
 363 following contents:
 364
 365     set(CMAKE_SYSTEM_NAME Windows)
 366     set(CMAKE_SYSTEM_PROCESSOR X86)
 367     set(CMAKE_C_COMPILER {mingw_binary_path}/i686-w64-mingw32-gcc)
 368     set(CMAKE_RC_COMPILER {mingw_binary_path}/i686-w64-mingw32-windres)
 369
 370 *{mingw\_binary\_path}* is the directory under which the MinGW binaries are
 371 located (usually **/usr/bin**.)  Next, execute the following commands:
 372
 373     cd {build_directory}
 374     cmake -G"Unix Makefiles" -DCMAKE_TOOLCHAIN_FILE=toolchain.cmake \
 375       [additional CMake flags] {source_directory}
 376     make
 377
 378
 379 ### 64-bit MinGW Build on Un*x (including Mac and Cygwin)
 380
 381 Create a file called **toolchain.cmake** under *{build_directory}*, with the
 382 following contents:
 383
 384     set(CMAKE_SYSTEM_NAME Windows)
 385     set(CMAKE_SYSTEM_PROCESSOR AMD64)
 386     set(CMAKE_C_COMPILER {mingw_binary_path}/x86_64-w64-mingw32-gcc)
 387     set(CMAKE_RC_COMPILER {mingw_binary_path}/x86_64-w64-mingw32-windres)
 388
 389 *{mingw\_binary\_path}* is the directory under which the MinGW binaries are
 390 located (usually **/usr/bin**.)  Next, execute the following commands:
 391
 392     cd {build_directory}
 393     cmake -G"Unix Makefiles" -DCMAKE_TOOLCHAIN_FILE=toolchain.cmake \
 394       [additional CMake flags] {source_directory}
 395     make
 396
 397
 398 Building libjpeg-turbo for iOS
 399 ------------------------------
 400
 401 iOS platforms, such as the iPhone and iPad, use Arm processors, and all
 402 currently supported models include Neon instructions.  Thus, they can take
 403 advantage of libjpeg-turbo's SIMD extensions to significantly accelerate JPEG
 404 compression/decompression.  This section describes how to build libjpeg-turbo
 405 for these platforms.
 406
 407
 408 ### Armv8 (64-bit)
 409
 410 **Xcode 5 or later required, Xcode 6.3.x or later recommended**
 411
 412 The following script demonstrates how to build libjpeg-turbo to run on the
 413 iPhone 5S/iPad Mini 2/iPad Air and newer.
 414
 415     IOS_PLATFORMDIR=/Applications/Xcode.app/Contents/Developer/Platforms/iPhoneOS.platform
 416     IOS_SYSROOT=($IOS_PLATFORMDIR/Developer/SDKs/iPhoneOS*.sdk)
 417     export CFLAGS="-Wall -arch arm64 -miphoneos-version-min=8.0 -funwind-tables"
 418
 419     cd {build_directory}
 420
 421     cat <<EOF >toolchain.cmake
 422     set(CMAKE_SYSTEM_NAME Darwin)
 423     set(CMAKE_SYSTEM_PROCESSOR aarch64)
 424     set(CMAKE_C_COMPILER /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin/clang)
 425     EOF
 426
 427     cmake -G"Unix Makefiles" -DCMAKE_TOOLCHAIN_FILE=toolchain.cmake \
 428       -DCMAKE_OSX_SYSROOT=${IOS_SYSROOT[0]} \
 429       [additional CMake flags] {source_directory}
 430     make
 431
 432
 433 Building libjpeg-turbo for Android
 434 ----------------------------------
 435
 436 Building libjpeg-turbo for Android platforms requires v13b or later of the
 437 [Android NDK](https://developer.android.com/tools/sdk/ndk).
 438
 439
 440 ### Armv7 (32-bit)
 441
 442 **NDK r19 or later with Clang recommended**
 443
 444 The following is a general recipe script that can be modified for your specific
 445 needs.
 446
 447     # Set these variables to suit your needs
 448     NDK_PATH={full path to the NDK directory-- for example,
 449       /opt/android/android-ndk-r16b}
 450     TOOLCHAIN={"gcc" or "clang"-- "gcc" must be used with NDK r16b and earlier,
 451       and "clang" must be used with NDK r17c and later}
 452     ANDROID_VERSION={the minimum version of Android to support-- for example,
 453       "16", "19", etc.}
 454
 455     cd {build_directory}
 456     cmake -G"Unix Makefiles" \
 457       -DANDROID_ABI=armeabi-v7a \
 458       -DANDROID_ARM_MODE=arm \
 459       -DANDROID_PLATFORM=android-${ANDROID_VERSION} \
 460       -DANDROID_TOOLCHAIN=${TOOLCHAIN} \
 461       -DCMAKE_ASM_FLAGS="--target=arm-linux-androideabi${ANDROID_VERSION}" \
 462       -DCMAKE_TOOLCHAIN_FILE=${NDK_PATH}/build/cmake/android.toolchain.cmake \
 463       [additional CMake flags] {source_directory}
 464     make
 465
 466
 467 ### Armv8 (64-bit)
 468
 469 **Clang recommended**
 470
 471 The following is a general recipe script that can be modified for your specific
 472 needs.
 473
 474     # Set these variables to suit your needs
 475     NDK_PATH={full path to the NDK directory-- for example,
 476       /opt/android/android-ndk-r16b}
 477     TOOLCHAIN={"gcc" or "clang"-- "gcc" must be used with NDK r14b and earlier,
 478       and "clang" must be used with NDK r17c and later}
 479     ANDROID_VERSION={the minimum version of Android to support.  "21" or later
 480       is required for a 64-bit build.}
 481
 482     cd {build_directory}
 483     cmake -G"Unix Makefiles" \
 484       -DANDROID_ABI=arm64-v8a \
 485       -DANDROID_ARM_MODE=arm \
 486       -DANDROID_PLATFORM=android-${ANDROID_VERSION} \
 487       -DANDROID_TOOLCHAIN=${TOOLCHAIN} \
 488       -DCMAKE_ASM_FLAGS="--target=aarch64-linux-android${ANDROID_VERSION}" \
 489       -DCMAKE_TOOLCHAIN_FILE=${NDK_PATH}/build/cmake/android.toolchain.cmake \
 490       [additional CMake flags] {source_directory}
 491     make
 492
 493
 494 ### x86 (32-bit)
 495
 496 The following is a general recipe script that can be modified for your specific
 497 needs.
 498
 499     # Set these variables to suit your needs
 500     NDK_PATH={full path to the NDK directory-- for example,
 501       /opt/android/android-ndk-r16b}
 502     TOOLCHAIN={"gcc" or "clang"-- "gcc" must be used with NDK r14b and earlier,
 503       and "clang" must be used with NDK r17c and later}
 504     ANDROID_VERSION={The minimum version of Android to support-- for example,
 505       "16", "19", etc.}
 506
 507     cd {build_directory}
 508     cmake -G"Unix Makefiles" \
 509       -DANDROID_ABI=x86 \
 510       -DANDROID_PLATFORM=android-${ANDROID_VERSION} \
 511       -DANDROID_TOOLCHAIN=${TOOLCHAIN} \
 512       -DCMAKE_TOOLCHAIN_FILE=${NDK_PATH}/build/cmake/android.toolchain.cmake \
 513       [additional CMake flags] {source_directory}
 514     make
 515
 516
 517 ### x86-64 (64-bit)
 518
 519 The following is a general recipe script that can be modified for your specific
 520 needs.
 521
 522     # Set these variables to suit your needs
 523     NDK_PATH={full path to the NDK directory-- for example,
 524       /opt/android/android-ndk-r16b}
 525     TOOLCHAIN={"gcc" or "clang"-- "gcc" must be used with NDK r14b and earlier,
 526       and "clang" must be used with NDK r17c and later}
 527     ANDROID_VERSION={the minimum version of Android to support.  "21" or later
 528       is required for a 64-bit build.}
 529
 530     cd {build_directory}
 531     cmake -G"Unix Makefiles" \
 532       -DANDROID_ABI=x86_64 \
 533       -DANDROID_PLATFORM=android-${ANDROID_VERSION} \
 534       -DANDROID_TOOLCHAIN=${TOOLCHAIN} \
 535       -DCMAKE_TOOLCHAIN_FILE=${NDK_PATH}/build/cmake/android.toolchain.cmake \
 536       [additional CMake flags] {source_directory}
 537     make
 538
 539
 540 Advanced CMake Options
 541 ----------------------
 542
 543 To list and configure other CMake options not specifically mentioned in this
 544 guide, run
 545
 546     ccmake {source_directory}
 547
 548 or
 549
 550     cmake-gui {source_directory}
 551
 552 from the build directory after initially configuring the build.  CCMake is a
 553 text-based interactive version of CMake, and CMake-GUI is a GUI version.  Both
 554 will display all variables that are relevant to the libjpeg-turbo build, their
 555 current values, and a help string describing what they do.
 556
 557
 558 Installing libjpeg-turbo
 559 ========================
 560
 561 You can use the build system to install libjpeg-turbo (as opposed to creating
 562 an installer package.)  To do this, run `make install` or `nmake install`
 563 (or build the "install" target in the Visual Studio IDE.)  Running
 564 `make uninstall` or `nmake uninstall` (or building the "uninstall" target in
 565 the Visual Studio IDE) will uninstall libjpeg-turbo.
 566
 567 The `CMAKE_INSTALL_PREFIX` CMake variable can be modified in order to install
 568 libjpeg-turbo into a directory of your choosing.  If you don't specify
 569 `CMAKE_INSTALL_PREFIX`, then the default is:
 570
 571 **c:\libjpeg-turbo**<br>
 572 Visual Studio 32-bit build
 573
 574 **c:\libjpeg-turbo64**<br>
 575 Visual Studio 64-bit build
 576
 577 **c:\libjpeg-turbo-gcc**<br>
 578 MinGW 32-bit build
 579
 580 **c:\libjpeg-turbo-gcc64**<br>
 581 MinGW 64-bit build
 582
 583 **/opt/libjpeg-turbo**<br>
 584 Un*x
 585
 586 The default value of `CMAKE_INSTALL_PREFIX` causes the libjpeg-turbo files to
 587 be installed with a directory structure resembling that of the official
 588 libjpeg-turbo binary packages.  Changing the value of `CMAKE_INSTALL_PREFIX`
 589 (for instance, to **/usr/local**) causes the libjpeg-turbo files to be
 590 installed with a directory structure that conforms to GNU standards.
 591
 592 The `CMAKE_INSTALL_BINDIR`, `CMAKE_INSTALL_DATAROOTDIR`,
 593 `CMAKE_INSTALL_DOCDIR`, `CMAKE_INSTALL_INCLUDEDIR`, `CMAKE_INSTALL_JAVADIR`,
 594 `CMAKE_INSTALL_LIBDIR`, and `CMAKE_INSTALL_MANDIR` CMake variables allow a
 595 finer degree of control over where specific files in the libjpeg-turbo
 596 distribution should be installed.  These directory variables can either be
 597 specified as absolute paths or as paths relative to `CMAKE_INSTALL_PREFIX` (for
 598 instance, setting `CMAKE_INSTALL_DOCDIR` to **doc** would cause the
 599 documentation to be installed in **${CMAKE\_INSTALL\_PREFIX}/doc**.)  If a
 600 directory variable contains the name of another directory variable in angle
 601 brackets, then its final value will depend on the final value of that other
 602 variable.  For instance, the default value of `CMAKE_INSTALL_MANDIR` is
 603 **\<CMAKE\_INSTALL\_DATAROOTDIR\>/man**.
 604
 605 NOTE: If setting one of these directory variables to a relative path using the
 606 CMake command line, you must specify that the variable is of type `PATH`.
 607 For example:
 608
 609     cmake -G"{generator type}" -DCMAKE_INSTALL_LIBDIR:PATH=lib {source_directory}
 610
 611 Otherwise, CMake will assume that the path is relative to the build directory
 612 rather than the install directory.
 613
 614
 615 Creating Distribution Packages
 616 ==============================
 617
 618 The following commands can be used to create various types of distribution
 619 packages:
 620
 621
 622 Linux
 623 -----
 624
 625     make rpm
 626
 627 Create Red Hat-style binary RPM package.  Requires RPM v4 or later.
 628
 629     make srpm
 630
 631 This runs `make dist` to create a pristine source tarball, then creates a
 632 Red Hat-style source RPM package from the tarball.  Requires RPM v4 or later.
 633
 634     make deb
 635
 636 Create Debian-style binary package.  Requires dpkg.
 637
 638
 639 Mac
 640 ---
 641
 642     make dmg
 643
 644 Create Mac package/disk image.  This requires pkgbuild and productbuild, which
 645 are installed by default on OS X/macOS 10.7 and later.
 646
 647 In order to create a Mac package/disk image that contains universal
 648 x86-64/Arm binaries, set the following CMake variable:
 649
 650 * `ARMV8_BUILD`: Directory containing an Armv8 (64-bit) iOS or macOS build of
 651   libjpeg-turbo to include in the universal binaries
 652
 653 You should first use CMake to configure an Armv8 sub-build of libjpeg-turbo
 654 (see "Building libjpeg-turbo for iOS" above, if applicable) in a build
 655 directory that matches the one specified in the aforementioned CMake variable.
 656 Next, configure the primary (x86-64) build of libjpeg-turbo as an out-of-tree
 657 build, specifying the aforementioned CMake variable, and build it.  Once the
 658 primary build has been built, run `make dmg` from the build directory.  The
 659 packaging system will build the sub-build, use lipo to combine it with the
 660 primary build into a single set of universal binaries, then package the
 661 universal binaries.
 662
 663
 664 Windows
 665 -------
 666
 667 If using NMake:
 668
 669     cd {build_directory}
 670     nmake installer
 671
 672 If using MinGW:
 673
 674     cd {build_directory}
 675     make installer
 676
 677 If using the Visual Studio IDE, build the "installer" target.
 678
 679 The installer package (libjpeg-turbo-*{version}*[-gcc|-vc][64].exe) will be
 680 located under *{build_directory}*.  If building using the Visual Studio IDE,
 681 then the installer package will be located in a subdirectory with the same name
 682 as the configuration you built (such as *{build_directory}*\Debug\ or
 683 *{build_directory}*\Release\).
 684
 685 Building a Windows installer requires the
 686 [Nullsoft Install System](http://nsis.sourceforge.net/).  makensis.exe should
 687 be in your `PATH`.
 688
 689
 690 Regression testing
 691 ==================
 692
 693 The most common way to test libjpeg-turbo is by invoking `make test` (Un*x) or
 694 `nmake test` (Windows command line) or by building the "RUN_TESTS" target
 695 (Visual Studio IDE), once the build has completed.  This runs a series of tests
 696 to ensure that mathematical compatibility has been maintained between
 697 libjpeg-turbo and libjpeg v6b.  This also invokes the TurboJPEG unit tests,
 698 which ensure that the colorspace extensions, YUV encoding, decompression
 699 scaling, and other features of the TurboJPEG C and Java APIs are working
 700 properly (and, by extension, that the equivalent features of the underlying
 701 libjpeg API are also working.)
 702
 703 Invoking `make testclean` (Un*x) or `nmake testclean` (Windows command line) or
 704 building the "testclean" target (Visual Studio IDE) will clean up the output
 705 images generated by the tests.
 706
 707 On Un*x platforms, more extensive tests of the TurboJPEG C and Java wrappers
 708 can be run by invoking `make tjtest`.  These extended TurboJPEG tests
 709 essentially iterate through all of the available features of the TurboJPEG APIs
 710 that are not covered by the TurboJPEG unit tests (including the lossless
 711 transform options) and compare the images generated by each feature to images
 712 generated using the equivalent feature in the libjpeg API.  The extended
 713 TurboJPEG tests are meant to test for regressions in the TurboJPEG wrappers,
 714 not in the underlying libjpeg API library.