Release 0.9.1 (#220 )

Allow arbitrary number of samples as long as all have the same bit depth (#215 )
Update edition and CI script, and add Cargo.lock.msrv (#212 )
2024-01-13 12:01:04 -08:00 · 2023-10-04 09:45:03 -07:00 · 2023-08-20 13:44:35 -07:00 · 2023-08-20 13:39:27 -07:00 · 2023-08-20 13:33:35 -07:00 · 2023-08-20 13:32:08 -07:00
23 changed files with 1162 additions and 442 deletions
@@ -9,32 +9,53 @@ jobs:
    runs-on: ubuntu-latest
    strategy:
      matrix:
-        rust: ["1.48", stable, beta, nightly]
-        command: [build, test]
+        rust: ["1.61.0", stable, beta, nightly]
    steps:
    - uses: actions/checkout@v2
-    - run: rustup default ${{ matrix.rust }}
+    - uses: dtolnay/rust-toolchain@v1
+      with:
+        toolchain: ${{ matrix.rust }}
+    - name: Cache Cargo Dependencies
+      uses: Swatinem/rust-cache@v2
+      with:
+        cache-on-failure: true
+    - name: Install MSRV Cargo.lock
+      if: ${{ matrix.rust == '1.61.0' }}
+      run: mv Cargo.lock.msrv Cargo.lock
    - name: build
-      run: >
-        cargo build --verbose --no-default-features --features "$FEATURES"
+      run: cargo build -v
    - name: test
-      run: >
-        cargo test --tests --benches --no-default-features --features "$FEATURES"
-      if: ${{ matrix.rust != '1.48' }}
-      env:
-        FEATURES: ${{ matrix.features }}
+      if: ${{ matrix.rust != '1.61.0' }}
+      run: cargo test -v && cargo doc -v
+
  rustfmt:
    runs-on: ubuntu-latest
    steps:
    - uses: actions/checkout@v2
-    - uses: actions-rs/toolchain@v1
+    - uses: dtolnay/rust-toolchain@stable
      with:
-        toolchain: stable
-        override: true
        components: rustfmt
    - name: Run rustfmt check
-      uses: actions-rs/cargo@v1
-      with:
-        command: fmt
-        args: -- --check
+      run: cargo fmt -- --check

+  clippy:
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v2
+    - uses: dtolnay/rust-toolchain@stable
+      with:
+        components: clippy
+    - run: cargo clippy --all-features # TODO: enable "-- -D warnings" once all outstanding clippy lints are fixed
+
+  verify_msrv:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+      - name: Install or use cached `cargo-msrv`
+        uses: baptiste0928/cargo-install@v1
+        with:
+          crate: cargo-msrv
+      - name: Install MSRV Cargo.lock
+        run: mv Cargo.lock.msrv Cargo.lock
+      - name: Verify Minimum Rust Version
+        run: cargo-msrv verify
@@ -1,3 +1,66 @@
+# Version 0.9.1
+
+New features:
+- Basic support for planar configuration.
+- Allow arbitrary number of samples as long as all have the same bit depth.
+
+Fixes:
+- Don't panic when parsing metadata when custom compression is used.
+
+# Version 0.9.0
+
+New features:
+* Added support for photometric interpretation `YCbCr` and added related
+  `ColorType`.
+
+Fixes:
+* Decoding tiled images calculates padding correctly when image width or height
+  is a multiple of tile size. It could previously corrupt the last tile per row
+  by skipping over data.
+
+# Version 0.8.1
+
+Changes:
+* The jpeg decoder gained to ability to utilize the Photometric Interpretation
+  directly instead of relying on a custom APP segment.
+
+Fixes:
+* A spurious error within the PackBits decoder lead to the incorrect results
+  (wrong bits or errors), based on the maximum size of reads from the
+  underlying reader.
+* Removed a panic path in jpeg decoding, when a feature such as photometric
+  interpretation is not supported. An error is returned instead.
+
+# Version 0.8.0
+
+Changes:
+* The minimum supported rust version is now indicated in `Cargo.toml`.
+* The enums `TiffFormatError` and `TiffUnsupportedError` are now
+  marked with the `#[non_exhaustive]` attribute. 
+* Additionally, tag related enums `Value`, `Tags`, `Type`, `CompressionMethod`,
+  `PhotometricInterpretation`, `PlanarConfiguration`, `Predictor`,
+  `ResolutionUnit`, `SampleFormat` are also changed.
+
+Removals:
+* Removed deprecated methods of `Decoder`: `init`, `read_jpeg`,
+  `read_strip_to_buffer`, `read_strip`, `read_tile`. The implicit chunk (row or
+  tile) index order could not be easily tracked by the caller. New separate
+  utility interfaces may be introduced at a later point, for now callers are
+  obligated to choose their own.
+
+Fixes:
+* Update to `jpeg_decoder = 0.3`.
+
+# Version 0.7.4
+
+New features:
+* Creating an encoder for invalid, zero-sized images is now rejected.
+
+Fixes:
+* Fix panic, in a case where decoding jpeg encoded images did not expect the
+  jpeg decoder to return an error.
+* Fix panic by validating `rows_per_strip` better, fixing a division-by-zero.
+
 # Version 0.7.3

 New features:
@@ -0,0 +1,638 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 3
+
+[[package]]
+name = "adler"
+version = "1.0.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f26201604c87b1e01bd3d98f8d5d9a8fcbb815e8cedb41ffccbeb4bf593a35fe"
+
+[[package]]
+name = "aho-corasick"
+version = "1.0.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6748e8def348ed4d14996fa801f4122cd763fff530258cdc03f64b25f89d3a5a"
+dependencies = [
+ "memchr",
+]
+
+[[package]]
+name = "atty"
+version = "0.2.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d9b39be18770d11421cdb1b9947a45dd3f37e93092cbf377614828a319d5fee8"
+dependencies = [
+ "hermit-abi 0.1.19",
+ "libc",
+ "winapi",
+]
+
+[[package]]
+name = "autocfg"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d468802bab17cbc0cc575e9b053f41e72aa36bfa6b7f55e3529ffa43161b97fa"
+
+[[package]]
+name = "bitflags"
+version = "1.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a"
+
+[[package]]
+name = "bumpalo"
+version = "3.13.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a3e2c3daef883ecc1b5d58c15adae93470a91d425f3532ba1695849656af3fc1"
+
+[[package]]
+name = "cast"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "37b2a672a2cb129a2e41c10b1224bb368f9f37a2b16b612598138befd7b37eb5"
+
+[[package]]
+name = "cfg-if"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"
+
+[[package]]
+name = "clap"
+version = "2.34.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a0610544180c38b88101fecf2dd634b174a62eef6946f84dfc6a7127512b381c"
+dependencies = [
+ "bitflags",
+ "textwrap",
+ "unicode-width",
+]
+
+[[package]]
+name = "crc32fast"
+version = "1.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b540bd8bc810d3885c6ea91e2018302f68baba2129ab3e88f32389ee9370880d"
+dependencies = [
+ "cfg-if",
+]
+
+[[package]]
+name = "criterion"
+version = "0.3.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b01d6de93b2b6c65e17c634a26653a29d107b3c98c607c765bf38d041531cd8f"
+dependencies = [
+ "atty",
+ "cast",
+ "clap",
+ "criterion-plot",
+ "csv",
+ "itertools",
+ "lazy_static",
+ "num-traits",
+ "oorandom",
+ "plotters",
+ "rayon",
+ "regex",
+ "serde",
+ "serde_cbor",
+ "serde_derive",
+ "serde_json",
+ "tinytemplate",
+ "walkdir",
+]
+
+[[package]]
+name = "criterion-plot"
+version = "0.4.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2673cc8207403546f45f5fd319a974b1e6983ad1a3ee7e6041650013be041876"
+dependencies = [
+ "cast",
+ "itertools",
+]
+
+[[package]]
+name = "crossbeam-channel"
+version = "0.5.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a33c2bf77f2df06183c3aa30d1e96c0695a313d4f9c453cc3762a6db39f99200"
+dependencies = [
+ "cfg-if",
+ "crossbeam-utils",
+]
+
+[[package]]
+name = "crossbeam-deque"
+version = "0.8.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ce6fd6f855243022dcecf8702fef0c297d4338e226845fe067f6341ad9fa0cef"
+dependencies = [
+ "cfg-if",
+ "crossbeam-epoch",
+ "crossbeam-utils",
+]
+
+[[package]]
+name = "crossbeam-epoch"
+version = "0.9.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ae211234986c545741a7dc064309f67ee1e5ad243d0e48335adc0484d960bcc7"
+dependencies = [
+ "autocfg",
+ "cfg-if",
+ "crossbeam-utils",
+ "memoffset",
+ "scopeguard",
+]
+
+[[package]]
+name = "crossbeam-utils"
+version = "0.8.16"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5a22b2d63d4d1dc0b7f1b6b2747dd0088008a9be28b6ddf0b1e7d335e3037294"
+dependencies = [
+ "cfg-if",
+]
+
+[[package]]
+name = "csv"
+version = "1.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "626ae34994d3d8d668f4269922248239db4ae42d538b14c398b74a52208e8086"
+dependencies = [
+ "csv-core",
+ "itoa",
+ "ryu",
+ "serde",
+]
+
+[[package]]
+name = "csv-core"
+version = "0.1.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2b2466559f260f48ad25fe6317b3c8dac77b5bdb5763ac7d9d6103530663bc90"
+dependencies = [
+ "memchr",
+]
+
+[[package]]
+name = "either"
+version = "1.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a26ae43d7bcc3b814de94796a5e736d4029efb0ee900c12e2d54c993ad1a1e07"
+
+[[package]]
+name = "flate2"
+version = "1.0.26"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3b9429470923de8e8cbd4d2dc513535400b4b3fef0319fb5c4e1f520a7bef743"
+dependencies = [
+ "crc32fast",
+ "miniz_oxide",
+]
+
+[[package]]
+name = "half"
+version = "1.8.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "eabb4a44450da02c90444cf74558da904edde8fb4e9035a9a6a4e15445af0bd7"
+
+[[package]]
+name = "hermit-abi"
+version = "0.1.19"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "62b467343b94ba476dcb2500d242dadbb39557df889310ac77c5d99100aaac33"
+dependencies = [
+ "libc",
+]
+
+[[package]]
+name = "hermit-abi"
+version = "0.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "443144c8cdadd93ebf52ddb4056d257f5b52c04d3c804e657d19eb73fc33668b"
+
+[[package]]
+name = "itertools"
+version = "0.10.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b0fd2260e829bddf4cb6ea802289de2f86d6a7a690192fbe91b3f46e0f2c8473"
+dependencies = [
+ "either",
+]
+
+[[package]]
+name = "itoa"
+version = "1.0.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "af150ab688ff2122fcef229be89cb50dd66af9e01a4ff320cc137eecc9bacc38"
+
+[[package]]
+name = "jpeg-decoder"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bc0000e42512c92e31c2252315bda326620a4e034105e900c98ec492fa077b3e"
+
+[[package]]
+name = "js-sys"
+version = "0.3.64"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c5f195fe497f702db0f318b07fdd68edb16955aed830df8363d837542f8f935a"
+dependencies = [
+ "wasm-bindgen",
+]
+
+[[package]]
+name = "lazy_static"
+version = "1.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e2abad23fbc42b3700f2f279844dc832adb2b2eb069b2df918f455c4e18cc646"
+
+[[package]]
+name = "libc"
+version = "0.2.147"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b4668fb0ea861c1df094127ac5f1da3409a82116a4ba74fca2e58ef927159bb3"
+
+[[package]]
+name = "log"
+version = "0.4.20"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b5e6163cb8c49088c2c36f57875e58ccd8c87c7427f7fbd50ea6710b2f3f2e8f"
+
+[[package]]
+name = "memchr"
+version = "2.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2dffe52ecf27772e601905b7522cb4ef790d2cc203488bbd0e2fe85fcb74566d"
+
+[[package]]
+name = "memoffset"
+version = "0.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5a634b1c61a95585bd15607c6ab0c4e5b226e695ff2800ba0cdccddf208c406c"
+dependencies = [
+ "autocfg",
+]
+
+[[package]]
+name = "miniz_oxide"
+version = "0.7.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e7810e0be55b428ada41041c41f32c9f1a42817901b4ccf45fa3d4b6561e74c7"
+dependencies = [
+ "adler",
+]
+
+[[package]]
+name = "num-traits"
+version = "0.2.16"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f30b0abd723be7e2ffca1272140fac1a2f084c77ec3e123c192b66af1ee9e6c2"
+dependencies = [
+ "autocfg",
+]
+
+[[package]]
+name = "num_cpus"
+version = "1.16.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4161fcb6d602d4d2081af7c3a45852d875a03dd337a6bfdd6e06407b61342a43"
+dependencies = [
+ "hermit-abi 0.3.2",
+ "libc",
+]
+
+[[package]]
+name = "once_cell"
+version = "1.18.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dd8b5dd2ae5ed71462c540258bedcb51965123ad7e7ccf4b9a8cafaa4a63576d"
+
+[[package]]
+name = "oorandom"
+version = "11.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0ab1bc2a289d34bd04a330323ac98a1b4bc82c9d9fcb1e66b63caa84da26b575"
+
+[[package]]
+name = "plotters"
+version = "0.3.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d2c224ba00d7cadd4d5c660deaf2098e5e80e07846537c51f9cfa4be50c1fd45"
+dependencies = [
+ "num-traits",
+ "plotters-backend",
+ "plotters-svg",
+ "wasm-bindgen",
+ "web-sys",
+]
+
+[[package]]
+name = "plotters-backend"
+version = "0.3.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9e76628b4d3a7581389a35d5b6e2139607ad7c75b17aed325f210aa91f4a9609"
+
+[[package]]
+name = "plotters-svg"
+version = "0.3.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "38f6d39893cca0701371e3c27294f09797214b86f1fb951b89ade8ec04e2abab"
+dependencies = [
+ "plotters-backend",
+]
+
+[[package]]
+name = "proc-macro2"
+version = "1.0.66"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "18fb31db3f9bddb2ea821cde30a9f70117e3f119938b5ee630b7403aa6e2ead9"
+dependencies = [
+ "unicode-ident",
+]
+
+[[package]]
+name = "quote"
+version = "1.0.33"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5267fca4496028628a95160fc423a33e8b2e6af8a5302579e322e4b520293cae"
+dependencies = [
+ "proc-macro2",
+]
+
+[[package]]
+name = "rayon"
+version = "1.7.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1d2df5196e37bcc87abebc0053e20787d73847bb33134a69841207dd0a47f03b"
+dependencies = [
+ "either",
+ "rayon-core",
+]
+
+[[package]]
+name = "rayon-core"
+version = "1.11.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4b8f95bd6966f5c87776639160a66bd8ab9895d9d4ab01ddba9fc60661aebe8d"
+dependencies = [
+ "crossbeam-channel",
+ "crossbeam-deque",
+ "crossbeam-utils",
+ "num_cpus",
+]
+
+[[package]]
+name = "regex"
+version = "1.9.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "81bc1d4caf89fac26a70747fe603c130093b53c773888797a6329091246d651a"
+dependencies = [
+ "aho-corasick",
+ "memchr",
+ "regex-automata",
+ "regex-syntax",
+]
+
+[[package]]
+name = "regex-automata"
+version = "0.3.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fed1ceff11a1dddaee50c9dc8e4938bd106e9d89ae372f192311e7da498e3b69"
+dependencies = [
+ "aho-corasick",
+ "memchr",
+ "regex-syntax",
+]
+
+[[package]]
+name = "regex-syntax"
+version = "0.7.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e5ea92a5b6195c6ef2a0295ea818b312502c6fc94dde986c5553242e18fd4ce2"
+
+[[package]]
+name = "ryu"
+version = "1.0.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1ad4cc8da4ef723ed60bced201181d83791ad433213d8c24efffda1eec85d741"
+
+[[package]]
+name = "same-file"
+version = "1.0.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "93fc1dc3aaa9bfed95e02e6eadabb4baf7e3078b0bd1b4d7b6b0b68378900502"
+dependencies = [
+ "winapi-util",
+]
+
+[[package]]
+name = "scopeguard"
+version = "1.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "94143f37725109f92c262ed2cf5e59bce7498c01bcc1502d7b9afe439a4e9f49"
+
+[[package]]
+name = "serde"
+version = "1.0.183"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "32ac8da02677876d532745a130fc9d8e6edfa81a269b107c5b00829b91d8eb3c"
+
+[[package]]
+name = "serde_cbor"
+version = "0.11.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2bef2ebfde456fb76bbcf9f59315333decc4fda0b2b44b420243c11e0f5ec1f5"
+dependencies = [
+ "half",
+ "serde",
+]
+
+[[package]]
+name = "serde_derive"
+version = "1.0.183"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "aafe972d60b0b9bee71a91b92fee2d4fb3c9d7e8f6b179aa99f27203d99a4816"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "serde_json"
+version = "1.0.105"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "693151e1ac27563d6dbcec9dee9fbd5da8539b20fa14ad3752b2e6d363ace360"
+dependencies = [
+ "itoa",
+ "ryu",
+ "serde",
+]
+
+[[package]]
+name = "syn"
+version = "2.0.29"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c324c494eba9d92503e6f1ef2e6df781e78f6a7705a0202d9801b198807d518a"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "unicode-ident",
+]
+
+[[package]]
+name = "textwrap"
+version = "0.11.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d326610f408c7a4eb6f51c37c330e496b08506c9457c9d34287ecc38809fb060"
+dependencies = [
+ "unicode-width",
+]
+
+[[package]]
+name = "tiff"
+version = "0.9.0"
+dependencies = [
+ "criterion",
+ "flate2",
+ "jpeg-decoder",
+ "weezl",
+]
+
+[[package]]
+name = "tinytemplate"
+version = "1.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "be4d6b5f19ff7664e8c98d03e2139cb510db9b0a60b55f8e8709b689d939b6bc"
+dependencies = [
+ "serde",
+ "serde_json",
+]
+
+[[package]]
+name = "unicode-ident"
+version = "1.0.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "301abaae475aa91687eb82514b328ab47a211a533026cb25fc3e519b86adfc3c"
+
+[[package]]
+name = "unicode-width"
+version = "0.1.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c0edd1e5b14653f783770bce4a4dabb4a5108a5370a5f5d8cfe8710c361f6c8b"
+
+[[package]]
+name = "walkdir"
+version = "2.3.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "36df944cda56c7d8d8b7496af378e6b16de9284591917d307c9b4d313c44e698"
+dependencies = [
+ "same-file",
+ "winapi-util",
+]
+
+[[package]]
+name = "wasm-bindgen"
+version = "0.2.87"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7706a72ab36d8cb1f80ffbf0e071533974a60d0a308d01a5d0375bf60499a342"
+dependencies = [
+ "cfg-if",
+ "wasm-bindgen-macro",
+]
+
+[[package]]
+name = "wasm-bindgen-backend"
+version = "0.2.87"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5ef2b6d3c510e9625e5fe6f509ab07d66a760f0885d858736483c32ed7809abd"
+dependencies = [
+ "bumpalo",
+ "log",
+ "once_cell",
+ "proc-macro2",
+ "quote",
+ "syn",
+ "wasm-bindgen-shared",
+]
+
+[[package]]
+name = "wasm-bindgen-macro"
+version = "0.2.87"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dee495e55982a3bd48105a7b947fd2a9b4a8ae3010041b9e0faab3f9cd028f1d"
+dependencies = [
+ "quote",
+ "wasm-bindgen-macro-support",
+]
+
+[[package]]
+name = "wasm-bindgen-macro-support"
+version = "0.2.87"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "54681b18a46765f095758388f2d0cf16eb8d4169b639ab575a8f5693af210c7b"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+ "wasm-bindgen-backend",
+ "wasm-bindgen-shared",
+]
+
+[[package]]
+name = "wasm-bindgen-shared"
+version = "0.2.87"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ca6ad05a4870b2bf5fe995117d3728437bd27d7cd5f06f13c17443ef369775a1"
+
+[[package]]
+name = "web-sys"
+version = "0.3.64"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9b85cbef8c220a6abc02aefd892dfc0fc23afb1c6a426316ec33253a3877249b"
+dependencies = [
+ "js-sys",
+ "wasm-bindgen",
+]
+
+[[package]]
+name = "weezl"
+version = "0.1.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9193164d4de03a926d909d3bc7c30543cecb35400c02114792c2cae20d5e2dbb"
+
+[[package]]
+name = "winapi"
+version = "0.3.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5c839a674fcd7a98952e593242ea400abe93992746761e38641405d28b00f419"
+dependencies = [
+ "winapi-i686-pc-windows-gnu",
+ "winapi-x86_64-pc-windows-gnu",
+]
+
+[[package]]
+name = "winapi-i686-pc-windows-gnu"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6"
+
+[[package]]
+name = "winapi-util"
+version = "0.1.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "70ec6ce85bb158151cae5e5c87f95a8e97d2c0c4b001223f33a334e3ce5de178"
+dependencies = [
+ "winapi",
+]
+
+[[package]]
+name = "winapi-x86_64-pc-windows-gnu"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f"
@@ -1,16 +1,24 @@
 [package]
 name = "tiff"
-version = "0.7.3"
-authors = ["The image-rs Developers"]
+version = "0.9.1"
+edition = "2021"
+resolver = "2"
+
+# note: when changed, also update test runner in `.github/workflows/rust.yml`
+rust-version = "1.61.0"
+
 license = "MIT"
 description = "TIFF decoding and encoding library in pure Rust"
+authors = ["The image-rs Developers"]
+
 repository = "https://github.com/image-rs/image-tiff"
+categories = ["multimedia::images", "multimedia::encoding"]
+
 exclude = ["tests/images/*", "tests/fuzz_images/*"]
-edition = "2018"

 [dependencies]
 weezl = "0.1.0"
-jpeg = { package = "jpeg-decoder", version = "0.2.4", default-features = false }
+jpeg = { package = "jpeg-decoder", version = "0.3.0", default-features = false }
 flate2 = "1.0.20"

 [dev-dependencies]
@@ -17,6 +17,7 @@ use self::Value::{

 #[allow(unused_qualifications)]
 #[derive(Debug, Clone, PartialEq)]
+#[non_exhaustive]
 pub enum Value {
    Byte(u8),
    Short(u16),
@@ -34,8 +35,6 @@ pub enum Value {
    Ascii(String),
    Ifd(u32),
    IfdBig(u64),
-    #[doc(hidden)] // Do not match against this.
-    __NonExhaustive,
 }

 impl Value {
@@ -361,7 +360,6 @@ impl Entry {
            | Type::RATIONAL
            | Type::SRATIONAL
            | Type::IFD8 => 8,
-            Type::__NonExhaustive => unreachable!(),
        };

        let value_bytes = match self.count.checked_mul(tag_size) {
@@ -398,7 +396,6 @@ impl Entry {
                    | Type::SLONG
                    | Type::FLOAT
                    | Type::IFD => unreachable!(),
-                    Type::__NonExhaustive => unreachable!(),
                });
            }

@@ -444,7 +441,6 @@ impl Entry {
                    reader.goto_offset(self.r(bo).read_u32()?.into())?;
                    IfdBig(reader.read_u64()?)
                }
-                Type::__NonExhaustive => unreachable!(),
            });
        }

