defmodule Pngex do
@moduledoc """
Generates PNG images.
"""
alias Pngex.{Chunk, Bitmap, Zip}
@scanline_filter_none 0
defstruct type: :rgb,
depth: :depth8,
width: 0,
height: 0,
palette: [],
scanline_filter: @scanline_filter_none
@typedoc """
PNG color type.
- `:gray` - grayscale
- `:rgb` - RGB color
- `:indexed` - palette color
- `:gray_and_alpha` - grayscale and alpha
- `:rgba` - RGB color and alpha
"""
@type color_type :: :gray | :rgb | :indexed | :gray_and_alpha | :rgba
@typedoc """
Bit depth.
- `:depth1` - 1 bits
- `:depth2` - 2 bits
- `:depth4` - 4 bits
- `:depth8` - 8 bits
- `:depth16` - 16 bits
"""
@type bit_depth :: :depth1 | :depth2 | :depth4 | :depth8 | :depth16
@typedoc """
Positive 32-bit integer.
It's for width and height.
"""
@type pos_int32 :: 1..0xFF_FF_FF_FF
@typedoc """
Data type of RGB color.
A tuple of red, green and blue values.
"""
@type rgb_color :: {r :: pos_integer(), g :: pos_integer(), b :: pos_integer()}
@typedoc """
Data type of RGB color and alpha.
A tuple of red, green, blue and alpha values.
"""
@type rgba_color ::
{r :: pos_integer(), g :: pos_integer(), b :: pos_integer(), a :: pos_integer()}
@typedoc """
Image data.
## RGB
| type | example |
|------------------|-------------------------------------|
| binary | `<<r0, g0, b0, r1, g1, b1, ...>>` |
| list of integers | `[r0, g0, b0, r1, g1, b1, ...]` |
| list of tuples | `[{r0, g0, b0}, {r1, g1, b1}, ...]` |
## RGB and Alpha
| type | example |
|------------------|---------------------------------------------|
| binary | `<<r0, g0, b0, a0, r1, g1, b1, a1, ...>>` |
| list of integers | `[r0, g0, b0, a0, r1, g1, b1, a1, ...]` |
| list of tuples | `[{r0, g0, b0, a0}, {r1, g1, b1, a1}, ...]` |
## Grayscale
| type | example |
|------------------|---------------------|
| binary | `<<c0, c1, ...>>` |
| list of integers | `[c0, c1, ...]` |
## Grayscale and Alpha
| type | example |
|------------------|-----------------------------|
| binary | `<<c0, a0, c1, a1, ...>>` |
| list of integers | `[c0, a0, c1, a1, ...]` |
## Indexed
| type | example |
|------------------|---------------------|
| binary | `<<c0, c1, ...>>` |
| list of integers | `[c0, c1, ...]` |
## Depth of binary
If you use binaries, you may need to use size options.
| depth | example |
|------------|----------------------------------------------------------|
| `:depth1` | `<<c0::size(1), c1::size(1), ...>>` |
| `:depth2` | `<<c0::size(2), c1::size(2), ...>>` |
| `:depth4` | `<<c0::size(4), c1::size(4), ...>>` |
| `:depth8` | `<<c0, c1, ...>>` or `<<c0::size(8), c1::size(8), ...>>` |
| `:depth16` | `<<c0::size(16), c1::size(16), ...>>` |
"""
@type data :: binary() | [pos_integer()] | [rgb_color()] | [rgba_color()]
@typedoc """
Type of filtering.
- `0` - None
- `1` - Sub
- `2` - Up
- `3` - Average
- `4` - Paeth
see: https://en.wikipedia.org/wiki/Portable_Network_Graphics#Filtering
"""
@type scanline_filter :: 0 | 1 | 2 | 3 | 4
@typedoc """
Configurations for PNG image.
"""
@type t :: %__MODULE__{
type: color_type(),
depth: bit_depth(),
width: pos_int32(),
height: pos_int32(),
palette: [rgb_color()],
scanline_filter: scanline_filter()
}
defguardp is_color_type(type) when type in [:gray, :rgb, :indexed, :gray_and_alpha, :rgba]
defguardp is_bit_depth(depth) when depth in [:depth1, :depth2, :depth4, :depth8, :depth16]
defguardp is_pos_int32(value) when is_integer(value) and value > 0 and value < 0x1_00_00_00_00
defguardp is_uint(n) when is_integer(n) and n >= 0
@doc false
@spec color_type_to_value(t()) :: 0 | 2 | 3 | 4 | 6
def color_type_to_value(%Pngex{type: type}) when is_color_type(type) do
case type do
:gray -> 0
:rgb -> 2
:indexed -> 3
:gray_and_alpha -> 4
:rgba -> 6
end
end
@doc false
@spec bit_depth_to_value(t()) :: 1 | 2 | 4 | 8 | 16
def bit_depth_to_value(%Pngex{depth: depth}) do
case depth do
:depth1 -> 1
:depth2 -> 2
:depth4 -> 4
:depth8 -> 8
:depth16 -> 16
end
end
@doc """
Creates a new Pngex structure.
## Options
- `:type` - color type;
- `:gray` - grayscale
- `:rgb` - RGB (default)
- `:indexed` - palette color
- `:gray_and_alpha` - grayscale and alpha
- `:rgba` - RGB and alpha
- `:depth` - color depth; `:depth2`, `:depth4`, `:depth8` (default) or `:depth16`
- `:width` - image width; 32-bit integer (1..4,294,967,295)
- `:height` - image height; 32-bit integer (1..4,294,967,295)
- `:palette` - palette table; list of RGB color tuples
## Examples
```elixir
pngex =
Pngex.new(
type: :indexed,
depth: :depth8,
width: 640,
height: 480,
palette: [{0, 0, 0}, {255, 255, 255}]
)
```
"""
@spec new(keyword()) :: t() | {:error, keyword()}
def new(opts \\ []) when is_list(opts) do
Enum.reduce(opts, %{pngex: %Pngex{}, errors: []}, fn
{:type, type}, acc when is_color_type(type) ->
%{acc | pngex: %{acc.pngex | type: type}}
{:depth, depth}, acc when is_bit_depth(depth) ->
%{acc | pngex: %{acc.pngex | depth: depth}}
{:width, width}, acc when is_pos_int32(width) ->
%{acc | pngex: %{acc.pngex | width: width}}
{:height, height}, acc when is_pos_int32(height) ->
%{acc | pngex: %{acc.pngex | height: height}}
{:palette, palette} = item, acc ->
if is_valid_palette(palette) do
%{acc | pngex: %{acc.pngex | palette: palette}}
else
%{acc | errors: [item | acc.errors]}
end
error, acc ->
%{acc | errors: [error | acc.errors]}
end)
|> case do
%{pngex: pngex, errors: []} -> pngex
%{errors: errors} -> {:error, Enum.reverse(errors)}
end
end
@doc """
Sets color type.
## Examples
```elixir
iex> Pngex.new() |> Pngex.set_type(:gray)
%Pngex{type: :gray}
```
```elixir
iex> Pngex.new() |> Pngex.set_type(:monotone)
{:error, invalid_type: :monotone}
```
"""
@spec set_type(Pngex.t(), color_type()) :: Pngex.t() | {:error, invalid_type: any()}
def set_type(%Pngex{} = pngex, type) when is_color_type(type) do
%{pngex | type: type}
end
def set_type(%Pngex{}, type) do
{:error, invalid_type: type}
end
@doc """
Sets bit depth.
## Examples
```elixir
iex> Pngex.new() |> Pngex.set_depth(:depth16)
%Pngex{depth: :depth16}
```
```elixir
iex> Pngex.new() |> Pngex.set_depth(:depth15)
{:error, invalid_depth: :depth15}
```
"""
@spec set_depth(Pngex.t(), bit_depth()) :: Pngex.t() | {:error, invalid_depth: any()}
def set_depth(%Pngex{} = pngex, depth) when is_bit_depth(depth) do
%{pngex | depth: depth}
end
def set_depth(%Pngex{}, depth) do
{:error, invalid_depth: depth}
end
@doc """
Sets image width.
## Examples
```elixir
iex> Pngex.new() |> Pngex.set_width(128)
%Pngex{width: 128}
```
```elixir
iex> Pngex.new() |> Pngex.set_width(0)
{:error, invalid_width: 0}
```
"""
@spec set_width(t(), pos_int32()) :: t() | {:error, invalid_width: any()}
def set_width(%Pngex{} = pngex, width) when is_pos_int32(width) do
%{pngex | width: width}
end
def set_width(%Pngex{}, width) do
{:error, invalid_width: width}
end
@doc """
Sets image hieght.
## Examples
```elixir
iex> Pngex.new() |> Pngex.set_height(128)
%Pngex{height: 128}
```
```elixir
iex> Pngex.new() |> Pngex.set_height(0)
{:error, invalid_height: 0}
```
"""
@spec set_height(t(), pos_int32()) :: t() | {:error, invalid_height: any()}
def set_height(%Pngex{} = pngex, height) when is_pos_int32(height) do
%{pngex | height: height}
end
def set_height(%Pngex{}, hieght) do
{:error, invalid_height: hieght}
end
@doc """
Sets image width and height.
## Examples
```elixir
iex> Pngex.new() |> Pngex.set_size(640, 480)
%Pngex{width: 640, height: 480}
```
```elixir
iex> Pngex.new() |> Pngex.set_size(0, 480)
{:error, invalid_size: %{width: 0}}
```
"""
@spec set_size(t(), pos_int32(), pos_int32()) :: t() | {:error, invalid_size: map()}
def set_size(%Pngex{} = pngex, width, height) do
case {is_pos_int32(width), is_pos_int32(height)} do
{true, true} -> %{pngex | width: width, height: height}
{false, true} -> {:error, invalid_size: %{width: width}}
{true, false} -> {:error, invalid_size: %{height: height}}
{false, false} -> {:error, invalid_size: %{width: width, height: height}}
end
end
@doc """
Sets a palette.
## Examples
```elixir
iex> Pngex.new() |> Pngex.set_palette([{0, 0, 0}, {255, 0, 0}, {0, 255, 0}, {0, 0, 255}])
%Pngex{palette: [{0, 0, 0}, {255, 0, 0}, {0, 255, 0}, {0, 0, 255}]}
```
```elixir
iex> Pngex.new() |> Pngex.set_palette([0, 0, 0, 255, 0, 0, 0, 255, 0, 0, 0, 255])
{:error, invalid_palette: [0, 0, 0, 255, 0, 0, 0, 255, 0, 0, 0, 255]}
```
"""
@spec set_palette(t(), [rgb_color()]) :: t() | {:error, invalid_palette: any()}
def set_palette(%Pngex{} = pngex, palette) do
if is_valid_palette(palette) do
%{pngex | palette: palette}
else
{:error, invalid_palette: palette}
end
end
@magic_number [0x89, "PNG", 0x0D, 0x0A, 0x1A, 0x0A]
@compression_method 0
@filter_method 0
@interlace_method 0
@doc """
Generates a PNG image.
## Examples
```elixir
image =
Pngex.new(type: :rgb, depth: :depth8, width: 16, height: 16)
|> Pngex.generate(for(c <- 0..255, do: {c, 255 - c, 0}))
File.write("image.png", image)
```
"""
@spec generate(t(), data()) :: iolist()
def generate(%Pngex{} = pngex, data) do
header = <<
pngex.width::32,
pngex.height::32,
bit_depth_to_value(pngex),
color_type_to_value(pngex),
@compression_method,
@filter_method,
@interlace_method
>>
bitmap = Bitmap.build(pngex, data)
ihdr = Chunk.build("IHDR", header)
idat = Chunk.build("IDAT", Zip.compress(bitmap))
iend = Chunk.build("IEND", "")
case pngex do
%Pngex{type: :indexed} ->
plte = Chunk.build("PLTE", for({r, g, b} <- pngex.palette, do: <<r, g, b>>))
[@magic_number, ihdr, plte, idat, iend]
_ ->
[@magic_number, ihdr, idat, iend]
end
end
defp is_valid_palette(palette) do
case palette do
[] ->
true
[{r, g, b} | rest] when is_uint(r) and is_uint(g) and is_uint(b) ->
is_valid_palette(rest)
_ ->
false
end
end
end
