oximg 0.18.1-aarch64-linux-gnu → 0.19.0-aarch64-linux-gnu

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d4d3cb7265d61a0d89d9851f6e0938951ca773603a02dcdc19ad5b8abf3d68de
-  data.tar.gz: 7cfa66df5ffac827bc245ddd387cc321054dabd6f97c97a13bf3e6b3e8ad50e5
+  metadata.gz: b2f87ce359e8fc26ca90d9d0a92019f6bfeb15d6e0666a3fb5e209ac8c52393d
+  data.tar.gz: 1f9b6406f2aef0f42a99519b846cc4f9e4617e1041ab3bbebda532a09d47e514
 SHA512:
-  metadata.gz: 1be6c2171b1eb682a4d495d3130eca32b7e856db393a5319aba109ada1f5d5cdd1e636ebf8072243894b58d6801849aa0cee30cb34d91adee4f0ff4593bfeb53
-  data.tar.gz: 5c2cf3b537d675e748cd62e3787a1008099ab2e16103ecdfee11d80a8e4b1535f81a5ebc3e3a7b5124410948042b230269f7ffae0dec5a75ea5f91770bfa6dbc
+  metadata.gz: 2a36f44d6923ed1978380a9c516381730313a10c97d7b8fdb4233f7cc9f8968e5478891cfc2aa490833521d7e03ac642f6b63ece421064539da133a0f623a783
+  data.tar.gz: 8e0a0482b8860043bdc0c641243646be4159cbfa533a47837d38f9ac87ae6375d961a41d8e1e57f702ee2037e6fc9a10f574f77931dda4503d2be9871bf960b4

data/README.md

@@ -20,7 +20,8 @@ Oximg.resize("in.jpg", "out.jpg", width: 750)
 Oximg.resize("in.jpg", "out.webp", width: 750, height: 500, quality: 80)
 Oximg.strip("upload.jpg", "clean.jpg")
 Oximg.probe("in.jpg")
-#=> {content_type: "image/jpeg", format: :jpeg, width: 4000, height: 3000}
+#=> {content_type: "image/jpeg", format: :jpeg, width: 4000, height: 3000,
+#    orientation: 1, display_width: 4000, display_height: 3000}
 ```
 
 A GIF source is read and probed like the others (`format: :gif`), but
@@ -66,7 +67,7 @@ cannot be read as a flag.
 ## Stripping metadata
 
 ```ruby
-Oximg.strip(source, destination, icc: nil, env: nil)
+Oximg.strip(source, destination, icc: nil, auto_rotate: nil, env: nil)
 ```
 
 Removes EXIF (GPS, camera, timestamps), XMP, IPTC and comments from a
@@ -78,6 +79,16 @@ still displays upright. `icc: :strip` also drops the colour profile.
 The default is `:keep`, or `OXIMG_ICC`. Dropping a CMYK JPEG's profile
 raises `Oximg::ProcessingError`, as do GIF and AVIF sources.
 
+`auto_rotate: true` turns a rotated JPEG upright instead, still without
+re-encoding: its compressed 8x8 blocks are moved, as `jpegtran
+-perfect` does, so the stored and displayed sizes agree for every
+reader, not only for ones that honor EXIF. That is only exact when the
+edges it moves are whole 8 or 16 px blocks (a phone's 4032x3024 is);
+otherwise, and for PNG and WebP, the file is stripped as without it,
+orientation kept. `Oximg.probe(destination)` tells which: orientation
+1, or the one kept. It costs a full entropy decode and encode, about
+170 ms for a 12 MP photo.
+
 ## Knobs, per process or per call
 
 Everything the server tunes through `OXIMG_*` environment variables
@@ -106,12 +117,21 @@ Oximg.probe(Pathname("in.jpg"))                # also a path
 Oximg.probe(upload.tempfile)                   # anything with #path
 Oximg.probe(File.open("in.jpg", "rb"))         # an open File
 Oximg.probe(StringIO.new(bytes))               # an IO: bytes in memory
-#=> {content_type: "image/jpeg", format: :jpeg, width: 4000, height: 3000}
+#=> {content_type: "image/jpeg", format: :jpeg, width: 4000, height: 3000,
+#    orientation: 1, display_width: 4000, display_height: 3000}
 ```
 
