image_pack 0.2.0

data/ext/image_pack/vendor/mozjpeg/yuvjpeg.c

@@ -0,0 +1,268 @@
+/*
+ * Written by Josh Aas and Tim Terriberry
+ * Copyright (c) 2013, Mozilla Corporation
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ *    this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ * 3. Neither the name of the Mozilla Corporation nor the names of its
+ *    contributors may be used to endorse or promote products derived from this
+ *    software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/* Expects 4:2:0 YCbCr */
+
+/* gcc -std=c99 yuvjpeg.c -I/opt/local/include/ -L/opt/local/lib/ -ljpeg -o yuvjpeg */
+
+#include <errno.h>
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+
+#include "jpeglib.h"
+
+void extend_edge(JSAMPLE *image, int width, int height, unsigned char *yuv,
+ int luma_width, int luma_height, int chroma_width, int chroma_height) {
+  int x;
+  int y;
+
+  for (y = 0; y < luma_height; y++) {
+    for (x = 0; x < luma_width; x++) {
+      image[width*y + x] = yuv[luma_width*y + x];
+    }
+  }
+  for (y = 0; y < chroma_height; y++) {
+    for (x = 0; x < chroma_width; x++) {
+      image[width*height + (width/2)*y + x] =
+       yuv[luma_width*luma_height + chroma_width*y + x];
+      image[width*height + (width/2)*((height/2) + y) + x] =
+       yuv[luma_width*luma_height + chroma_width*(chroma_height + y) + x];
+    }
+  }
+
+  /* Perform right edge extension. */
+  for (y = 0; y < luma_height; y++) {
+    for (x = luma_width; x < width; x++) {
+      image[width*y + x] = image[width*y + (x - 1)];
+    }
+  }
+  for (y = 0; y < chroma_height; y++) {
+    for (x = chroma_width; x < width/2; x++) {
+      image[width*height + (width/2)*y + x] =
+       image[width*height + (width/2)*y + (x - 1)];
+      image[width*height + (width/2)*((height/2) + y) + x] =
+       image[width*height + (width/2)*((height/2) + y) + (x - 1)];
+    }
+  }
+
+  /* Perform bottom edge extension. */
+  for (x = 0; x < width; x++) {
+    for (y = luma_height; y < height; y++) {
+      image[width*y + x] = image[width*(y - 1) + x];
+    }
+  }
+  for (x = 0; x < width/2; x++) {
+    for (y = chroma_height; y < height/2; y++) {
+      image[width*height + (width/2)*y + x] =
+       image[width*height + (width/2)*(y - 1) + x];
+      image[width*height + (width/2)*((height/2) + y) + x] =
+       image[width*height + (width/2)*((height/2) + (y - 1)) + x];
+    }
+  }
+}
+
+int main(int argc, char *argv[]) {
+  long quality;
+  int matches;
+  int luma_width;
+  int luma_height;
+  int chroma_width;
+  int chroma_height;
+  int frame_width;
+  int frame_height;
+  const char *yuv_path;
+  const char *jpg_path;
+  FILE *yuv_fd;
+  size_t yuv_size;
+  unsigned char *yuv_buffer;
+  JSAMPLE *jpg_buffer;
+  struct jpeg_compress_struct cinfo;
+  struct jpeg_error_mgr jerr;
+  FILE *jpg_fd;
+  JSAMPROW yrow_pointer[16];
+  JSAMPROW cbrow_pointer[8];
+  JSAMPROW crrow_pointer[8];
+  JSAMPROW *plane_pointer[3];
+  int y;
+
+  if (argc != 5) {
+    fprintf(stderr, "Required arguments:\n");
+    fprintf(stderr, "1. JPEG quality value, 0-100\n");
+    fprintf(stderr, "2. Image size (e.g. '512x512')\n");
+    fprintf(stderr, "3. Path to YUV input file\n");
+    fprintf(stderr, "4. Path to JPG output file\n");
+    return 1;
+  }
+
+  errno = 0;
+
+  quality = strtol(argv[1], NULL, 10);
+  if (errno != 0 || quality < 0 || quality > 100) {
+    fprintf(stderr, "Invalid JPEG quality value!\n");
+    return 1;
+  }
+
+  matches = sscanf(argv[2], "%dx%d", &luma_width, &luma_height);
+  if (matches != 2) {
+    fprintf(stderr, "Invalid image size input!\n");
+    return 1;
+  }
+  if (luma_width <= 0 || luma_height <= 0) {
+    fprintf(stderr, "Invalid image size input!\n");
+    return 1;
+  }
+
+  chroma_width = (luma_width + 1) >> 1;
+  chroma_height = (luma_height + 1) >> 1;
+
+  /* Will check these for validity when opening via 'fopen'. */
+  yuv_path = argv[3];
+  jpg_path = argv[4];
+
+  yuv_fd = fopen(yuv_path, "r");
+  if (!yuv_fd) {
+    fprintf(stderr, "Invalid path to YUV file!\n");
+    return 1;
+  }
+
+  fseek(yuv_fd, 0, SEEK_END);
+  yuv_size = ftell(yuv_fd);
+  fseek(yuv_fd, 0, SEEK_SET);
+
+  /* Check that the file size matches 4:2:0 yuv. */
+  if (yuv_size !=
+   (size_t)luma_width*luma_height + 2*chroma_width*chroma_height) {
+    fclose(yuv_fd);
+    fprintf(stderr, "Unexpected input format!\n");
+    return 1;
+  }
+
+  yuv_buffer = malloc(yuv_size);
+  if (!yuv_buffer) {
+    fclose(yuv_fd);
+    fprintf(stderr, "Memory allocation failure!\n");
+    return 1;
+  }
+
+  if (fread(yuv_buffer, yuv_size, 1, yuv_fd) != 1) {
+    fprintf(stderr, "Error reading yuv file\n");
+  };
+
+  fclose(yuv_fd);
+
+  frame_width = (luma_width + (16 - 1)) & ~(16 - 1);
+  frame_height = (luma_height + (16 - 1)) & ~(16 - 1);
+
+  jpg_buffer =
+   malloc(frame_width*frame_height + 2*(frame_width/2)*(frame_height/2));
+  if (!jpg_buffer) {
+    free(yuv_buffer);
+    fprintf(stderr, "Memory allocation failure!\n");
+    return 1;
+  }
+
+  extend_edge(jpg_buffer, frame_width, frame_height,
+   yuv_buffer, luma_width, luma_height, chroma_width, chroma_height);
+
+  free(yuv_buffer);
+
+  cinfo.err = jpeg_std_error(&jerr);
+  jpeg_create_compress(&cinfo);
+
+  jpg_fd = fopen(jpg_path, "wb");
+  if (!jpg_fd) {    
+    free(jpg_buffer);
+    fprintf(stderr, "Invalid path to JPEG file!\n");
+    return 1;
+  }
+
+  jpeg_stdio_dest(&cinfo, jpg_fd);
+
+  cinfo.image_width = luma_width;
+  cinfo.image_height = luma_height;
+  cinfo.input_components = 3;
+
+  cinfo.in_color_space = JCS_YCbCr;
+  jpeg_set_defaults(&cinfo);
+
+  cinfo.raw_data_in = TRUE;
+
+  cinfo.comp_info[0].h_samp_factor = 2;
+  cinfo.comp_info[0].v_samp_factor = 2;
+  cinfo.comp_info[0].dc_tbl_no = 0;
+  cinfo.comp_info[0].ac_tbl_no = 0;
+  cinfo.comp_info[0].quant_tbl_no = 0;
+
+  cinfo.comp_info[1].h_samp_factor = 1;
+  cinfo.comp_info[1].v_samp_factor = 1;
+  cinfo.comp_info[1].dc_tbl_no = 1;
+  cinfo.comp_info[1].ac_tbl_no = 1;
+  cinfo.comp_info[1].quant_tbl_no = 1;
+
+  cinfo.comp_info[2].h_samp_factor = 1;
+  cinfo.comp_info[2].v_samp_factor = 1;
+  cinfo.comp_info[2].dc_tbl_no = 1;
+  cinfo.comp_info[2].ac_tbl_no = 1;
+  cinfo.comp_info[2].quant_tbl_no = 1;
+
+  jpeg_set_quality(&cinfo, quality, TRUE);
+  cinfo.optimize_coding = TRUE;
+
+  jpeg_start_compress(&cinfo, TRUE);
+
+  plane_pointer[0] = yrow_pointer;
+  plane_pointer[1] = cbrow_pointer;
+  plane_pointer[2] = crrow_pointer;
+
+  while (cinfo.next_scanline < cinfo.image_height) {
+    int scanline;
+    scanline = cinfo.next_scanline;
+
+    for (y = 0; y < 16; y++) {
+      yrow_pointer[y] = &jpg_buffer[frame_width*(scanline + y)];
+    }
+    for (y = 0; y < 8; y++) {
+      cbrow_pointer[y] = &jpg_buffer[frame_width*frame_height +
+       (frame_width/2)*((scanline/2) + y)];
+      crrow_pointer[y] = &jpg_buffer[frame_width*frame_height +
+       (frame_width/2)*(frame_height/2) + (frame_width/2)*((scanline/2) + y)];
+    }
+    jpeg_write_raw_data(&cinfo, plane_pointer, 16);
+  }
+
+  jpeg_finish_compress(&cinfo);
+  jpeg_destroy_compress(&cinfo);
+
+  free(jpg_buffer);
+  fclose(jpg_fd);
+
+  return 0;
+}