@@ -528,7 +524,6 @@ impl Entry {
                | Type::IFD8 => {
                    unreachable!()
                }
-                Type::__NonExhaustive => unreachable!(),
            }
        }

@@ -542,7 +537,7 @@ impl Entry {
                Ok(UnsignedBig(u64::from(buf[0])))
            }),
            Type::SBYTE => self.decode_offset(self.count, bo, bigtiff, limits, reader, |reader| {
-                Ok(SignedBig(i64::from(reader.read_i8()? as i8)))
+                Ok(SignedBig(i64::from(reader.read_i8()?)))
            }),
            Type::SHORT => self.decode_offset(self.count, bo, bigtiff, limits, reader, |reader| {
                Ok(UnsignedBig(u64::from(reader.read_u16()?)))
@@ -611,7 +606,6 @@ impl Entry {
                }
                Ok(Ascii(String::from_utf8(out)?))
            }
-            Type::__NonExhaustive => unreachable!(),
        }
    }

@@ -1,14 +1,13 @@
 use super::ifd::{Directory, Value};
-use super::stream::{
-    add_app14segment, ByteOrder, DeflateReader, JpegReader, JpegTagApp14Transform, LZWReader,
-    PackBitsReader,
-};
+use super::stream::{ByteOrder, DeflateReader, LZWReader, PackBitsReader};
 use super::tag_reader::TagReader;
 use super::{fp_predict_f32, fp_predict_f64, DecodingBuffer, Limits};
 use super::{stream::SmartReader, ChunkType};