-`probe` reads the header only and decodes no pixels. The dimensions are
-the stored ones, before any EXIF rotation. A String is always a path,
-so bytes already in memory go in as a `StringIO`. An open `File` is
+`probe` reads the header only and decodes no pixels. `width` and
+`height` are the stored ones, before any EXIF rotation. `orientation`
+is the EXIF value, 1..8 (1 when there is none or it is invalid, as
+`resize` reads it), and `display_width` / `display_height` are what a
+viewer honoring it shows: the axes exchanged for 5..8. A portrait
+phone photo stored 4000x3000 with orientation 6, as `strip` leaves it,
+lays out at 3000x4000. A WebP keeps its EXIF after the image data, so
+probing one that has it reads the whole source. An `oximg` executable
+older than this gem reports every source as orientation 1.
+
+A String is always a path, so bytes already in memory go in as a `StringIO`. An open `File` is
 read from its start, its position untouched, and it is the file you
 hold that is read, even if its name has since been replaced, renamed,
 or was relative to a directory the process has left. A closed or
@@ -161,8 +181,8 @@ Oximg.in_process_probe?  #=> true on a platform gem
 
 ```ruby
 Oximg.available?  #=> true
-Oximg.executable  #=> "/…/gems/oximg-0.18.1-arm64-darwin/exe/oximg"
-Oximg.version     #=> "0.18.1"   # the binary's version, not the gem's
+Oximg.executable  #=> "/…/gems/oximg-0.19.0-arm64-darwin/exe/oximg"
+Oximg.version     #=> "0.19.0"   # the binary's version, not the gem's
 ```
 
 `resize` shells out to that binary — one process per image, which is

data/lib/oximg/native.rb

@@ -29,7 +29,7 @@ module Oximg
     BUNDLED = File.expand_path("native/#{LIBRARY}", __dir__)
 
     # The library's oximg_probe_abi_version this code was written for.
-    ABI_VERSION = 1
+    ABI_VERSION = 2
 
     # Statuses (ext/src/lib.rs).
     OK = 0
@@ -110,7 +110,8 @@ module Oximg
       end
 
       def call
-        dims = FFI::MemoryPointer.new(:uint64, 2)
+        # Stored width, stored height, orientation (ext/src/lib.rs).
+        dims = FFI::MemoryPointer.new(:uint64, 3)
         msg = FFI::MemoryPointer.new(:char, MESSAGE_BYTES)
         status = yield(dims, msg)
         return if status == READ
@@ -118,8 +119,8 @@ module Oximg
         text = msg.read_string.force_encoding(Encoding::UTF_8)
         raise ProcessingError.new(text, 1) unless status == OK
 
-        width, height = dims.read_array_of_uint64(2)
-        {content_type: text, format: CONTENT_TYPE_FORMATS[text], width: width, height: height}
+        width, height, orientation = dims.read_array_of_uint64(3)
+        Header.build(text, width, height, orientation)
       end
 
       # nil when there is no library to use. Memoized either way, so a

data/lib/oximg/version.rb

@@ -7,5 +7,5 @@ module Oximg
   # names a binary it does not carry. `Oximg.version` reports what the
   # resolved executable actually is, which can differ when it comes
   # from PATH.
-  VERSION = "0.18.1"
+  VERSION = "0.19.0"
 end

data/lib/oximg.rb

@@ -102,8 +102,12 @@ module Oximg
   # The line `oximg probe` prints (src/cli.rs):
   #
   #   in.gif: image/gif 120x90 (10800 stored pixels), 3 frames, 1500ms, looping forever
+  #   in.jpg: image/jpeg 3000x2000 (6000000 stored pixels), orientation 6 (displayed 2000x3000)
   #
-  # The three fields the gem reports are pinned exactly. Everything after
+  # The three fields the gem reports are pinned exactly, and so is the
+  # orientation, which a non-upright source prints first after the
+  # comma (its absence means 1; the displayed size is derived here from
+  # it, not read). Everything after
   # the comma — the animation summary, printed for an animated source
   # only — is information the gem does not expose, and is deliberately
   # left unparsed rather than matched: a pattern that stopped at
@@ -113,7 +117,25 @@ module Oximg
   # a field missing, a continuation without the comma, or anything
   # printed before or after it. stderr is captured separately, so a
   # warning never lands here.