data/lib/image_pack/backend.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module ImagePack
+  module Backend
+    JPEG_TURBO = :jpeg_turbo
+    MOZJPEG = :mozjpeg
+  end
+end

data/lib/image_pack/configuration.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module ImagePack
+  class Configuration
+    attr_accessor :execution,
+                  :direct_input_threshold,
+                  :direct_pixel_threshold,
+                  :max_pixels,
+                  :max_width,
+                  :max_height,
+                  :max_output_size
+
+    def initialize
+      @execution              = :auto
+      @direct_input_threshold = 128 * 1024
+      @direct_pixel_threshold = 1 * 1024 * 1024
+      @max_pixels             = 100_000_000
+      @max_width              = 30_000
+      @max_height             = 30_000
+      @max_output_size        = 256 * 1024 * 1024
+    end
+  end
+end

data/lib/image_pack/errors.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module ImagePack
+  class Error < StandardError; end
+  class InvalidArgumentError < Error; end
+  class InvalidImageError < Error; end
+  class UnsupportedError < Error; end
+  class LimitExceededError < Error; end
+  class EncodeError < Error; end
+  class QualityConstraintError < Error; end
+  class OutOfMemoryError < Error; end
+  class CancelledError < Error; end
+end

data/lib/image_pack/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module ImagePack
+  VERSION = "0.2.0"
+end