-use crate::tags::{CompressionMethod, PhotometricInterpretation, Predictor, SampleFormat, Tag};
+use crate::tags::{
+    CompressionMethod, PhotometricInterpretation, PlanarConfiguration, Predictor, SampleFormat, Tag,
+};
 use crate::{ColorType, TiffError, TiffFormatError, TiffResult, TiffUnsupportedError, UsageError};
-use std::convert::{TryFrom, TryInto};
+use std::convert::TryFrom;
 use std::io::{self, Cursor, Read, Seek};
 use std::sync::Arc;

@@ -35,12 +34,11 @@ impl TileAttributes {
        (self.image_height + self.tile_length - 1) / self.tile_length
    }
    fn padding_right(&self) -> usize {
-        self.tile_width - self.image_width % self.tile_width
+        (self.tile_width - self.image_width % self.tile_width) % self.tile_width
    }
    fn padding_down(&self) -> usize {
-        self.tile_length - self.image_height % self.tile_length
+        (self.tile_length - self.image_height % self.tile_length) % self.tile_length
    }
-
    pub fn get_padding(&self, tile: usize) -> (usize, usize) {
        let row = tile / self.tiles_across();
        let column = tile % self.tiles_across();
@@ -66,15 +64,16 @@ pub(crate) struct Image {
    pub ifd: Option<Directory>,
    pub width: u32,
    pub height: u32,
-    pub bits_per_sample: Vec<u8>,
+    pub bits_per_sample: u8,
    #[allow(unused)]
-    pub samples: u8,
+    pub samples: u16,
    pub sample_format: Vec<SampleFormat>,
    pub photometric_interpretation: PhotometricInterpretation,
    pub compression_method: CompressionMethod,
    pub predictor: Predictor,
    pub jpeg_tables: Option<Arc<Vec<u8>>>,
    pub chunk_type: ChunkType,
+    pub planar_config: PlanarConfiguration,
    pub strip_decoder: Option<StripDecodeState>,
    pub tile_attributes: Option<TileAttributes>,
    pub chunk_offsets: Vec<u64>,
@@ -97,6 +96,11 @@ impl Image {

        let width = tag_reader.require_tag(Tag::ImageWidth)?.into_u32()?;
        let height = tag_reader.require_tag(Tag::ImageLength)?.into_u32()?;
+        if width == 0 || height == 0 {
+            return Err(TiffError::FormatError(TiffFormatError::InvalidDimensions(
+                width, height,
+            )));
+        }

        let photometric_interpretation = tag_reader
            .find_tag(Tag::PhotometricInterpretation)?
@@ -108,15 +112,14 @@ impl Image {
        // Try to parse both the compression method and the number, format, and bits of the included samples.
        // If they are not explicitly specified, those tags are reset to their default values and not carried from previous images.
        let compression_method = match tag_reader.find_tag(Tag::Compression)? {
-            Some(val) => CompressionMethod::from_u16(val.into_u16()?)
-                .ok_or(TiffUnsupportedError::UnknownCompressionMethod)?,
+            Some(val) => CompressionMethod::from_u16_exhaustive(val.into_u16()?),
            None => CompressionMethod::None,
        };

        let jpeg_tables = if compression_method == CompressionMethod::ModernJPEG
            && ifd.contains_key(&Tag::JPEGTables)
        {
-            let mut vec = tag_reader
+            let vec = tag_reader
                .find_tag(Tag::JPEGTables)?
                .unwrap()
                .into_u8_vec()?;
@@ -126,22 +129,19 @@ impl Image {
                ));
            }

-            // TODO: Can we avoid this somehow?
-            if photometric_interpretation == PhotometricInterpretation::RGB {
-                add_app14segment(&mut vec, JpegTagApp14Transform::App14TransformUnknown)
-            }
-
            Some(Arc::new(vec))
        } else {
            None
        };

-        let samples = tag_reader
+        let samples: u16 = tag_reader
            .find_tag(Tag::SamplesPerPixel)?
            .map(Value::into_u16)
            .transpose()?
-            .unwrap_or(1)
-            .try_into()?;
+            .unwrap_or(1);
+        if samples == 0 {
+            return Err(TiffFormatError::SamplesPerPixelIsZero.into());
+        }

        let sample_format = match tag_reader.find_tag_uint_vec(Tag::SampleFormat)? {
            Some(vals) => {
@@ -160,12 +160,22 @@ impl Image {
            None => vec![SampleFormat::Uint],
        };

-        let bits_per_sample = match samples {
-            1 | 3 | 4 => tag_reader
-                .find_tag_uint_vec(Tag::BitsPerSample)?
-                .unwrap_or_else(|| vec![1]),
-            _ => return Err(TiffUnsupportedError::UnsupportedSampleDepth(samples).into()),
-        };
+        let bits_per_sample: Vec<u8> = tag_reader
+            .find_tag_uint_vec(Tag::BitsPerSample)?
+            .unwrap_or_else(|| vec![1]);
+
+        // Technically bits_per_sample.len() should be *equal* to samples, but libtiff also allows
+        // it to be a single value that applies to all samples.
+        if bits_per_sample.len() != samples.into() && bits_per_sample.len() != 1 {
+            return Err(TiffError::FormatError(
+                TiffFormatError::InconsistentSizesEncountered,
+            ));
+        }
+
+        // This library (and libtiff) do not support mixed sample formats.
+        if bits_per_sample.iter().any(|&b| b != bits_per_sample[0]) {
+            return Err(TiffUnsupportedError::InconsistentBitsPerSample(bits_per_sample).into());
+        }

        let predictor = tag_reader
            .find_tag(Tag::Predictor)?
@@ -178,6 +188,23 @@ impl Image {
            .transpose()?
            .unwrap_or(Predictor::None);

+        let planar_config = tag_reader
+            .find_tag(Tag::PlanarConfiguration)?
+            .map(Value::into_u16)
+            .transpose()?
+            .map(|p| {
+                PlanarConfiguration::from_u16(p).ok_or(TiffError::FormatError(
+                    TiffFormatError::UnknownPlanarConfiguration(p),
+                ))
+            })
+            .transpose()?
+            .unwrap_or(PlanarConfiguration::Chunky);
+
+        let planes = match planar_config {
+            PlanarConfiguration::Chunky => 1,
+            PlanarConfiguration::Planar => samples,
+        };
+
        let chunk_type;
        let chunk_offsets;
        let chunk_bytes;
@@ -208,7 +235,11 @@ impl Image {
                strip_decoder = Some(StripDecodeState { rows_per_strip });
                tile_attributes = None;

-                if chunk_offsets.len() != chunk_bytes.len() {
+                if chunk_offsets.len() != chunk_bytes.len()
+                    || rows_per_strip == 0
+                    || u32::try_from(chunk_offsets.len())?
+                        != (height.saturating_sub(1) / rows_per_strip + 1) * planes as u32
+                {
                    return Err(TiffError::FormatError(
                        TiffFormatError::InconsistentSizesEncountered,
                    ));
@@ -246,7 +277,8 @@ impl Image {

                let tile = tile_attributes.as_ref().unwrap();
                if chunk_offsets.len() != chunk_bytes.len()
-                    || chunk_offsets.len() != tile.tiles_down() * tile.tiles_across()
+                    || chunk_offsets.len()
+                        != tile.tiles_down() * tile.tiles_across() * planes as usize
                {
                    return Err(TiffError::FormatError(
                        TiffFormatError::InconsistentSizesEncountered,
@@ -264,7 +296,7 @@ impl Image {
            ifd: Some(ifd),
            width,
            height,
-            bits_per_sample,
+            bits_per_sample: bits_per_sample[0],
            samples,
            sample_format,
            photometric_interpretation,
@@ -272,6 +304,7 @@ impl Image {
            jpeg_tables,
            predictor,
            chunk_type,
+            planar_config,
            strip_decoder,
            tile_attributes,
            chunk_offsets,
@@ -281,9 +314,9 @@ impl Image {

    pub(crate) fn colortype(&self) -> TiffResult<ColorType> {
        match self.photometric_interpretation {
-            PhotometricInterpretation::RGB => match self.bits_per_sample[..] {
-                [r, g, b] if [r, r] == [g, b] => Ok(ColorType::RGB(r)),
-                [r, g, b, a] if [r, r, r] == [g, b, a] => Ok(ColorType::RGBA(r)),
+            PhotometricInterpretation::RGB => match self.samples {
+                3 => Ok(ColorType::RGB(self.bits_per_sample)),
+                4 => Ok(ColorType::RGBA(self.bits_per_sample)),
                // FIXME: We should _ignore_ other components. In particular:
                // > Beware of extra components. Some TIFF files may have more components per pixel
                // than you think. A Baseline TIFF reader must skip over them gracefully,using the
@@ -292,30 +325,39 @@ impl Image {
                _ => Err(TiffError::UnsupportedError(
                    TiffUnsupportedError::InterpretationWithBits(
                        self.photometric_interpretation,
-                        self.bits_per_sample.clone(),
+                        vec![self.bits_per_sample; self.samples as usize],
                    ),
                )),
            },
-            PhotometricInterpretation::CMYK => match self.bits_per_sample[..] {
-                [c, m, y, k] if [c, c, c] == [m, y, k] => Ok(ColorType::CMYK(c)),
+            PhotometricInterpretation::CMYK => match self.samples {
+                4 => Ok(ColorType::CMYK(self.bits_per_sample)),
                _ => Err(TiffError::UnsupportedError(
                    TiffUnsupportedError::InterpretationWithBits(
                        self.photometric_interpretation,
-                        self.bits_per_sample.clone(),
+                        vec![self.bits_per_sample; self.samples as usize],
+                    ),
+                )),
+            },
+            PhotometricInterpretation::YCbCr => match self.samples {
+                3 => Ok(ColorType::YCbCr(self.bits_per_sample)),
+                _ => Err(TiffError::UnsupportedError(
+                    TiffUnsupportedError::InterpretationWithBits(
+                        self.photometric_interpretation,
+                        vec![self.bits_per_sample; self.samples as usize],
                    ),
                )),
            },
            PhotometricInterpretation::BlackIsZero | PhotometricInterpretation::WhiteIsZero
-                if self.bits_per_sample.len() == 1 =>
+                if self.samples == 1 =>
            {
-                Ok(ColorType::Gray(self.bits_per_sample[0]))
+                Ok(ColorType::Gray(self.bits_per_sample))
            }

            // TODO: this is bad we should not fail at this point
            _ => Err(TiffError::UnsupportedError(
                TiffUnsupportedError::InterpretationWithBits(
                    self.photometric_interpretation,
-                    self.bits_per_sample.clone(),
+                    vec![self.bits_per_sample; self.samples as usize],
                ),
            )),
        }
@@ -323,9 +365,10 @@ impl Image {

    fn create_reader<'r, R: 'r + Read>(
        reader: R,
+        photometric_interpretation: PhotometricInterpretation,
        compression_method: CompressionMethod,
        compressed_length: u64,
-        jpeg_tables: Option<Arc<Vec<u8>>>,
+        jpeg_tables: Option<&[u8]>,
    ) -> TiffResult<Box<dyn Read + 'r>> {
        Ok(match compression_method {
            CompressionMethod::None => Box::new(reader),
@@ -343,9 +386,60 @@ impl Image {
                    ));
                }

-                let jpeg_reader = JpegReader::new(reader, compressed_length, jpeg_tables)?;
+                // Construct new jpeg_reader wrapping a SmartReader.
+                //
+                // JPEG compression in TIFF allows saving quantization and/or huffman tables in one
+                // central location. These `jpeg_tables` are simply prepended to the remaining jpeg image data.
+                // Because these `jpeg_tables` start with a `SOI` (HEX: `0xFFD8`) or __start of image__ marker
+                // which is also at the beginning of the remaining JPEG image data and would
+                // confuse the JPEG renderer, one of these has to be taken off. In this case the first two
+                // bytes of the remaining JPEG data is removed because it follows `jpeg_tables`.
+                // Similary, `jpeg_tables` ends with a `EOI` (HEX: `0xFFD9`) or __end of image__ marker,
+                // this has to be removed as well (last two bytes of `jpeg_tables`).
+                let jpeg_reader = match jpeg_tables {
+                    Some(jpeg_tables) => {
+                        let mut reader = reader.take(compressed_length);
+                        reader.read_exact(&mut [0; 2])?;
+
+                        Box::new(
+                            Cursor::new(&jpeg_tables[..jpeg_tables.len() - 2])
+                                .chain(reader.take(compressed_length)),
+                        ) as Box<dyn Read>
+                    }
+                    None => Box::new(reader.take(compressed_length)),
+                };
+
                let mut decoder = jpeg::Decoder::new(jpeg_reader);
-                let data = decoder.decode().unwrap();
+
+                match photometric_interpretation {
+                    PhotometricInterpretation::RGB => {
+                        decoder.set_color_transform(jpeg::ColorTransform::RGB)
+                    }
+                    PhotometricInterpretation::WhiteIsZero => {
+                        decoder.set_color_transform(jpeg::ColorTransform::None)
+                    }
+                    PhotometricInterpretation::BlackIsZero => {
+                        decoder.set_color_transform(jpeg::ColorTransform::None)
+                    }
+                    PhotometricInterpretation::TransparencyMask => {
+                        decoder.set_color_transform(jpeg::ColorTransform::None)
+                    }
+                    PhotometricInterpretation::CMYK => {
+                        decoder.set_color_transform(jpeg::ColorTransform::CMYK)
+                    }
+                    PhotometricInterpretation::YCbCr => {
+                        decoder.set_color_transform(jpeg::ColorTransform::YCbCr)
+                    }
+                    photometric_interpretation => {
+                        return Err(TiffError::UnsupportedError(
+                            TiffUnsupportedError::UnsupportedInterpretation(
+                                photometric_interpretation,
+                            ),
+                        ));
+                    }
+                }
+
+                let data = decoder.decode()?;

                Box::new(Cursor::new(data))
            }
@@ -357,6 +451,28 @@ impl Image {
        })
    }

+    /// Samples per pixel within chunk.
+    ///
+    /// In planar config, samples are stored in separate strips/chunks, also called bands.
+    ///
+    /// Example with `bits_per_sample = [8, 8, 8]` and `PhotometricInterpretation::RGB`:
+    /// * `PlanarConfiguration::Chunky` -> 3 (RGBRGBRGB...)
+    /// * `PlanarConfiguration::Planar` -> 1 (RRR...) (GGG...) (BBB...)
+    pub(crate) fn samples_per_pixel(&self) -> usize {
+        match self.planar_config {
+            PlanarConfiguration::Chunky => self.samples.into(),
+            PlanarConfiguration::Planar => 1,
+        }
+    }
+
+    /// Number of strips per pixel.
+    pub(crate) fn strips_per_pixel(&self) -> usize {
+        match self.planar_config {
+            PlanarConfiguration::Chunky => 1,
+            PlanarConfiguration::Planar => self.samples.into(),
+        }
+    }
+
    pub(crate) fn chunk_file_range(&self, chunk: u32) -> TiffResult<(u64, u64)> {
        let file_offset = self
            .chunk_offsets
@@ -396,7 +512,10 @@ impl Image {

        match self.chunk_type {
            ChunkType::Strip => {
-                let strip_height_without_padding = chunk_index
+                let strip_attrs = self.strip_decoder.as_ref().unwrap();
+                let strips_per_band =
+                    self.height.saturating_sub(1) / strip_attrs.rows_per_strip + 1;
+                let strip_height_without_padding = (chunk_index % strips_per_band)
                    .checked_mul(dims.1)
                    .and_then(|x| self.height.checked_sub(x))
                    .ok_or(TiffError::UsageError(UsageError::InvalidChunkIndex(
@@ -427,6 +546,7 @@ impl Image {
        output_width: usize,
        byte_order: ByteOrder,
        chunk_index: u32,
+        limits: &Limits,
    ) -> TiffResult<()> {
        // Validate that the provided buffer is of the expected type.
        let color_type = self.colortype()?;
@@ -434,6 +554,7 @@ impl Image {
            (ColorType::RGB(n), _)
            | (ColorType::RGBA(n), _)
            | (ColorType::CMYK(n), _)
+            | (ColorType::YCbCr(n), _)
            | (ColorType::Gray(n), _)
                if usize::from(n) == buffer.byte_len() * 8 => {}
            (ColorType::Gray(n), DecodingBuffer::U8(_)) if n < 8 => match self.predictor {
@@ -448,7 +569,6 @@ impl Image {
                        TiffUnsupportedError::FloatingPointPredictor(color_type),
                    ));
                }
-                Predictor::__NonExhaustive => unreachable!(),
            },
            (type_, _) => {
                return Err(TiffError::UnsupportedError(
@@ -481,21 +601,28 @@ impl Image {
                .ok_or(TiffError::FormatError(
                    TiffFormatError::InconsistentSizesEncountered,
                ))?;
+        if *compressed_bytes > limits.intermediate_buffer_size as u64 {
+            return Err(TiffError::LimitsExceeded);
+        }

        let byte_len = buffer.byte_len();
        let compression_method = self.compression_method;
        let photometric_interpretation = self.photometric_interpretation;
        let predictor = self.predictor;
-        let samples = self.bits_per_sample.len();
+        let samples = self.samples_per_pixel();

        let chunk_dims = self.chunk_dimensions()?;
        let data_dims = self.chunk_data_dimensions(chunk_index)?;

        let padding_right = chunk_dims.0 - data_dims.0;

-        let jpeg_tables = self.jpeg_tables.clone();
-        let mut reader =
-            Self::create_reader(reader, compression_method, *compressed_bytes, jpeg_tables)?;
+        let mut reader = Self::create_reader(
+            reader,
+            photometric_interpretation,
+            compression_method,
+            *compressed_bytes,
+            self.jpeg_tables.as_deref().map(|a| &**a),
+        )?;

        if output_width == data_dims.0 as usize && padding_right == 0 {
            let total_samples = data_dims.0 as usize * data_dims.1 as usize * samples;
@@ -503,8 +630,8 @@ impl Image {
            reader.read_exact(tile)?;

            for row in 0..data_dims.1 as usize {
-                let row_start = row as usize * output_width as usize * samples;
-                let row_end = (row + 1) * output_width as usize * samples;
+                let row_start = row * output_width * samples;
+                let row_end = (row + 1) * output_width * samples;
                let row = buffer.subrange(row_start..row_end);
                super::fix_endianness_and_predict(row, samples, byte_order, predictor);
            }
@@ -517,7 +644,7 @@ impl Image {
            let mut encoded = vec![0u8; chunk_dims.0 as usize * samples * byte_len];

            for row in 0..data_dims.1 as usize {
-                let row_start = row * output_width as usize * samples;
+                let row_start = row * output_width * samples;
                let row_end = row_start + data_dims.0 as usize * samples;

                reader.read_exact(&mut encoded)?;
@@ -532,7 +659,7 @@ impl Image {
            }
        } else {
            for row in 0..data_dims.1 as usize {
-                let row_start = row * output_width as usize * samples;
+                let row_start = row * output_width * samples;
                let row_end = row_start + data_dims.0 as usize * samples;

                let row = &mut buffer.as_bytes_mut()[(row_start * byte_len)..(row_end * byte_len)];
@@ -10,7 +10,8 @@ use crate::{
 use self::ifd::Directory;
 use self::image::Image;
 use crate::tags::{
-    CompressionMethod, PhotometricInterpretation, Predictor, SampleFormat, Tag, Type,
+    CompressionMethod, PhotometricInterpretation, PlanarConfiguration, Predictor, SampleFormat,
+    Tag, Type,
 };

 use self::stream::{ByteOrder, EndianReader, SmartReader};
@@ -220,7 +221,7 @@ impl<'a> DecodingBuffer<'a> {

    fn as_bytes_mut(&mut self) -> &mut [u8] {
        match self {
-            DecodingBuffer::U8(buf) => &mut *buf,
+            DecodingBuffer::U8(ref mut buf) => buf,
            DecodingBuffer::I8(buf) => bytecast::i8_as_ne_mut_bytes(buf),
            DecodingBuffer::U16(buf) => bytecast::u16_as_ne_mut_bytes(buf),
            DecodingBuffer::I16(buf) => bytecast::i16_as_ne_mut_bytes(buf),
@@ -301,7 +302,6 @@ where
    reader: SmartReader<R>,
    bigtiff: bool,
    limits: Limits,
-    current_chunk: u32,
    next_ifd: Option<u64>,
    ifd_offsets: Vec<u64>,
    seen_ifds: HashSet<u64>,
@@ -371,8 +371,8 @@ pub fn fp_predict_f32(input: &mut [u8], output: &mut [f32], samples: usize) {
    for i in 0..output.len() {
        // TODO: use f32::from_be_bytes() when we can (version 1.40)
        output[i] = f32::from_bits(u32::from_be_bytes([
-            input[input.len() / 4 * 0 + i],
-            input[input.len() / 4 * 1 + i],
+            input[i],
+            input[input.len() / 4 + i],
            input[input.len() / 4 * 2 + i],
            input[input.len() / 4 * 3 + i],
        ]));
@@ -384,8 +384,8 @@ pub fn fp_predict_f64(input: &mut [u8], output: &mut [f64], samples: usize) {
    for i in 0..output.len() {
        // TODO: use f64::from_be_bytes() when we can (version 1.40)
        output[i] = f64::from_bits(u64::from_be_bytes([
-            input[input.len() / 8 * 0 + i],
-            input[input.len() / 8 * 1 + i],
+            input[i],
+            input[input.len() / 8 + i],
            input[input.len() / 8 * 2 + i],
            input[input.len() / 8 * 3 + i],
            input[input.len() / 8 * 4 + i],
@@ -430,7 +430,6 @@ fn fix_endianness_and_predict(
                _ => unreachable!("Caller should have validated arguments. Please file a bug."),
            }
        }
-        Predictor::__NonExhaustive => unreachable!(),
    }
 }

@@ -573,7 +572,7 @@ impl<R: Read + Seek> Decoder<R> {
                ifd: None,
                width: 0,
                height: 0,
-                bits_per_sample: vec![1],
+                bits_per_sample: 1,
                samples: 1,
                sample_format: vec![SampleFormat::Uint],
                photometric_interpretation: PhotometricInterpretation::BlackIsZero,
@@ -581,12 +580,12 @@ impl<R: Read + Seek> Decoder<R> {
                jpeg_tables: None,
                predictor: Predictor::None,
                chunk_type: ChunkType::Strip,
+                planar_config: PlanarConfiguration::Chunky,
                strip_decoder: None,
                tile_attributes: None,
                chunk_offsets: Vec::new(),
                chunk_bytes: Vec::new(),
            },
-            current_chunk: 0,
        };
        decoder.next_image()?;
        Ok(decoder)
@@ -638,7 +637,6 @@ impl<R: Read + Seek> Decoder<R> {
        if let Some(ifd_offset) = self.ifd_offsets.get(ifd_index) {
            let (ifd, _next_ifd) = Self::read_ifd(&mut self.reader, self.bigtiff, *ifd_offset)?;

-            self.current_chunk = 0;
            self.image = Image::from_reader(&mut self.reader, ifd, &self.limits, self.bigtiff)?;

            Ok(())
@@ -649,13 +647,6 @@ impl<R: Read + Seek> Decoder<R> {
        }
    }

-    /// Reset the decoder.
-    #[deprecated = "Never should have been public. Only use Decoder::new()"]
-    pub fn init(self) -> TiffResult<Decoder<R>> {
-        let Self { reader, .. } = self;
-        Self::new(reader.into_inner())
-    }
-
    fn next_ifd(&mut self) -> TiffResult<(Directory, Option<u64>)> {
        if self.next_ifd.is_none() {
            return Err(TiffError::FormatError(
@@ -686,7 +677,6 @@ impl<R: Read + Seek> Decoder<R> {
    pub fn next_image(&mut self) -> TiffResult<()> {
        let (ifd, _next_ifd) = self.next_ifd()?;

-        self.current_chunk = 0;
        self.image = Image::from_reader(&mut self.reader, ifd, &self.limits, self.bigtiff)?;
        Ok(())
    }
@@ -1028,7 +1018,12 @@ impl<R: Read + Seek> Decoder<R> {
            None => return Err(TiffError::IntSizeError),
        };

-        Ok(height / rows_per_strip)
+        let strips = match self.image().planar_config {
+            PlanarConfiguration::Chunky => height / rows_per_strip,
+            PlanarConfiguration::Planar => height / rows_per_strip * self.image().samples as u32,
+        };
+
+        Ok(strips)
    }

    /// Number of tiles in image
@@ -1037,33 +1032,6 @@ impl<R: Read + Seek> Decoder<R> {
        Ok(u32::try_from(self.image().chunk_offsets.len())?)
    }

-    #[deprecated = "Use read_image instead"]
-    pub fn read_jpeg(&mut self) -> TiffResult<DecodingResult> {
-        self.read_image()
-    }
-
-    #[deprecated = "Use read_chunk_to_buffer instead"]
-    pub fn read_strip_to_buffer(&mut self, mut buffer: DecodingBuffer) -> TiffResult<()> {
-        self.check_chunk_type(ChunkType::Strip)?;
-
-        let offset = self.image.chunk_file_range(self.current_chunk)?.0;
-        self.goto_offset_u64(offset)?;
-
-        let byte_order = self.reader.byte_order;
-        let output_width = usize::try_from(self.image().width)?;
-        self.image.expand_chunk(
-            &mut self.reader,
-            buffer.copy(),
-            output_width,
-            byte_order,
-            self.current_chunk,
-        )?;
-
-        self.current_chunk += 1;
-
-        Ok(())
-    }
-
    pub fn read_chunk_to_buffer(
        &mut self,
        mut buffer: DecodingBuffer,
@@ -1081,6 +1049,7 @@ impl<R: Read + Seek> Decoder<R> {
            output_width,
            byte_order,
            chunk_index,
+            &self.limits,
        )?;

        Ok(())
@@ -1089,19 +1058,13 @@ impl<R: Read + Seek> Decoder<R> {
    fn result_buffer(&self, width: usize, height: usize) -> TiffResult<DecodingResult> {
        let buffer_size = match width
            .checked_mul(height)
-            .and_then(|x| x.checked_mul(self.image().bits_per_sample.len()))
+            .and_then(|x| x.checked_mul(self.image().samples_per_pixel()))
        {
            Some(s) => s,
            None => return Err(TiffError::LimitsExceeded),
        };

-        let max_sample_bits = self
-            .image()
-            .bits_per_sample
-            .iter()
-            .cloned()
-            .max()
-            .unwrap_or(8);
+        let max_sample_bits = self.image().bits_per_sample;
        match self
            .image()
            .sample_format
@@ -1133,36 +1096,10 @@ impl<R: Read + Seek> Decoder<R> {
                    TiffUnsupportedError::UnsupportedBitsPerChannel(n),
                )),
            },
-            format => {
-                Err(TiffUnsupportedError::UnsupportedSampleFormat(vec![format.clone()]).into())
-            }
+            format => Err(TiffUnsupportedError::UnsupportedSampleFormat(vec![*format]).into()),
        }
    }

-    /// Read a single strip from the image and return it as a Vector. This method does not return
-    /// information on the size of the strip read and so the caller must take care of the final
-    /// strip in the image as the data read may be less than the expected strip size. This interface
-    /// may change at a future date to reflect this.
-    #[deprecated = "Use read_chunk instead"]
-    pub fn read_strip(&mut self) -> TiffResult<DecodingResult> {
-        let result = self.read_chunk(self.current_chunk)?;
-
-        Ok(result)
-    }
-
-    /// Read a single tile from the image and return it as a Vector. This method does not return
-    /// information on the size of the tile read and so the caller must take care of tiles on the
-    /// rightmost column and the bottommost row in the image as the data read may be less than the
-    /// expected tile size. This interface may change at a future date to reflect this.
-    #[deprecated = "Use read_chunk instead"]
-    pub fn read_tile(&mut self) -> TiffResult<DecodingResult> {
-        let result = self.read_chunk(self.current_chunk)?;
-
-        self.current_chunk += 1;
-
-        Ok(result)
-    }
-
    /// Read the specified chunk (at index `chunk_index`) and return the binary data as a Vector.
    pub fn read_chunk(&mut self, chunk_index: u32) -> TiffResult<DecodingResult> {
        let data_dims = self.image().chunk_data_dimensions(chunk_index)?;
@@ -1208,7 +1145,7 @@ impl<R: Read + Seek> Decoder<R> {
            ));
        }

-        let samples = self.image().bits_per_sample.len();
+        let samples = self.image().samples_per_pixel();
        if samples == 0 {
            return Err(TiffError::FormatError(
                TiffFormatError::InconsistentSizesEncountered,
@@ -1218,7 +1155,12 @@ impl<R: Read + Seek> Decoder<R> {
        let chunks_across = ((width - 1) / chunk_dimensions.0 + 1) as usize;
        let strip_samples = width as usize * chunk_dimensions.1 as usize * samples;

-        for chunk in 0..self.image().chunk_offsets.len() {
+        let image_chunks = self.image().chunk_offsets.len() / self.image().strips_per_pixel();
+        // For multi-band images, only the first band is read.
+        // Possible improvements:
+        // * pass requested band as parameter
+        // * collect bands to a RGB encoding result in case of RGB bands
+        for chunk in 0..image_chunks {
            self.goto_offset_u64(self.image().chunk_offsets[chunk])?;

            let x = chunk % chunks_across;
@@ -1231,6 +1173,7 @@ impl<R: Read + Seek> Decoder<R> {
                width as usize,
                byte_order,
                chunk as u32,
+                &self.limits,
            )?;
        }

@@ -1,8 +1,7 @@
 //! All IO functionality needed for TIFF decoding

 use std::convert::TryFrom;
-use std::io::{self, BufRead, BufReader, Read, Seek, SeekFrom, Take};
-use std::sync::Arc;
+use std::io::{self, BufRead, BufReader, Read, Seek, Take};

 /// Byte order of the TIFF file.
 #[derive(Clone, Copy, Debug)]
@@ -183,156 +182,6 @@ impl<R: Read> Read for LZWReader<R> {
    }
 }

-///
-/// ## JPEG Reader (for "new-style" JPEG format (TIFF compression tag 7))
-///
-
-pub(crate) struct JpegReader {
-    jpeg_tables: Option<Arc<Vec<u8>>>,
-
-    buffer: io::Cursor<Vec<u8>>,
-
-    offset: usize,
-}
-
-impl JpegReader {
-    /// Constructs new JpegReader wrapping a SmartReader.
-    /// Because JPEG compression in TIFF allows to save quantization and/or huffman tables in one
-    /// central location, the constructor accepts this data as `jpeg_tables` here containing either
-    /// or both.
-    /// These `jpeg_tables` are simply prepended to the remaining jpeg image data.
-    /// Because these `jpeg_tables` start with a `SOI` (HEX: `0xFFD8`) or __start of image__ marker
-    /// which is also at the beginning of the remaining JPEG image data and would
-    /// confuse the JPEG renderer, one of these has to be taken off. In this case the first two
-    /// bytes of the remaining JPEG data is removed because it follows `jpeg_tables`.
-    /// Similary, `jpeg_tables` ends with a `EOI` (HEX: `0xFFD9`) or __end of image__ marker,
-    /// this has to be removed as well (last two bytes of `jpeg_tables`).
-    pub fn new<R: Read>(
-        mut reader: R,
-        length: u64,
-        jpeg_tables: Option<Arc<Vec<u8>>>,
-    ) -> io::Result<JpegReader> {
-        // Read jpeg image data
-        let mut segment = vec![0; length as usize];
-
-        reader.read_exact(&mut segment[..])?;
-
-        match jpeg_tables {
-            Some(jpeg_tables) => {
-                assert!(
-                    jpeg_tables.len() >= 2,
-                    "jpeg_tables, if given, must be at least 2 bytes long. Got {:?}",
-                    jpeg_tables
-                );
-
-                assert!(
-                    length >= 2,
-                    "if jpeg_tables is given, length must be at least 2 bytes long, got {}",
-                    length
-                );
-
-                let mut buffer = io::Cursor::new(segment);
-                // Skip the first two bytes (marker bytes)
-                buffer.seek(SeekFrom::Start(2))?;
-
-                Ok(JpegReader {
-                    buffer,
-                    jpeg_tables: Some(jpeg_tables),
-                    offset: 0,
-                })
-            }
-            None => Ok(JpegReader {
-                buffer: io::Cursor::new(segment),
-                jpeg_tables: None,
-                offset: 0,
-            }),
-        }
-    }
-}
-
-#[repr(u8)]
-pub(crate) enum JpegTagApp14Transform {
-    // App14TransformYCCK = 2,
-    // App14TransformYCbCr = 1,
-    App14TransformUnknown = 0,
-}
-
-pub(crate) fn add_app14segment(jpeg_tables: &mut Vec<u8>, transform: JpegTagApp14Transform) {
-    // Add JPEG Tag APP14 Adobe segment to jpeg_tables.
-    // This segment stores image encoding information for DCT filters.
-    // When `transform` value is 0 which is defined as Unknown, jpeg-decoder interpret the
-    // color-space of image as RGB(3 channels) or CMYK(4).
-    let mut app14_offset = None;
-    let mut dht_offset = None;
-    for (offset, window) in jpeg_tables.windows(2).enumerate() {
-        if window == [0xff, 0xee] {
-            app14_offset = Some(offset);
-            break;
-        }
-        if window == [0xff, 0xc4] {
-            dht_offset = Some(offset);
-        }
-    }
-    match (app14_offset, dht_offset) {
-        (Some(i), _) => {
-            jpeg_tables[i + 16] = transform as u8;
-        }
-        (None, Some(sos_offset)) => {
-            let app14segment: [u8; 16] = [
-                0xff,
-                0xee,
-                0x00,
-                0x0e,
-                0x41,
-                0x64,
-                0x6f,
-                0x62,
-                0x65,
-                0x00,
-                0x64,
-                0x00,
-                0x00,
-                0x00,
-                0x00,
-                transform as u8,
-            ];
-            jpeg_tables.splice(sos_offset..sos_offset, app14segment.iter().copied());
-        }
-        (None, None) => {}
-    }
-}
-
-impl Read for JpegReader {
-    // #[inline]
-    fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
-        let mut start = 0;
-
-        if let Some(jpeg_tables) = &self.jpeg_tables {
-            if jpeg_tables.len() - 2 > self.offset {
-                // Read (rest of) jpeg_tables to buf (without the last two bytes)
-                let size_remaining = jpeg_tables.len() - self.offset - 2;
-                let to_copy = size_remaining.min(buf.len());
-
-                buf[start..start + to_copy]
-                    .copy_from_slice(&jpeg_tables[self.offset..self.offset + to_copy]);
-
-                self.offset += to_copy;
-
-                if to_copy == buf.len() {
-                    return Ok(to_copy);
-                }
-
-                start += to_copy;
-            }
-        }
-
-        let read = self.buffer.read(&mut buf[start..])?;
-        self.offset += read;
-
-        Ok(read + start)
-    }
-}
-
 ///
 /// ## PackBits Reader
 ///
@@ -370,7 +219,7 @@ impl<R: Read> Read for PackBitsReader<R> {
            let mut header: [u8; 1] = [0];
            self.reader.read_exact(&mut header)?;
            let h = header[0] as i8;
-            if h >= -127 && h <= -1 {
+            if (-127..=-1).contains(&h) {
                let mut data: [u8; 1] = [0];
                self.reader.read_exact(&mut data)?;
                self.state = PackBitsReaderState::Repeat { value: data[0] };
@@ -384,23 +233,23 @@ impl<R: Read> Read for PackBitsReader<R> {
        }

        let length = buf.len().min(self.count);
-        match self.state {
-            PackBitsReaderState::Literal => {
-                self.reader.read(&mut buf[..length])?;
-            }
+        let actual = match self.state {
+            PackBitsReaderState::Literal => self.reader.read(&mut buf[..length])?,
            PackBitsReaderState::Repeat { value } => {
                for b in &mut buf[..length] {
                    *b = value;
                }
+
+                length
            }
            PackBitsReaderState::Header => unreachable!(),
-        }
+        };

-        self.count -= length;
+        self.count -= actual;
        if self.count == 0 {
            self.state = PackBitsReaderState::Header;
        }
-        return Ok(length);
+        Ok(actual)
    }
 }

@@ -235,3 +235,11 @@ impl ColorType for CMYK64Float {
    const BITS_PER_SAMPLE: &'static [u16] = &[64, 64, 64, 64];
    const SAMPLE_FORMAT: &'static [SampleFormat] = &[SampleFormat::IEEEFP; 4];
 }
+
+pub struct YCbCr8;
+impl ColorType for YCbCr8 {
+    type Inner = u8;
+    const TIFF_VALUE: PhotometricInterpretation = PhotometricInterpretation::YCbCr;
+    const BITS_PER_SAMPLE: &'static [u16] = &[8, 8, 8];
+    const SAMPLE_FORMAT: &'static [SampleFormat] = &[SampleFormat::Uint; 3];
+}
@@ -46,7 +46,7 @@ impl Compression for Deflate {
    const COMPRESSION_METHOD: CompressionMethod = CompressionMethod::Deflate;

    fn get_algorithm(&self) -> Compressor {
-        Compressor::Deflate(self.clone())
+        Compressor::Deflate(*self)
    }
 }

@@ -41,7 +41,7 @@ mod tests {

        let mut compressed_data = Vec::<u8>::new();
        let mut writer = Cursor::new(&mut compressed_data);
-        Lzw::default().write_to(&mut writer, TEST_DATA).unwrap();
+        Lzw.write_to(&mut writer, TEST_DATA).unwrap();
        assert_eq!(EXPECTED_COMPRESSED_DATA, compressed_data.as_slice());
    }
 }
@@ -38,7 +38,7 @@ pub enum Compressor {
 impl Default for Compressor {
    /// The default compression strategy does not apply any compression.
    fn default() -> Self {
-        Compressor::Uncompressed(Uncompressed::default())
+        Compressor::Uncompressed(Uncompressed)
    }
 }

@@ -55,6 +55,5 @@ impl CompressionAlgorithm for Compressor {

 #[cfg(test)]
 mod tests {
-    pub const TEST_DATA: &'static [u8] =
-        b"This is a string for checking various compression algorithms.";
+    pub const TEST_DATA: &[u8] = b"This is a string for checking various compression algorithms.";
 }
@@ -80,33 +80,31 @@ impl CompressionAlgorithm for Packbits {
                    run_index = 0;
                    in_run = false;
                }
-            } else {
-                if bytes_pending > MAX_BYTES {
-                    // We have as much differing data as we can output in one chunk.
-                    // Output MAX_BYTES leaving one byte.
-                    offset.get_or_insert(write_u8(&mut bufwriter, encode_diff(MAX_BYTES))?);
-                    bufwriter.write(&bytes[pending_index..pending_index + MAX_BYTES as usize])?;
-                    bytes_written += 1 + MAX_BYTES as u64;
+            } else if bytes_pending > MAX_BYTES {
+                // We have as much differing data as we can output in one chunk.
+                // Output MAX_BYTES leaving one byte.
+                offset.get_or_insert(write_u8(&mut bufwriter, encode_diff(MAX_BYTES))?);
+                bufwriter.write_all(&bytes[pending_index..pending_index + MAX_BYTES as usize])?;
+                bytes_written += 1 + MAX_BYTES as u64;

-                    pending_index += MAX_BYTES as usize;
-                    bytes_pending -= MAX_BYTES;
-                    run_index = bytes_pending - 1; // A run could start here
-                } else if curr_byte == last_byte {
-                    if (bytes_pending - run_index >= MIN_REPT) || (run_index == 0) {
-                        // This is a worthwhile run
-                        if run_index != 0 {
-                            // Flush differing data out of input buffer
-                            offset.get_or_insert(write_u8(&mut bufwriter, encode_diff(run_index))?);
-                            bufwriter
-                                .write(&bytes[pending_index..pending_index + run_index as usize])?;
-                            bytes_written += 1 + run_index as u64;
-                        }
-                        bytes_pending -= run_index; // Length of run
-                        in_run = true;
+                pending_index += MAX_BYTES as usize;
+                bytes_pending -= MAX_BYTES;
+                run_index = bytes_pending - 1; // A run could start here
+            } else if curr_byte == last_byte {
+                if (bytes_pending - run_index >= MIN_REPT) || (run_index == 0) {
+                    // This is a worthwhile run
+                    if run_index != 0 {
+                        // Flush differing data out of input buffer
+                        offset.get_or_insert(write_u8(&mut bufwriter, encode_diff(run_index))?);
+                        bufwriter
+                            .write_all(&bytes[pending_index..pending_index + run_index as usize])?;
+                        bytes_written += 1 + run_index as u64;
                    }
-                } else {
-                    run_index = bytes_pending - 1; // A run could start here
+                    bytes_pending -= run_index; // Length of run
+                    in_run = true;
                }
+            } else {
+                run_index = bytes_pending - 1; // A run could start here
            }
            last_byte = curr_byte;
        }
@@ -119,7 +117,7 @@ impl CompressionAlgorithm for Packbits {
        } else {
            bytes_written += 1 + bytes_pending as u64;
            offset.get_or_insert(write_u8(&mut bufwriter, encode_diff(bytes_pending))?);
-            bufwriter.write(&bytes[pending_index..pending_index + bytes_pending as usize])?;
+            bufwriter.write_all(&bytes[pending_index..pending_index + bytes_pending as usize])?;
        }

        bufwriter.flush()?;
@@ -141,24 +139,20 @@ mod tests {

        let mut compressed_data = Vec::<u8>::new();
        let mut writer = Cursor::new(&mut compressed_data);
-        Packbits::default()
-            .write_to(&mut writer, &UNCOMPRESSED_DATA)
-            .unwrap();
+        Packbits.write_to(&mut writer, &UNCOMPRESSED_DATA).unwrap();
        assert_eq!(compressed_data, EXPECTED_COMPRESSED_DATA);
    }

    #[test]
    fn test_packbits_rept() {
        // compress buffer with repetitive sequence
-        const UNCOMPRESSED_DATA: &'static [u8] =
+        const UNCOMPRESSED_DATA: &[u8] =
            b"This strrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrring hangs.";
-        const EXPECTED_COMPRESSED_DATA: &'static [u8] = b"\x06This st\xD1r\x09ing hangs.";
+        const EXPECTED_COMPRESSED_DATA: &[u8] = b"\x06This st\xD1r\x09ing hangs.";

        let mut compressed_data = Vec::<u8>::new();
        let mut writer = Cursor::new(&mut compressed_data);
-        Packbits::default()
-            .write_to(&mut writer, UNCOMPRESSED_DATA)
-            .unwrap();
+        Packbits.write_to(&mut writer, UNCOMPRESSED_DATA).unwrap();
        assert_eq!(compressed_data, EXPECTED_COMPRESSED_DATA);
    }

@@ -192,23 +186,19 @@ mod tests {

        let mut compressed_data = Vec::<u8>::new();
        let mut writer = Cursor::new(&mut compressed_data);
-        Packbits::default()
-            .write_to(&mut writer, data.as_slice())
-            .unwrap();
+        Packbits.write_to(&mut writer, data.as_slice()).unwrap();
        assert_eq!(compressed_data, EXPECTED_COMPRESSED_DATA);
    }

    #[test]
    fn test_packbits() {
        // compress teststring
-        const EXPECTED_COMPRESSED_DATA: &'static [u8] =
+        const EXPECTED_COMPRESSED_DATA: &[u8] =
            b"\x3CThis is a string for checking various compression algorithms.";

        let mut compressed_data = Vec::<u8>::new();
        let mut writer = Cursor::new(&mut compressed_data);
-        Packbits::default()
-            .write_to(&mut writer, TEST_DATA)
-            .unwrap();
+        Packbits.write_to(&mut writer, TEST_DATA).unwrap();
        assert_eq!(compressed_data, EXPECTED_COMPRESSED_DATA);
    }
 }
@@ -29,9 +29,7 @@ mod tests {
    fn test_no_compression() {
        let mut compressed_data = Vec::<u8>::new();
        let mut writer = Cursor::new(&mut compressed_data);
-        Uncompressed::default()
-            .write_to(&mut writer, TEST_DATA)
-            .unwrap();
+        Uncompressed.write_to(&mut writer, TEST_DATA).unwrap();
        assert_eq!(TEST_DATA, compressed_data);
    }
 }
@@ -13,6 +13,7 @@ use std::{
 use crate::{
    error::TiffResult,
    tags::{CompressionMethod, ResolutionUnit, Tag},
+    TiffError, TiffFormatError,
 };

 pub mod colortype;
@@ -218,19 +219,19 @@ impl<'a, W: 'a + Write + Seek, K: TiffKind> DirectoryEncoder<'a, W, K> {

        let offset = self.writer.offset();

-        K::write_entry_count(&mut self.writer, self.ifd.len())?;
+        K::write_entry_count(self.writer, self.ifd.len())?;
        for (
            tag,
-            &DirectoryEntry {
-                data_type: ref field_type,
-                ref count,
-                data: ref offset,
+            DirectoryEntry {
+                data_type: field_type,
+                count,
+                data: offset,
            },
        ) in self.ifd.iter()
        {
            self.writer.write_u16(*tag)?;
            self.writer.write_u16(*field_type)?;
-            (*count).write(&mut self.writer)?;
+            (*count).write(self.writer)?;
            self.writer.write_bytes(offset)?;
        }

@@ -242,7 +243,7 @@ impl<'a, W: 'a + Write + Seek, K: TiffKind> DirectoryEncoder<'a, W, K> {
    /// This could be used to write tiff strips.
    pub fn write_data<T: TiffValue>(&mut self, value: T) -> TiffResult<u64> {
        let offset = self.writer.offset();
-        value.write(&mut self.writer)?;
+        value.write(self.writer)?;
        Ok(offset)
    }

@@ -256,9 +257,9 @@ impl<'a, W: 'a + Write + Seek, K: TiffKind> DirectoryEncoder<'a, W, K> {
        let curr_pos = self.writer.offset();

        self.writer.goto_offset(self.ifd_pointer_pos)?;
-        K::write_offset(&mut self.writer, ifd_pointer)?;
+        K::write_offset(self.writer, ifd_pointer)?;
        self.writer.goto_offset(curr_pos)?;
-        K::write_offset(&mut self.writer, 0)?;
+        K::write_offset(self.writer, 0)?;

        self.dropped = true;

@@ -349,6 +350,12 @@ impl<'a, W: 'a + Write + Seek, T: ColorType, K: TiffKind, D: Compression>
        height: u32,
        compression: D,
    ) -> TiffResult<Self> {
+        if width == 0 || height == 0 {
+            return Err(TiffError::FormatError(TiffFormatError::InvalidDimensions(
+                width, height,
+            )));
+        }
+
        let row_samples = u64::from(width) * u64::try_from(<T>::BITS_PER_SAMPLE.len())?;
        let row_bytes = row_samples * u64::from(<T::Inner>::BYTE_LEN);

@@ -393,7 +400,7 @@ impl<'a, W: 'a + Write + Seek, T: ColorType, K: TiffKind, D: Compression>
            strip_offsets: Vec::new(),
            strip_byte_count: Vec::new(),
            dropped: false,
-            compression: compression,
+            compression,
            _phantom: ::std::marker::PhantomData,
        })
    }
@@ -182,7 +182,7 @@ impl<W: Write> TiffWriter<W> {
 impl<W: Seek> TiffWriter<W> {
    pub fn goto_offset(&mut self, offset: u64) -> Result<(), io::Error> {
        self.offset = offset;
-        self.writer.seek(SeekFrom::Start(offset as u64))?;
+        self.writer.seek(SeekFrom::Start(offset))?;
        Ok(())
    }
 }
@@ -1,8 +1,12 @@
 use std::error::Error;
 use std::fmt;
+use std::fmt::Display;
 use std::io;
 use std::str;
 use std::string;
+use std::sync::Arc;
+
+use jpeg::UnsupportedFeature;

 use crate::decoder::{ifd::Value, ChunkType};
 use crate::tags::{
@@ -43,6 +47,7 @@ pub enum TiffError {
 /// The list of variants may grow to incorporate errors of future features. Matching against this
 /// exhaustively is not covered by interface stability guarantees.
 #[derive(Debug, Clone, PartialEq)]
+#[non_exhaustive]
 pub enum TiffFormatError {
    TiffSignatureNotFound,
    TiffSignatureInvalid,
@@ -56,10 +61,12 @@ pub enum TiffFormatError {
        actual_samples: usize,
        required_samples: usize,
    },
+    InvalidDimensions(u32, u32),
    InvalidTag,
    InvalidTagValueType(Tag),
    RequiredTagNotFound(Tag),
    UnknownPredictor(u16),
+    UnknownPlanarConfiguration(u16),
    ByteExpected(Value),
    UnsignedIntegerExpected(Value),
    SignedIntegerExpected(Value),
@@ -67,9 +74,8 @@ pub enum TiffFormatError {
    RequiredTagEmpty(Tag),
    StripTileTagConflict,
    CycleInOffsets,
-    #[doc(hidden)]
-    /// Do not match against this variant. It may get removed.
-    __NonExhaustive,
+    JpegDecoder(JpegDecoderError),
+    SamplesPerPixelIsZero,
 }

 impl fmt::Display for TiffFormatError {
@@ -100,6 +106,7 @@ impl fmt::Display for TiffFormatError {
                    actual_samples, required_samples
                )
            }
+            InvalidDimensions(width, height) => write!(fmt, "Invalid dimensions: {}x{}.", width, height),
            InvalidTag => write!(fmt, "Image contains invalid tag."),
            InvalidTagValueType(ref tag) => {
                write!(fmt, "Tag `{:?}` did not have the expected value type.", tag)
@@ -108,6 +115,9 @@ impl fmt::Display for TiffFormatError {
            UnknownPredictor(ref predictor) => {
                write!(fmt, "Unknown predictor “{}” encountered", predictor)
            }
+            UnknownPlanarConfiguration(ref planar_config) =>  {
+                write!(fmt, "Unknown planar configuration “{}” encountered", planar_config)
+            }
            ByteExpected(ref val) => write!(fmt, "Expected byte, {:?} found.", val),
            UnsignedIntegerExpected(ref val) => {
                write!(fmt, "Expected unsigned integer, {:?} found.", val)
@@ -119,7 +129,8 @@ impl fmt::Display for TiffFormatError {
            RequiredTagEmpty(ref val) => write!(fmt, "Required tag {:?} was empty.", val),
            StripTileTagConflict => write!(fmt, "File should contain either (StripByteCounts and StripOffsets) or (TileByteCounts and TileOffsets), other combination was found."),
            CycleInOffsets => write!(fmt, "File contained a cycle in the list of IFDs"),
-            __NonExhaustive => unreachable!(),
+            JpegDecoder(ref error) => write!(fmt, "{}",  error),
+            SamplesPerPixelIsZero => write!(fmt, "Samples per pixel is zero"),
        }
    }
 }
@@ -133,9 +144,11 @@ impl fmt::Display for TiffFormatError {
 /// The list of variants may grow. Matching against this exhaustively is not covered by interface
 /// stability guarantees.
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
+#[non_exhaustive]
 pub enum TiffUnsupportedError {
    FloatingPointPredictor(ColorType),
    HorizontalPredictor(ColorType),
+    InconsistentBitsPerSample(Vec<u8>),
    InterpretationWithBits(PhotometricInterpretation, Vec<u8>),
    UnknownInterpretation,
    UnknownCompressionMethod,
@@ -146,9 +159,8 @@ pub enum TiffUnsupportedError {
    UnsupportedBitsPerChannel(u8),
    UnsupportedPlanarConfig(Option<PlanarConfiguration>),
    UnsupportedDataType,
-    #[doc(hidden)]
-    /// Do not match against this variant. It may get removed.
-    __NonExhaustive,
+    UnsupportedInterpretation(PhotometricInterpretation),
+    UnsupportedJpegFeature(UnsupportedFeature),
 }

 impl fmt::Display for TiffUnsupportedError {
@@ -165,6 +177,9 @@ impl fmt::Display for TiffUnsupportedError {
                "Horizontal predictor for {:?} is unsupported.",
                color_type
            ),
+            InconsistentBitsPerSample(ref bits_per_sample) => {
+                write!(fmt, "Inconsistent bits per sample: {:?}.", bits_per_sample)
+            }
            InterpretationWithBits(ref photometric_interpretation, ref bits_per_sample) => write!(
                fmt,
                "{:?} with {:?} bits per sample is unsupported",
@@ -194,7 +209,16 @@ impl fmt::Display for TiffUnsupportedError {
                write!(fmt, "Unsupported planar configuration “{:?}”.", config)
            }
            UnsupportedDataType => write!(fmt, "Unsupported data type."),
-            __NonExhaustive => unreachable!(),
+            UnsupportedInterpretation(interpretation) => {
+                write!(
+                    fmt,
+                    "Unsupported photometric interpretation \"{:?}\".",
+                    interpretation
+                )
+            }
+            UnsupportedJpegFeature(ref unsupported_feature) => {
+                write!(fmt, "Unsupported JPEG feature {:?}", unsupported_feature)
+            }
        }
    }
 }
@@ -314,5 +338,42 @@ impl From<LzwError> for TiffError {
    }
 }

+#[derive(Debug, Clone)]
+pub struct JpegDecoderError {
+    inner: Arc<jpeg::Error>,
+}
+
+impl JpegDecoderError {
+    fn new(error: jpeg::Error) -> Self {
+        Self {
+            inner: Arc::new(error),
+        }
+    }
+}
+
+impl PartialEq for JpegDecoderError {
+    fn eq(&self, other: &Self) -> bool {
+        Arc::ptr_eq(&self.inner, &other.inner)
+    }
+}
+
+impl Display for JpegDecoderError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        self.inner.fmt(f)
+    }
+}
+
+impl From<JpegDecoderError> for TiffError {
+    fn from(error: JpegDecoderError) -> Self {
+        TiffError::FormatError(TiffFormatError::JpegDecoder(error))
+    }
+}
+
+impl From<jpeg::Error> for TiffError {
+    fn from(error: jpeg::Error) -> Self {
+        JpegDecoderError::new(error).into()
+    }
+}
+
 /// Result of an image decoding/encoding process
 pub type TiffResult<T> = Result<T, TiffError>;
@@ -4,7 +4,7 @@
 //! lossless and lossy compression.
 //!
 //! # Related Links
-//! * <https://www.adobe.io/open/standards/TIFF.html> - The TIFF specification
+//! * <https://web.archive.org/web/20210108073850/https://www.adobe.io/open/standards/TIFF.html> - The TIFF specification

 extern crate jpeg;
 extern crate weezl;
@@ -37,4 +37,7 @@ pub enum ColorType {

    /// Pixel is CMYK
    CMYK(u8),
+
+    /// Pixel is YCbCr
+    YCbCr(u8),
 }
@@ -9,11 +9,9 @@ macro_rules! tags {
    } => {
        $( #[$enum_attr] )*
        #[derive(Clone, Copy, PartialEq, Eq, Debug, Hash)]
+        #[non_exhaustive]
        pub enum $name {
            $($(#[$ident_attr])* $tag,)*
-            // FIXME: switch to non_exhaustive once stabilized and compiler requirement new enough
-            #[doc(hidden)]
-            __NonExhaustive,
            $(
                #[doc = $unknown_doc]
                Unknown($ty),
@@ -34,7 +32,6 @@ macro_rules! tags {
                match *self {
                    $( $name::$tag => $val, )*
                    $( $name::Unknown(n) => { $unknown_doc; n }, )*
-                    $name::__NonExhaustive => unreachable!(),
                }
            }
        }
@@ -175,7 +172,7 @@ pub enum Type(u16) {
 tags! {
 /// See [TIFF compression tags](https://www.awaresystems.be/imaging/tiff/tifftags/compression.html)
 /// for reference.
-pub enum CompressionMethod(u16) {
+pub enum CompressionMethod(u16) unknown("A custom compression method") {
    None = 1,
    Huffman = 2,
    Fax3 = 3,
@@ -285,6 +285,48 @@ fn test_tiled_incremental() {
    }
 }

+#[test]
+fn test_planar_rgb_u8() {
+    // gdal_translate tiled-rgb-u8.tif planar-rgb-u8.tif -co INTERLEAVE=BAND -co COMPRESS=LZW -co PROFILE=BASELINE
+    let file = "planar-rgb-u8.tif";
+    let expected_type = ColorType::RGB(8);
+
+    let path = PathBuf::from(TEST_IMAGE_DIR).join(file);
+    let img_file = File::open(path).expect("Cannot find test image!");
+    let mut decoder = Decoder::new(img_file).expect("Cannot create decoder");
+    assert_eq!(decoder.colortype().unwrap(), expected_type);
+
+    let chunks = decoder.strip_count().unwrap();
+    assert_eq!(chunks as usize, 72);
+
+    // convert -quiet planar-rgb-u8.tif[0] -crop 1x1+0+0 txt:
+    // 0,0: (73,51,30)  #49331E  srgb(73,51,30)
+
+    // 1st band (red)
+    match decoder.read_chunk(0).unwrap() {
+        DecodingResult::U8(chunk) => {
+            assert_eq!(chunk[0], 73);
+        }
+        _ => panic!("Wrong bit depth"),
+    }
+    // 2nd band (green)
+    match decoder.read_chunk(chunks / 3).unwrap() {
+        DecodingResult::U8(chunk) => {
+            assert_eq!(chunk[0], 51);
+        }
+        _ => panic!("Wrong bit depth"),
+    }
+    // 3rd band (blue)
+    match decoder.read_chunk(chunks / 3 * 2).unwrap() {
+        DecodingResult::U8(chunk) => {
+            assert_eq!(chunk[0], 30);
+        }
+        _ => panic!("Wrong bit depth"),
+    }
+
+    test_image_sum_u8(file, ColorType::RGB(8), 15417630);
+}
+
 #[test]
 fn test_div_zero() {
    use tiff::{TiffError, TiffFormatError};
@@ -333,9 +375,7 @@ fn fuzzer_testcase5() {
        178, 178, 178,
    ];

-    let mut decoder = tiff::decoder::Decoder::new(std::io::Cursor::new(&image)).unwrap();
-
-    let _ = decoder.read_image().unwrap_err();
+    let _ = tiff::decoder::Decoder::new(std::io::Cursor::new(&image)).unwrap_err();
 }

 #[test]
@@ -352,7 +392,7 @@ fn fuzzer_testcase1() {
 }

 #[test]
-fn test_stripped_image_overflow() {
+fn fuzzer_testcase6() {
    let image = [
        73, 73, 42, 0, 8, 0, 0, 0, 8, 0, 0, 1, 4, 0, 1, 0, 0, 0, 100, 0, 0, 148, 1, 1, 4, 0, 1, 0,
        0, 0, 158, 0, 0, 251, 3, 1, 3, 255, 254, 255, 255, 0, 1, 0, 0, 0, 6, 1, 3, 0, 1, 0, 0, 0,
@@ -361,14 +401,7 @@ fn test_stripped_image_overflow() {
        178, 178,
    ];

-    let mut decoder = tiff::decoder::Decoder::new(std::io::Cursor::new(&image)).unwrap();
-
-    let err = decoder.read_image().unwrap_err();
-
-    match err {
-        tiff::TiffError::LimitsExceeded => {}
-        unexpected => panic!("Unexpected error {}", unexpected),
-    }
+    let _ = tiff::decoder::Decoder::new(std::io::Cursor::new(&image)).unwrap_err();
 }

 #[test]
@@ -380,16 +413,7 @@ fn oom() {
        0, 0, 0, 40, 0, 0, 0, 23, 1, 4, 0, 1, 0, 0, 0, 178, 48, 178, 178, 178, 178, 162, 178,
    ];

-    let mut decoder = tiff::decoder::Decoder::new(std::io::Cursor::new(&image)).unwrap();
-
-    let err = decoder.read_image().unwrap_err();
-
-    match err {
-        tiff::TiffError::UnsupportedError(tiff::TiffUnsupportedError::InterpretationWithBits(
-            ..,
-        )) => {}
-        unexpected => panic!("Unexpected error {}", unexpected),
-    }
+    let _ = tiff::decoder::Decoder::new(std::io::Cursor::new(&image)).unwrap_err();
 }

 #[test]
@@ -401,14 +425,7 @@ fn fuzzer_testcase4() {
        0, 0, 0, 40, 0, 0, 0, 23, 1, 4, 0, 1, 0, 0, 0, 48, 178, 178, 178, 0, 1, 0, 13, 13,
    ];

-    let mut decoder = tiff::decoder::Decoder::new(std::io::Cursor::new(&image)).unwrap();
-
-    let err = decoder.read_image().unwrap_err();
-
-    match err {
-        tiff::TiffError::IoError(_) => {}
-        unexpected => panic!("Unexpected error {}", unexpected),
-    }
+    let _ = tiff::decoder::Decoder::new(std::io::Cursor::new(&image)).unwrap_err();
 }

 #[test]
@@ -429,9 +446,6 @@ fn fuzzer_testcase2() {

 #[test]
 fn invalid_jpeg_tag_2() {
-    use tiff::tags;
-    use tiff::{TiffError, TiffFormatError};
-
    let image = [
        73, 73, 42, 0, 8, 0, 0, 0, 16, 0, 254, 0, 4, 0, 1, 0, 0, 0, 0, 0, 0, 242, 0, 1, 4, 0, 1, 0,
        0, 0, 0, 129, 16, 0, 1, 1, 4, 0, 1, 0, 0, 0, 214, 0, 0, 248, 253, 1, 3, 0, 1, 0, 0, 0, 64,
@@ -443,15 +457,7 @@ fn invalid_jpeg_tag_2() {
        0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 36, 73, 73, 0, 42, 36, 36, 36, 36, 0, 0, 8, 0,
    ];

-    let mut decoder = tiff::decoder::Decoder::new(std::io::Cursor::new(&image)).unwrap();
-
-    let err = decoder.read_image().unwrap_err();
-
-    match err {
-        TiffError::FormatError(TiffFormatError::InvalidTagValueType(tags::Tag::JPEGTables)) => {}
-        TiffError::LimitsExceeded => {}
-        unexpected => panic!("Unexpected error {}", unexpected),
-    }
+    let _ = tiff::decoder::Decoder::new(std::io::Cursor::new(&image)).unwrap_err();
 }

 #[test]
@@ -94,6 +94,7 @@ fn test_encode_ifd() {
    {
        let mut tiff = TiffEncoder::new(&mut data).unwrap();
        let mut image_encoder = tiff.new_image::<colortype::Gray8>(1, 1).unwrap();
+        image_encoder.write_strip(&[1]).unwrap();
        let encoder = image_encoder.encoder();

        // Use the "reusable" tags section as per the TIFF6 spec
@@ -263,6 +264,11 @@ fn test_gray_f64_roundtrip() {
    test_f64_roundtrip::<colortype::Gray64Float>("gradient-1c-64b-float.tiff", ColorType::Gray(64));
 }

+#[test]
+fn test_ycbcr_u8_roundtrip() {
+    test_u8_roundtrip::<colortype::YCbCr8>("tiled-jpeg-ycbcr.tif", ColorType::YCbCr(8));
+}
+
 trait AssertDecode {
    fn assert_tag_u32(&mut self, tag: u16) -> u32;
    fn assert_tag_u32_vec(&mut self, tag: u16) -> Vec<u32>;
@@ -320,6 +326,7 @@ fn test_multiple_byte() {
    {
        let mut tiff = TiffEncoder::new(&mut data).unwrap();
        let mut image_encoder = tiff.new_image::<colortype::Gray8>(1, 1).unwrap();
+        image_encoder.write_strip(&[1]).unwrap();
        let encoder = image_encoder.encoder();

        encoder.write_tag(Tag::Unknown(65000), &[1_u8][..]).unwrap();
@@ -360,6 +367,7 @@ fn test_signed() {
    {
        let mut tiff = TiffEncoder::new(&mut data).unwrap();
        let mut image_encoder = tiff.new_image::<colortype::Gray8>(1, 1).unwrap();
+        image_encoder.write_strip(&[1]).unwrap();
        let encoder = image_encoder.encoder();

        //Use the "reusable" tags section as per the TIFF6 spec
Author	SHA1	Message	Date
Jonathan Behrens	b0ba4a6788	Release 0.9.1 (#220 )	2024-01-13 12:01:04 -08:00
Jonathan Behrens	4a2e76858b	Allow arbitrary number of samples as long as all have the same bit depth (#215 )	2023-10-04 09:45:03 -07:00
Jonathan Behrens	a67f50568c	Update edition and CI script, and add Cargo.lock.msrv (#212 ) * Add Cargo.lock.msrv, update edition, and CI script * Also run clippy and verify msrv * Fix string mismatch * Have clippy only check for serious errors	2023-08-20 13:44:35 -07:00
Jonathan Behrens	d6f6b8a01e	Merge pull request #213 from fintelia/fix-clippy A bunch of clippy fixes	2023-08-20 13:39:27 -07:00
Jonathan Behrens	8ec91b64f6	Cargo fmt	2023-08-20 13:33:35 -07:00
Jonathan Behrens	60f866c119	A bunch of clippy fixes	2023-08-20 13:32:08 -07:00
Jonathan Behrens	daa0e3eabf	Merge pull request #206 from fintelia/simplify-jpeg Simplify and avoid allocation in jpeg decompression	2023-06-14 14:04:01 -07:00
Jonathan Behrens	24d203c7c3	Simplify and avoid allocation in jpeg decompression	2023-06-11 12:54:30 -07:00
Jonathan Behrens	473868a7bb	Merge pull request #199 from pka/planar-config Basic support for planar configuration	2023-06-10 12:46:20 -07:00
Andreas Molzer	aefea7786f	Merge pull request #203 from AlanRace/custom-compression Don't panic when parsing metadata when custom compression is used	2023-03-08 09:33:03 +01:00
Alan Race	d1ad9b2664	Don't panic when parsing metadata when custom compression is used	2023-03-07 09:15:24 +01:00
Andreas Molzer	bd1d085189	Merge pull request #201 from image-rs/release-0.8.2 Add changelog and metadata for 0.9.0	2023-02-06 23:58:59 +01:00
Andreas Molzer	fcfcecb2df	Add changelog and metadata for 0.8.2	2023-02-06 23:37:12 +01:00
Andreas Molzer	aa10d27a28	Merge pull request #200 from anfedotoff/master Fix capacity overflow in JpegReader	2023-02-06 21:22:13 +01:00
fedotoff	8fa175c371	Fix capacity overflow in JpegReader	2023-02-05 17:53:37 +03:00
Pirmin Kalberer	2a15aa6b7e	Support also tiled planar images	2023-01-17 11:57:54 +01:00
Pirmin Kalberer	42feeba8da	Add basic support for planar configuration	2023-01-12 23:34:31 +01:00
Jonathan Behrens	0da9770916	Merge pull request #190 from kurtkuehnert/YCbCr_support Added support for the YCbCr PhotometricInterpretation	2023-01-06 23:54:16 -08:00
Kurt Kühnert	c30ea911a2	fixed ci	2023-01-05 10:00:10 +01:00
Kurt Kühnert	da07c0f4f5	added round trip test fixed ci added colortype	2023-01-05 09:34:54 +01:00
Jonathan Behrens	289fab2fcd	Merge pull request #197 from pka/fix-padding Fix padding when image size is multiple of chunk size	2022-12-16 15:49:58 -08:00
Pirmin Kalberer	21252d9d89	Fix padding when image size is multiple of chunk size	2022-12-16 23:37:38 +01:00
Andreas Molzer	ffaccf2b52	Merge pull request #196 from image-rs/release-0.8.1 Changelog and metadata for 0.8.1	2022-12-10 16:57:28 +01:00
Andreas Molzer	4dea7c4c81	Changelog and metadata for 0.8.1	2022-12-10 08:25:57 +01:00
Andreas Molzer	aa42fcb1bb	Merge pull request #193 from image-rs/issue-192-desync-packbits Fix read in packbits decoder	2022-12-03 18:49:51 +01:00
Andreas Molzer	1f7b25ef55	Fix read in packbits decoder This assumed that a `read` would succeed for the full length, thus interpreting in a subsequent call some data bits as a header. For instance, consider 77 bytes of literal were left and a buffer of 1024 bytes was provided. Then the `read` call might return 60 which was ignored and assumed to be 77. Thus the next 17 bytes of literal data were instead interpreted as a header due to setting `self.count` to 0.	2022-12-03 18:42:08 +01:00
Andreas Molzer	6c65e66440	Merge pull request #170 from AlanRace/jpeg-unwrap Removed `unwrap` and set colour transform with Jpeg compressed tiffs	2022-11-22 16:17:40 +01:00
Alan Race	a733ff13d9	Changed to using private constructor rather than From<> JpegDecoderError	2022-11-22 15:53:42 +01:00
Alan Race	b1cd459330	Updated error handling	2022-11-22 15:44:10 +01:00
Alan Race	4f1c88e35f	Added unsupported error for interpretations not supported by JPEG	2022-11-22 14:38:27 +01:00
Alan Race	7307e96782	Removed `unwrap` and set colour transform with Jpeg compressed tiffs	2022-11-22 14:31:33 +01:00
Kurt Kühnert	a08604b015	added support for the YCbCr PhotometricInterpretation	2022-11-16 17:33:39 +01:00
HeroicKatora	9333d99c92	Merge pull request #187 from image-rs/release-0.8.0 Changelog for 0.8	2022-11-10 21:02:40 +01:00
Andreas Molzer	65bc24d5d9	Add deprecation removals to changelog	2022-11-10 17:49:32 +01:00
Andreas Molzer	7fc75f194a	Changelog for 0.8	2022-11-10 17:28:12 +01:00
HeroicKatora	7679be19c1	Merge pull request #189 from image-rs/non-exhaustive-enumeration Non exhaustive enumerations	2022-11-10 17:27:31 +01:00
Andreas Molzer	0e9f8e3b5b	Mark more tag enums as non_exhaustive	2022-11-10 12:45:04 +01:00
Andreas Molzer	c900129f2c	Change to non_exhaustive attributes	2022-11-10 12:45:04 +01:00
HeroicKatora	61234c0005	Merge pull request #188 from fintelia/decoder-deprecated Remove deprecated methods on Decoder	2022-11-05 20:22:38 +01:00
Jonathan Behrens	1416af1018	Remove deprecated methods on Decoder	2022-11-05 10:15:31 -07:00
HeroicKatora	87d652ae5e	Merge pull request #186 from micahsnyder/bump-jpeg-decoder-dependency Bump jpeg-decoder version pin to 0.3.0	2022-11-03 08:28:43 +01:00
Micah Snyder	b5a78fbec4	CI: Correct the MSRV from 1.48 to 1.61	2022-11-02 15:00:29 -07:00
Micah Snyder	30640d50ff	Bump jpeg-decoder version pin to 0.3.0 The jpeg-decoder project has a new version with a number of improvements plus a fix for a possible panic. Semantic versioning considers 0.2.4 to be incompatible with 0.3.X because of the leading zero, so this change bumps the pin to 0.3.0.	2022-11-02 14:25:18 -07:00
HeroicKatora	b87770225f	Merge pull request #185 from image-rs/release-0.7.4 Changelog for 0.7.4	2022-10-29 12:44:25 +02:00
Andreas Molzer	d38b65eeb2	Changelog for 0.7.4	2022-10-28 22:58:18 +02:00
HeroicKatora	ee27553cf6	Merge pull request #180 from luksab/patch-1 Update link to the TIFF specification	2022-10-14 20:14:07 +02:00
Lukas Sabatschus	5a809a728e	Update link to the TIFF specification The old link is unavailable since mid-2017, so we link to archive.org	2022-10-14 13:53:29 +02:00
HeroicKatora	b0b99fc536	Merge pull request #173 from micahsnyder/issue-168-handle-jpeg-decoder-errors Handle possible JPEG decoder errors	2022-09-06 21:17:04 +02:00
Jonathan Behrens	3bce92781c	Merge pull request #176 from fintelia/zero-size Return an error for zero-size images	2022-09-05 13:10:30 -07:00
Jonathan Behrens	907bbee576	cargo fmt	2022-09-05 12:54:21 -07:00
Jonathan Behrens	fc0dafcde2	Change error kind	2022-09-05 12:45:22 -07:00
Jonathan Behrens	945a02d1e1	Format	2022-09-05 12:44:42 -07:00
Jonathan Behrens	ef3294d1fe	Return an error for zero-size images	2022-09-05 12:44:42 -07:00
HeroicKatora	0311402999	Merge pull request #177 from fintelia/fix-warnings Fix some warnings	2022-09-05 12:45:04 +02:00
Jonathan Behrens	361578df00	Fix some warnings	2022-09-04 12:35:15 -07:00
Jonathan Behrens	bd23428f52	Validate that images contain the proper number of strips (#174 )	2022-09-04 12:00:34 -07:00
Micah Snyder	d32adf8ef4	Handle possible JPEG decoder errors The JPEG decoder may fail and panic the TIFF decoder. This commit converts the JPEG `Format(String)` error to a TIFF `Format(String)` error. Fixes #168	2022-09-02 15:02:23 -07:00