-  PROBE_LINE = /\A[^\n]*: (\S+) (\d+)x(\d+) \(\d+ stored pixels\)(?:,[^\n]*)?\n?\z/
+  PROBE_LINE = /\A[^\n]*: (\S+) (\d+)x(\d+) \(\d+ stored pixels\)(?:, orientation ([1-8]) \(displayed \d+x\d+\))?(?:,[^\n]*)?\n?\z/
+
+  # The hash probe returns, built in one place for both of its paths
+  # (the in-process library and the spawned executable).
+  module Header # :nodoc:
+    def self.build(content_type, width, height, orientation)
+      # Orientations 5-8 exchange the axes on display.
+      swapped = orientation >= 5
+      {
+        content_type: content_type,
+        format: CONTENT_TYPE_FORMATS[content_type],
+        width: width,
+        height: height,
+        orientation: orientation,
+        display_width: swapped ? height : width,
+        display_height: swapped ? width : height
+      }
+    end
+  end
 
   class << self
     # Absolute path to the executable in use; raises
@@ -181,10 +203,18 @@ module Oximg
     # This is what <tt>saver(strip: true)</tt> / <tt>-strip</tt> did
     # under libvips or ImageMagick, minus the re-encode.
     #
+    # <tt>auto_rotate: true</tt> turns a rotated JPEG upright instead,
+    # still without re-encoding: the compressed 8x8 blocks are moved
+    # (what <tt>jpegtran -perfect</tt> does), so its stored and displayed
+    # dimensions agree for every reader and no orientation tag is left.
+    # That is only exact when the edges it moves are whole 8 or 16 px
+    # blocks; otherwise, and for PNG and WebP, the orientation is kept
+    # as without it. Probe the destination to see which happened.
+    #
     # +env:+ is per-call knobs, as for resize.
-    def strip(source, destination, icc: nil, env: nil)
+    def strip(source, destination, icc: nil, auto_rotate: nil, env: nil)
       output = expand(destination, "destination")
-      argv = strip_argv(source, output, icc: icc)
+      argv = strip_argv(source, output, icc: icc, auto_rotate: auto_rotate)
       Binary.run(*argv, env: knob_env(env))
       output
     end
@@ -213,15 +243,21 @@ module Oximg
 
     # The argv `strip` would run, minus the executable; public for the
     # same reason as resize_argv.
-    def strip_argv(source, destination, icc: nil)
+    def strip_argv(source, destination, icc: nil, auto_rotate: nil)
       argv = ["strip", expand(source, "source"), expand(destination, "destination")]
       argv.push("--icc", token(icc, ICC_MODES, "icc")) unless icc.nil?
+      # Off is strip's own default, so false adds nothing.
+      argv.push("--auto-rotate") if !auto_rotate.nil? && boolean(auto_rotate, "auto_rotate")
       argv
     end
 
     # Header-only inspection — no pixels are decoded. Returns
-    # <tt>{content_type:, format:, width:, height:}</tt>, where the
-    # dimensions are the stored ones (an EXIF rotation is not applied).
+    # <tt>{content_type:, format:, width:, height:, orientation:,
+    # display_width:, display_height:}</tt>. +width+ and +height+ are the
+    # stored ones; +orientation+ is the EXIF value, 1..8 (1 when there is
+    # none: the rule resize's auto-rotate applies and strip keeps), and
+    # the display size is what a viewer honoring it shows, with the axes
+    # exchanged for 5..8.
     #
     # +source+ is a path — a String, a Pathname, or anything with #path
     # such as a Tempfile — an open File, or a stream read from its
@@ -363,12 +399,7 @@ module Oximg
       match = output.match(PROBE_LINE)
       raise ProcessingError, "unparsable probe output: #{output.inspect}" unless match
 
-      {
-        content_type: match[1],
-        format: CONTENT_TYPE_FORMATS[match[1]],
-        width: Integer(match[2]),
-        height: Integer(match[3])
-      }
+      Header.build(match[1], Integer(match[2]), Integer(match[3]), match[4] ? Integer(match[4]) : 1)
     end
 
     # Absolute paths throughout: a relative name beginning with "-"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: oximg
 version: !ruby/object:Gem::Version
-  version: 0.18.1
+  version: 0.19.0
 platform: aarch64-linux-gnu
 authors:
 - oximg contributors