Adds native code to dialyzer ignore

Unfortunately we have very little control over that code so we are required to
ignore the native code.

Author: adkron

dialyzer.ignore-warnings

@@ -0,0 +1,3 @@
+[
+  {"lib/turbojpeg/native.ex"}
+]

dialyzer.ignore-warnings.exs

@@ -22,7 +22,6 @@ defmodule Turbojpeg do
 
   @spec yuv_to_jpeg(Shmex.t(), width, height, quality, format) ::
           {:ok, Shmex.t()} | error()
-
   def yuv_to_jpeg(yuv, width, height, quality, format) do
     Native.yuv_to_jpeg(yuv, width, height, quality, format)
   rescue
@@ -32,7 +31,6 @@ defmodule Turbojpeg do
 
   @spec jpeg_to_yuv(Shmex.t()) ::
           {:ok, Shmex.t()} | error()
-
   def jpeg_to_yuv(jpeg) do
     Native.jpeg_to_yuv(jpeg)
   rescue

lib/turbojpeg.ex

@@ -18,7 +18,7 @@ defmodule Turbojpeg.MixProject do
       docs: docs(),
       deps: deps(),
       dialyzer: [
-        ignore_warnings: "dialyzer.ignore-warnings"
+        ignore_warnings: "dialyzer.ignore-warnings.exs"
       ]
     ]
   end

mix.exs

@@ -1,6 +1,6 @@
 defmodule TurbojpegTest do
   use ExUnit.Case
-  use PropCheck, default_opts: [numtests: 10]
+  use PropCheck, numtests: 10
   use Mogrify.Options
 
   @jpeg_header <<255, 216, 255>>
@@ -10,52 +10,52 @@ defmodule TurbojpegTest do
   test "Converts an i420 frame into a jpeg" do
     frame = File.read!(@i420_fixture)
     shmex = Shmex.new(frame)
-    {:ok, jpeg} = Turbojpeg.Native.yuv_to_jpeg(shmex, 1920, 1080, 100, :I420)
+    {:ok, jpeg} = Turbojpeg.yuv_to_jpeg(shmex, 1920, 1080, 100, :I420)
     assert match?(@jpeg_header <> _, Shmex.to_binary(jpeg))
   end
 
   test "extracts i444 frame from jpeg" do
     jpeg = Shmex.new(File.read!(@ff0000_fixture))
-    {:ok, yuv} = Turbojpeg.Native.jpeg_to_yuv(jpeg)
-    {:ok, new_jpeg} = Turbojpeg.Native.yuv_to_jpeg(yuv, 64, 64, 100, :I444)
+    {:ok, yuv} = Turbojpeg.jpeg_to_yuv(jpeg)
+    {:ok, new_jpeg} = Turbojpeg.yuv_to_jpeg(yuv, 64, 64, 100, :I444)
     assert Shmex.to_binary(jpeg) == Shmex.to_binary(new_jpeg)
   end
 
   test "get jpeg header" do
     jpeg = Shmex.new(File.read!(@ff0000_fixture))
-    {:ok, result} = Turbojpeg.Native.get_jpeg_header(jpeg)
+    {:ok, result} = Turbojpeg.get_jpeg_header(jpeg)
     assert result.width == 64
     assert result.height == 64
     assert result.format == :I444
   end
 
-  @tag [timeout: :infinity]
-  property "encoding an image is fast", numtests: 8 do
+  @tag [timeout: :timer.minutes(2)]
+  property "encoding an image is fast", numtests: 5 do
     forall [width, height] <- [
              width(100),
              height(100)
            ] do
-      {jpeg_creation_micros, jpeg} =
-        :timer.tc(fn ->
-          jpeg =
-            %Mogrify.Image{}
-            |> Mogrify.custom("size", "#{width}x#{height}")
-            |> Mogrify.custom("seed", 43)
-            |> Mogrify.custom("plasma", "fractal")
-            |> Mogrify.custom("sampling-factor", "4:4:4")
-            |> Mogrify.custom("stdout", "jpg:-")
-            |> Mogrify.create(buffer: true)
-
-          Shmex.new(jpeg.buffer)
-        end)
-
-      {_native_micros, ret} =
-        :timer.tc(fn ->
-          Turbojpeg.Native.jpeg_to_yuv(jpeg)
-        end)
+      jpeg =
+        %Mogrify.Image{}
+        |> Mogrify.custom("size", "#{width}x#{height}")
+        |> Mogrify.custom("seed", 43)
+        |> Mogrify.custom("plasma", "fractal")
+        |> Mogrify.custom("sampling-factor", "4:4:4")
+        |> Mogrify.custom("stdout", "jpg:-")
+        |> Mogrify.create(buffer: true)
 