data/lib/image_pack.rb

@@ -0,0 +1,208 @@
+# frozen_string_literal: true
+
+required = Gem::Version.new("3.4.0")
+current  = Gem::Version.new(RUBY_VERSION)
+
+if current < required
+  raise LoadError,
+        "image_pack requires Ruby >= 3.4.0, got #{RUBY_VERSION}. " \
+        "Reason: gem relies on RB_NOGVL_OFFLOAD_SAFE / Fiber::Scheduler hooks."
+end
+
+require "pathname"
+require_relative "image_pack/version"
+require_relative "image_pack/errors"
+require_relative "image_pack/configuration"
+require_relative "image_pack/backend"
+
+begin
+  require "image_pack/image_pack"
+rescue LoadError
+  ext_dir = File.expand_path("image_pack", __dir__)
+  so_path = %w[.bundle .so .dll]
+    .map { |ext| File.join(ext_dir, "image_pack#{ext}") }
+    .find { |path| File.file?(path) }
+
+  raise LoadError, "Could not find compiled ImagePack extension. Run: bundle exec rake compile" unless so_path
+
+  require so_path
+end
+
+module ImagePack
+  ALGOS = %i[jpeg_turbo mozjpeg].freeze
+  EXECUTION_MODES = %i[direct nogvl offload auto].freeze
+  DEFAULT_QUALITY = 82
+
+  class << self
+    def configuration
+      @configuration ||= Configuration.new
+    end
+
+    def configure
+      return configuration unless block_given?
+
+      yield(configuration)
+      configuration
+    end
+
+    def compress(input,
+                 output: nil,
+                 algo: :jpeg_turbo,
+                 quality: nil,
+                 min_ssim: nil,
+                 mozjpeg_trellis: true,
+                 progressive: false,
+                 strip_metadata: true,
+                 execution: nil,
+                 cancellable: false)
+      validate_algo!(algo)
+      validate_min_ssim!(min_ssim)
+      validate_mozjpeg_trellis!(mozjpeg_trellis)
+      quality_was_given = !quality.nil?
+      effective_quality = quality_was_given ? quality : DEFAULT_QUALITY
+      effective_quality = 1 if min_ssim && !quality_was_given
+      validate_quality!(effective_quality)
+      execution ||= configuration.execution
+      validate_execution!(execution)
+      validate_cancellable!(algo, execution, cancellable)
+
+      normalized_input_kind = input_kind!(input)
+      normalized_output_kind = output_kind!(output)
+      has_scheduler = fiber_scheduler_active?
+
+      __compress_jpeg(input, normalized_input_kind,
+                      output, normalized_output_kind,
+                      algo, effective_quality.to_i,
+                      min_ssim ? min_ssim.to_f : 0.0,
+                      mozjpeg_trellis ? 1 : 0,
+                      progressive ? 1 : 0,
+                      strip_metadata ? 1 : 0,
+                      execution,
+                      cancellable ? 1 : 0,
+                      has_scheduler ? 1 : 0)
+    end
+
+    def compress_pixels(buffer,
+                        width:,
+                        height:,
+                        channels:,
+                        output: nil,
+                        algo: :jpeg_turbo,
+                        quality: DEFAULT_QUALITY,
+                        progressive: false,
+                        execution: nil,
+                        cancellable: false)
+      validate_algo!(algo)
+      validate_quality!(quality)
+      validate_dimensions!(width, height, channels)
+      execution ||= configuration.execution
+      validate_execution!(execution)
+      validate_cancellable!(algo, execution, cancellable)
+
+      normalized_output_kind = output_kind!(output)
+      has_scheduler = fiber_scheduler_active?
+
+      __compress_pixels(buffer,
+                        width.to_i, height.to_i, channels.to_i,
+                        output, normalized_output_kind,
+                        algo, quality.to_i,
+                        progressive ? 1 : 0,
+                        execution,
+                        cancellable ? 1 : 0,
+                        has_scheduler ? 1 : 0)
+    end
+
+    def inspect_image(input)
+      __inspect_image(input, input_kind!(input))
+    end
+
+    private
+
+    def input_kind!(input)
+      case input
+      when String
+        if input.encoding == Encoding::BINARY || input.encoding == Encoding::ASCII_8BIT
+          :bytes
+        else
+          raise InvalidArgumentError, "input path does not exist: #{input.inspect}" unless File.file?(input)
+
+          :path
+        end
+      when Pathname
+        raise InvalidArgumentError, "input path does not exist: #{input}" unless input.file?
+
+        :path
+      else
+        if defined?(IO::Buffer) && input.is_a?(IO::Buffer)
+          :io_buffer
+        else
+          raise InvalidArgumentError,
+                "input must be binary String bytes, path String, Pathname, or IO::Buffer"
+        end
+      end
+    end
+
+    def output_kind!(output)
+      return :return_string if output.nil?
+      return :path if output.is_a?(String) || output.is_a?(Pathname)
+
+      raise InvalidArgumentError, "output must be nil, String path, or Pathname in v0.2.0"
+    end
+
+    def validate_algo!(algo)
+      return if ALGOS.include?(algo)
+
+      raise InvalidArgumentError, "algo must be one of #{ALGOS}, got: #{algo.inspect}"
+    end
+
+    def validate_quality!(quality)
+      return if quality.is_a?(Integer) && quality.between?(1, 100)
+
+      raise InvalidArgumentError, "quality must be Integer 1..100, got: #{quality.inspect}"
+    end
+
+    def validate_min_ssim!(min_ssim)
+      return if min_ssim.nil?
+      return if min_ssim.is_a?(Numeric) && min_ssim.positive? && min_ssim <= 1.0
+
+      raise InvalidArgumentError, "min_ssim must be Numeric > 0.0 and <= 1.0, got: #{min_ssim.inspect}"
+    end
+
+
+    def validate_mozjpeg_trellis!(value)
+      return if value == true || value == false
+
+      raise InvalidArgumentError, "mozjpeg_trellis must be true or false, got: #{value.inspect}"
+    end
+
+    def validate_execution!(execution)
+      return if EXECUTION_MODES.include?(execution)
+
+      raise InvalidArgumentError, "execution must be one of #{EXECUTION_MODES}, got: #{execution.inspect}"
+    end
+
+    def validate_dimensions!(width, height, channels)
+      raise InvalidArgumentError, "width must be > 0" unless width.is_a?(Integer) && width.positive?
+      raise InvalidArgumentError, "height must be > 0" unless height.is_a?(Integer) && height.positive?
+      raise InvalidArgumentError, "channels must be 1, 3 or 4" unless [1, 3, 4].include?(channels)
+    end
+
+    def validate_cancellable!(algo, execution, cancellable)
+      return unless cancellable
+
+      if algo == :jpeg_turbo
+        raise InvalidArgumentError,
+              "cancellable: true is only supported with algo: :mozjpeg in v0.2.0"
+      end
+
+      return unless execution == :direct
+
+      raise InvalidArgumentError,
+            "cancellable: true requires execution: :nogvl, :offload, or :auto"
+    end
+
+    def fiber_scheduler_active?
+      Fiber.respond_to?(:scheduler) && !Fiber.scheduler.nil?
+    end
+  end
+end