defmodule Exexif do
@moduledoc """
Read TIFF and EXIF information from a JPEG-format image.
iex> {:ok, info} = Exexif.exif_from_jpeg_buffer(buffer)
iex> info.x_resolution
72
iex> info.model
"DSC-RX100M2"
...> Exexif.Data.Gps.inspect info
"41°23´16˝N,2°11´50˝E"
"""
alias Exexif.{Decode, Tag}
alias Exexif.Data.{Gps, Thumbnail}
@type t :: %{
:brightness_value => float(),
:color_space => binary(),
:component_configuration => binary(),
:compressed_bits_per_pixel => non_neg_integer(),
:contrast => binary(),
:custom_rendered => binary(),
:datetime_digitized => binary(),
:datetime_original => binary(),
:digital_zoom_ratio => non_neg_integer(),
:exif_image_height => non_neg_integer(),
:exif_image_width => non_neg_integer(),
:exif_version => binary(),
:exposure_mode => binary(),
:exposure_bias_value => non_neg_integer(),
:exposure_program => binary(),
:exposure_time => binary(),
:f_number => non_neg_integer(),
:file_source => binary(),
:flash => binary(),
:flash_pix_version => binary(),
:focal_length_in_35mm_film => non_neg_integer(),
:focal_length => float(),
:iso_speed_ratings => non_neg_integer(),
:lens_info => [float()],
:light_source => non_neg_integer(),
:max_aperture_value => float(),
:metering_mode => binary(),
:recommended_exposure => non_neg_integer(),
:saturation => binary(),
:scene_capture_type => binary(),
:scene_type => binary(),
:sensitivity_type => binary(),
:sharpness => binary(),
:white_balance => binary()
}
# <<_::32>>
@type value :: binary()
@type context :: {value(), non_neg_integer(), (any() -> non_neg_integer())}
@max_exif_len 2 * (65_536 + 2)
@image_start_marker 0xFFD8
# @image_end_marker 0xffd9 # NOT USED
@app1_marker 0xFFE1
@spec exif_from_jpeg_file(binary()) ::
{:error, :no_exif_data_in_jpeg | :not_a_jpeg_file | :file.posix()}
| {:ok, %{exif: t()}}
@doc "Extracts EXIF from jpeg file"
def exif_from_jpeg_file(name) when is_binary(name) do
with {:ok, buffer} <- File.open(name, [:read], &IO.binread(&1, @max_exif_len)),
do: exif_from_jpeg_buffer(buffer)
end
@doc "Extracts EXIF from jpeg file, raises on any error"
@spec exif_from_jpeg_file!(binary()) :: %{exif: t()} | no_return()
def exif_from_jpeg_file!(name) when is_binary(name) do
case exif_from_jpeg_file(name) do
{:ok, result} -> result
{:error, error} -> raise(Exexif.ReadError, type: error, file: name)
end
end
@spec exif_from_jpeg_buffer(binary()) ::
{:error, :no_exif_data_in_jpeg | :not_a_jpeg_file} | {:ok, %{exif: t()}}
@doc "Extracts EXIF from binary buffer"
def exif_from_jpeg_buffer(<<@image_start_marker::16, rest::binary>>),
do: read_exif(rest)
def exif_from_jpeg_buffer(_), do: {:error, :not_a_jpeg_file}
@spec exif_from_jpeg_buffer!(binary()) :: %{exif: t()} | no_return()
@doc "Extracts EXIF from binary buffer, raises on any error"
def exif_from_jpeg_buffer!(buffer) do
case exif_from_jpeg_buffer(buffer) do
{:ok, result} -> result
{:error, error} -> raise Exexif.ReadError, type: error, file: nil
end
end
@spec read_exif(binary()) :: {:error, :no_exif_data_in_jpeg} | {:ok, %{exif: t()}}
def read_exif(<<
@app1_marker::16,
_len::16,
"Exif"::binary,
0::16,
exif::binary
>>) do
<<
byte_order::16,
forty_two::binary-size(2),
offset::binary-size(4),
_rest::binary
>> = exif
endian =
case byte_order do
0x4949 -> :little
0x4D4D -> :big
end
read_unsigned = &:binary.decode_unsigned(&1, endian)
# sanity check
42 = read_unsigned.(forty_two)
offset = read_unsigned.(offset)
{:ok, reshape(read_ifd({exif, offset, read_unsigned}))}
end
def read_exif(<<0xFF::8, _number::8, len::16, data::binary>>) do
(len - 2)
|> skip_segment(data)
|> read_exif()
end
def read_exif(_), do: {:error, :no_exif_data_in_jpeg}
@spec skip_segment(len :: non_neg_integer(), data :: binary()) :: binary()
defp skip_segment(len, data) do
<<_segment::size(len)-unit(8), rest::binary>> = data
rest
end
@spec read_ifd(context :: context()) :: map()
defp read_ifd({exif, offset, ru} = context) do
case exif do
<<_::binary-size(offset), tag_count::binary-size(2), tags::binary>> ->
read_tags(ru.(tag_count), tags, context, :tiff, [])
_ ->
%{}
end
end
@spec read_tags(non_neg_integer(), binary(), context(), any(), any()) :: map()
defp read_tags(0, _tags, _context, _type, result), do: Map.new(result)
defp read_tags(
count,
<<
tag::binary-size(2),
format::binary-size(2),
component_count::binary-size(4),
value::binary-size(4),
rest::binary
>>,
{_exif, _offset, ru} = context,
type,
result
) do
tag = ru.(tag)
format = ru.(format)
component_count = ru.(component_count)
value = Tag.value(format, component_count, value, context)
{name, description} = Decode.tag(type, tag, value)
kv =
case name do
:exif -> {:exif, read_exif(value, context)}
:gps -> {:gps, read_gps(value, context)}
_ -> {name, description}
end
read_tags(count - 1, rest, context, type, [kv | result])
end
# Handle malformed data
defp read_tags(_, _, _, _, result), do: Map.new(result)
def read_exif(exif_offset, {exif, _offset, ru} = context) do
<<_::binary-size(exif_offset), count::binary-size(2), tags::binary>> = exif
count = ru.(count)
read_tags(count, tags, context, :exif, [])
end
@spec read_gps(non_neg_integer(), context()) :: %Gps{}
defp read_gps(gps_offset, {gps, _offset, ru} = context) do
case gps do
<<_::binary-size(gps_offset), count::binary-size(2), tags::binary>> ->
struct(Gps, read_tags(ru.(count), tags, context, :gps, []))
_ ->
%Gps{}
end
end
@spec reshape(%{exif: t()} | map()) :: %{exif: t()} | map()
defp reshape(%{exif: %{} = _} = result), do: extract_thumbnail(result)
defp reshape(result), do: result
@spec extract_thumbnail(%{exif: t()}) :: %{exif: t()}
defp extract_thumbnail(%{exif: exif} = result) do
exif_keys = Map.keys(exif)
result =
if Enum.all?(Thumbnail.fields(), fn e -> Enum.any?(exif_keys, &(&1 == e)) end) do
Map.put(
result,
:thumbnail,
struct(
Thumbnail,
Thumbnail.fields()
|> Enum.map(fn e -> {e, exif[e]} end)
|> Enum.into(%{})
)
)
else
result
end
%{result | exif: Map.drop(exif, Thumbnail.fields())}
end
end