+      Shmex.new(jpeg.buffer)
+
+      ret = Turbojpeg.jpeg_to_yuv(jpeg)
+
+      # Only for local runs
+      # {time_micros, ret} =
+      #   :timer.tc(fn ->
+      #     Turbojpeg.jpeg_to_yuv(jpeg)
+      #   end)
+
+      # assert time_micros / 1000 <= 5000
       assert match?({:ok, _}, ret)
-      aggregate(true, result: {to_range(10, jpeg_creation_micros), to_range(1024, jpeg.size)})
     end
   end
 
@@ -79,31 +79,25 @@ defmodule TurbojpegTest do
         |> Mogrify.create(buffer: true)
 
       jpeg = Shmex.new(jpeg.buffer)
-      {:ok, yuv} = Turbojpeg.Native.jpeg_to_yuv(jpeg)
+      {:ok, yuv} = Turbojpeg.jpeg_to_yuv(jpeg)
 
-      {:ok, original_header} = Turbojpeg.Native.get_jpeg_header(jpeg)
+      {:ok, original_header} = Turbojpeg.get_jpeg_header(jpeg)
 
-      {:ok, new_jpeg} =
-        Turbojpeg.Native.yuv_to_jpeg(yuv, width, height, 100, original_header.format)
+      {:ok, new_jpeg} = Turbojpeg.yuv_to_jpeg(yuv, width, height, 100, original_header.format)
 
-      {:ok, new_header} = Turbojpeg.Native.get_jpeg_header(new_jpeg)
+      {:ok, new_header} = Turbojpeg.get_jpeg_header(new_jpeg)
 
       assert original_header == new_header
-
-      aggregate(true,
-        r: to_range(51, r),
-        g: to_range(51, g),
-        b: to_range(51, b)
-      )
     end
   end
 
   property "jpeg and yuv conversion are complementary after running through the tool once" do
-    forall [width, height, seed, {sampling_factor, format}] <- [
+    forall [width, height, seed, {sampling_factor, format}, quality] <- [
              width(),
              height(),
              seed(),
-             format()
+             format(),
+             integer(0, 100)
            ] do
       jpeg =
         %Mogrify.Image{}
@@ -115,16 +109,11 @@ defmodule TurbojpegTest do
         |> Mogrify.create(buffer: true)
 
       jpeg = Shmex.new(jpeg.buffer)
-      {:ok, yuv} = Turbojpeg.Native.jpeg_to_yuv(jpeg)
-      {:ok, new_jpeg} = Turbojpeg.Native.yuv_to_jpeg(yuv, width, height, 100, format)
-      {:ok, original_header} = Turbojpeg.Native.get_jpeg_header(jpeg)
-      {:ok, new_header} = Turbojpeg.Native.get_jpeg_header(new_jpeg)
+      {:ok, yuv} = Turbojpeg.jpeg_to_yuv(jpeg)
+      {:ok, new_jpeg} = Turbojpeg.yuv_to_jpeg(yuv, width, height, quality, format)
+      {:ok, original_header} = Turbojpeg.get_jpeg_header(jpeg)
+      {:ok, new_header} = Turbojpeg.get_jpeg_header(new_jpeg)
       assert original_header == new_header
-
-      aggregate(true,
-        size: to_range(10_000, width * height) |> as_bytes(1024),
-        width: to_range(10, width)
-      )
     end
   end
 
@@ -137,11 +126,11 @@ defmodule TurbojpegTest do
     {div(min, size), div(max, size)}
   end
 
-  def width(multiplier \\ 50) do
+  def width(multiplier \\ 10) do
     dimension(multiplier)
   end
 
-  def height(multiplier \\ 50) do
+  def height(multiplier \\ 10) do
     dimension(multiplier)
   end