{-# LANGUAGE CPP #-}
{-# LANGUAGE GADTs #-}
{-# LANGUAGE OverloadedStrings #-}
module Codec.Picture.Png.Internal.Metadata( extractMetadatas
                                 , encodeMetadatas
                                 ) where

#if !MIN_VERSION_base(4,8,0)
import Control.Applicative( (<$>), (<*>), pure )
import Data.Monoid( Monoid, mempty )
import Data.Foldable( foldMap )
#endif

import Data.Maybe( fromMaybe )
import Data.Binary( Binary( get, put ), encode )
import Data.Binary.Get( getLazyByteStringNul, getWord8 )
import Data.Binary.Put( putLazyByteString, putWord8 )
import qualified Data.ByteString.Lazy.Char8 as L
#if !MIN_VERSION_base(4,11,0)
import Data.Monoid( (<>) )
#endif

import qualified Codec.Compression.Zlib as Z

import Codec.Picture.InternalHelper
import qualified Codec.Picture.Metadata as Met
import Codec.Picture.Metadata ( Metadatas
                              , dotsPerMeterToDotPerInch
                              , Elem( (:=>) ) )
import Codec.Picture.Png.Internal.Type

#if !MIN_VERSION_base(4,7,0)
eitherFoldMap :: Monoid m => (a -> m) -> Either e a -> m
eitherFoldMap f v = case v of
  Left _ -> mempty
  Right a -> f a
#else
eitherFoldMap :: Monoid m => (a -> m) -> Either e a -> m
eitherFoldMap :: forall m a e. Monoid m => (a -> m) -> Either e a -> m
eitherFoldMap = (a -> m) -> Either e a -> m
forall m a. Monoid m => (a -> m) -> Either e a -> m
forall (t :: * -> *) m a.
(Foldable t, Monoid m) =>
(a -> m) -> t a -> m
foldMap
#endif

getGamma :: [L.ByteString] -> Metadatas
getGamma :: [ByteString] -> Metadatas
getGamma [] = Metadatas
forall a. Monoid a => a
mempty
getGamma (ByteString
g:[ByteString]
_) = (PngGamma -> Metadatas) -> Either String PngGamma -> Metadatas
forall m a e. Monoid m => (a -> m) -> Either e a -> m
eitherFoldMap PngGamma -> Metadatas
unpackGamma (Either String PngGamma -> Metadatas)
-> Either String PngGamma -> Metadatas
forall a b. (a -> b) -> a -> b
$ Get PngGamma -> ByteString -> Either String PngGamma
forall a. Get a -> ByteString -> Either String a
runGet Get PngGamma
forall t. Binary t => Get t
get ByteString
g
  where
    unpackGamma :: PngGamma -> Metadatas
unpackGamma PngGamma
gamma = Keys Double -> Double -> Metadatas
forall a. (Show a, NFData a) => Keys a -> a -> Metadatas
Met.singleton Keys Double
Met.Gamma (PngGamma -> Double
getPngGamma PngGamma
gamma)

getDpis :: [L.ByteString] -> Metadatas
getDpis :: [ByteString] -> Metadatas
getDpis [] = Metadatas
forall a. Monoid a => a
mempty
getDpis (ByteString
b:[ByteString]
_) = (PngPhysicalDimension -> Metadatas)
-> Either String PngPhysicalDimension -> Metadatas
forall m a e. Monoid m => (a -> m) -> Either e a -> m
eitherFoldMap PngPhysicalDimension -> Metadatas
unpackPhys (Either String PngPhysicalDimension -> Metadatas)
-> Either String PngPhysicalDimension -> Metadatas
forall a b. (a -> b) -> a -> b
$ Get PngPhysicalDimension
-> ByteString -> Either String PngPhysicalDimension
forall a. Get a -> ByteString -> Either String a
runGet Get PngPhysicalDimension
forall t. Binary t => Get t
get ByteString
b
  where
    unpackPhys :: PngPhysicalDimension -> Metadatas
unpackPhys PngPhysicalDimension { pngUnit :: PngPhysicalDimension -> PngUnit
pngUnit = PngUnit
PngUnitUnknown } =
      Keys Word -> Word -> Metadatas -> Metadatas
forall a.
(Show a, NFData a) =>
Keys a -> a -> Metadatas -> Metadatas
Met.insert Keys Word
Met.DpiX Word
72 (Metadatas -> Metadatas) -> Metadatas -> Metadatas
forall a b. (a -> b) -> a -> b
$ Keys Word -> Word -> Metadatas
forall a. (Show a, NFData a) => Keys a -> a -> Metadatas
Met.singleton Keys Word
Met.DpiY Word
72
    unpackPhys phy :: PngPhysicalDimension
phy@PngPhysicalDimension { pngUnit :: PngPhysicalDimension -> PngUnit
pngUnit = PngUnit
PngUnitMeter } =
      Keys Word -> Word -> Metadatas -> Metadatas
forall a.
(Show a, NFData a) =>
Keys a -> a -> Metadatas -> Metadatas
Met.insert Keys Word
Met.DpiX Word
dpx (Metadatas -> Metadatas) -> Metadatas -> Metadatas
forall a b. (a -> b) -> a -> b
$ Keys Word -> Word -> Metadatas
forall a. (Show a, NFData a) => Keys a -> a -> Metadatas
Met.singleton Keys Word
Met.DpiY Word
dpy
        where
          dpx :: Word
dpx = Word -> Word
dotsPerMeterToDotPerInch (Word -> Word) -> (Word32 -> Word) -> Word32 -> Word
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Word32 -> Word
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Word32 -> Word) -> Word32 -> Word
forall a b. (a -> b) -> a -> b
$ PngPhysicalDimension -> Word32
pngDpiX PngPhysicalDimension
phy
          dpy :: Word
dpy = Word -> Word
dotsPerMeterToDotPerInch (Word -> Word) -> (Word32 -> Word) -> Word32 -> Word
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Word32 -> Word
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Word32 -> Word) -> Word32 -> Word
forall a b. (a -> b) -> a -> b
$ PngPhysicalDimension -> Word32
pngDpiY PngPhysicalDimension
phy

data PngText = PngText
  { PngText -> ByteString
pngKeyword :: !L.ByteString
  , PngText -> ByteString
pngData    :: !L.ByteString
  }
  deriving Int -> PngText -> ShowS
[PngText] -> ShowS
PngText -> String
(Int -> PngText -> ShowS)
-> (PngText -> String) -> ([PngText] -> ShowS) -> Show PngText
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> PngText -> ShowS
showsPrec :: Int -> PngText -> ShowS
$cshow :: PngText -> String
show :: PngText -> String
$cshowList :: [PngText] -> ShowS
showList :: [PngText] -> ShowS
Show

instance Binary PngText where
  get :: Get PngText
get = ByteString -> ByteString -> PngText
PngText (ByteString -> ByteString -> PngText)
-> Get ByteString -> Get (ByteString -> PngText)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Get ByteString
getLazyByteStringNul Get (ByteString -> PngText) -> Get ByteString -> Get PngText
forall a b. Get (a -> b) -> Get a -> Get b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Get ByteString
getRemainingLazyBytes
  put :: PngText -> Put
put (PngText ByteString
kw ByteString
pdata) = do
    ByteString -> Put
putLazyByteString ByteString
kw
    Word8 -> Put
putWord8 Word8
0
    ByteString -> Put
putLazyByteString ByteString
pdata

data PngZText = PngZText
  { PngZText -> ByteString
pngZKeyword :: !L.ByteString
  , PngZText -> ByteString
pngZData    :: !L.ByteString
  }
  deriving Int -> PngZText -> ShowS
[PngZText] -> ShowS
PngZText -> String
(Int -> PngZText -> ShowS)
-> (PngZText -> String) -> ([PngZText] -> ShowS) -> Show PngZText
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> PngZText -> ShowS
showsPrec :: Int -> PngZText -> ShowS
$cshow :: PngZText -> String
show :: PngZText -> String
$cshowList :: [PngZText] -> ShowS
showList :: [PngZText] -> ShowS
Show

instance Binary PngZText where
  get :: Get PngZText
get = ByteString -> ByteString -> PngZText
PngZText (ByteString -> ByteString -> PngZText)
-> Get ByteString -> Get (ByteString -> PngZText)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Get ByteString
getLazyByteStringNul Get (ByteString -> PngZText)
-> Get () -> Get (ByteString -> PngZText)
forall a b. Get a -> Get b -> Get a
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* Get ()
getCompressionType Get (ByteString -> PngZText) -> Get ByteString -> Get PngZText
forall a b. Get (a -> b) -> Get a -> Get b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (ByteString -> ByteString
Z.decompress (ByteString -> ByteString) -> Get ByteString -> Get ByteString
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Get ByteString
getRemainingLazyBytes)
    where
      getCompressionType :: Get ()
getCompressionType = do
        Word8
0 <- Get Word8
getWord8
        () -> Get ()
forall a. a -> Get a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
  put :: PngZText -> Put
put (PngZText ByteString
kw ByteString
pdata) = do
    ByteString -> Put
putLazyByteString ByteString
kw
    Word8 -> Put
putWord8 Word8
0
    Word8 -> Put
putWord8 Word8
0 -- compression type

    ByteString -> Put
putLazyByteString (ByteString -> ByteString
Z.compress ByteString
pdata)

aToMetadata :: (a -> L.ByteString) -> (a -> L.ByteString) -> a -> Metadatas
aToMetadata :: forall a. (a -> ByteString) -> (a -> ByteString) -> a -> Metadatas
aToMetadata a -> ByteString
pkeyword a -> ByteString
pdata a
ptext = case a -> ByteString
pkeyword a
ptext of
  ByteString
"Title" -> Keys String -> Metadatas
strValue Keys String
Met.Title
  ByteString
"Author" -> Keys String -> Metadatas
strValue Keys String
Met.Author
  ByteString
"Description" -> Keys String -> Metadatas
strValue Keys String
Met.Description
  ByteString
"Copyright" -> Keys String -> Metadatas
strValue Keys String
Met.Copyright
  {-"Creation Time" -> strValue Creation-}
  ByteString
"Software" -> Keys String -> Metadatas
strValue Keys String
Met.Software
  ByteString
"Disclaimer" -> Keys String -> Metadatas
strValue Keys String
Met.Disclaimer
  ByteString
"Warning" -> Keys String -> Metadatas
strValue Keys String
Met.Warning
  ByteString
"Source" -> Keys String -> Metadatas
strValue Keys String
Met.Source
  ByteString
"Comment" -> Keys String -> Metadatas
strValue Keys String
Met.Comment
  ByteString
other -> 
    Keys Value -> Value -> Metadatas
forall a. (Show a, NFData a) => Keys a -> a -> Metadatas
Met.singleton
      (String -> Keys Value
Met.Unknown (String -> Keys Value) -> String -> Keys Value
forall a b. (a -> b) -> a -> b
$ ByteString -> String
L.unpack ByteString
other)
      (String -> Value
Met.String (String -> Value) -> (ByteString -> String) -> ByteString -> Value
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString -> String
L.unpack (ByteString -> Value) -> ByteString -> Value
forall a b. (a -> b) -> a -> b
$ a -> ByteString
pdata a
ptext)
  where
    strValue :: Keys String -> Metadatas
strValue Keys String
k = Keys String -> String -> Metadatas
forall a. (Show a, NFData a) => Keys a -> a -> Metadatas
Met.singleton Keys String
k (String -> Metadatas)
-> (ByteString -> String) -> ByteString -> Metadatas
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString -> String
L.unpack (ByteString -> Metadatas) -> ByteString -> Metadatas
forall a b. (a -> b) -> a -> b
$ a -> ByteString
pdata a
ptext

textToMetadata :: PngText -> Metadatas
textToMetadata :: PngText -> Metadatas
textToMetadata = (PngText -> ByteString)
-> (PngText -> ByteString) -> PngText -> Metadatas
forall a. (a -> ByteString) -> (a -> ByteString) -> a -> Metadatas
aToMetadata PngText -> ByteString
pngKeyword PngText -> ByteString
pngData

ztxtToMetadata :: PngZText -> Metadatas
ztxtToMetadata :: PngZText -> Metadatas
ztxtToMetadata = (PngZText -> ByteString)
-> (PngZText -> ByteString) -> PngZText -> Metadatas
forall a. (a -> ByteString) -> (a -> ByteString) -> a -> Metadatas
aToMetadata PngZText -> ByteString
pngZKeyword PngZText -> ByteString
pngZData

getTexts :: [L.ByteString] -> Metadatas
getTexts :: [ByteString] -> Metadatas
getTexts = (ByteString -> Metadatas) -> [ByteString] -> Metadatas
forall m a. Monoid m => (a -> m) -> [a] -> m
forall (t :: * -> *) m a.
(Foldable t, Monoid m) =>
(a -> m) -> t a -> m
foldMap ((PngText -> Metadatas) -> Either String PngText -> Metadatas
forall m a e. Monoid m => (a -> m) -> Either e a -> m
eitherFoldMap PngText -> Metadatas
textToMetadata (Either String PngText -> Metadatas)
-> (ByteString -> Either String PngText) -> ByteString -> Metadatas
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Get PngText -> ByteString -> Either String PngText
forall a. Get a -> ByteString -> Either String a
runGet Get PngText
forall t. Binary t => Get t
get)

getZTexts :: [L.ByteString] -> Metadatas
getZTexts :: [ByteString] -> Metadatas
getZTexts = (ByteString -> Metadatas) -> [ByteString] -> Metadatas
forall m a. Monoid m => (a -> m) -> [a] -> m
forall (t :: * -> *) m a.
(Foldable t, Monoid m) =>
(a -> m) -> t a -> m
foldMap ((PngZText -> Metadatas) -> Either String PngZText -> Metadatas
forall m a e. Monoid m => (a -> m) -> Either e a -> m
eitherFoldMap PngZText -> Metadatas
ztxtToMetadata (Either String PngZText -> Metadatas)
-> (ByteString -> Either String PngZText)
-> ByteString
-> Metadatas
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Get PngZText -> ByteString -> Either String PngZText
forall a. Get a -> ByteString -> Either String a
runGet Get PngZText
forall t. Binary t => Get t
get)

extractMetadatas :: PngRawImage -> Metadatas
extractMetadatas :: PngRawImage -> Metadatas
extractMetadatas PngRawImage
img = [ByteString] -> Metadatas
getDpis (ByteString -> [ByteString]
chunksOf ByteString
pHYsSignature)
                    Metadatas -> Metadatas -> Metadatas
forall a. Semigroup a => a -> a -> a
<> [ByteString] -> Metadatas
getGamma (ByteString -> [ByteString]
chunksOf ByteString
gammaSignature)
                    Metadatas -> Metadatas -> Metadatas
forall a. Semigroup a => a -> a -> a
<> [ByteString] -> Metadatas
getTexts (ByteString -> [ByteString]
chunksOf ByteString
tEXtSignature)
                    Metadatas -> Metadatas -> Metadatas
forall a. Semigroup a => a -> a -> a
<> [ByteString] -> Metadatas
getZTexts (ByteString -> [ByteString]
chunksOf ByteString
zTXtSignature)
  where
    chunksOf :: ByteString -> [ByteString]
chunksOf = PngRawImage -> ByteString -> [ByteString]
chunksWithSig PngRawImage
img

encodePhysicalMetadata :: Metadatas -> [PngRawChunk]
encodePhysicalMetadata :: Metadatas -> [PngRawChunk]
encodePhysicalMetadata Metadatas
metas = [PngRawChunk] -> Maybe [PngRawChunk] -> [PngRawChunk]
forall a. a -> Maybe a -> a
fromMaybe [] (Maybe [PngRawChunk] -> [PngRawChunk])
-> Maybe [PngRawChunk] -> [PngRawChunk]
forall a b. (a -> b) -> a -> b
$ do
  Word
dx <- Keys Word -> Metadatas -> Maybe Word
forall a. Keys a -> Metadatas -> Maybe a
Met.lookup Keys Word
Met.DpiX Metadatas
metas
  Word
dy <- Keys Word -> Metadatas -> Maybe Word
forall a. Keys a -> Metadatas -> Maybe a
Met.lookup Keys Word
Met.DpiY Metadatas
metas
  let to :: Word -> Word32
to = Word -> Word32
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Word -> Word32) -> (Word -> Word) -> Word -> Word32
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Word -> Word
Met.dotPerInchToDotsPerMeter
      dim :: PngPhysicalDimension
dim = Word32 -> Word32 -> PngUnit -> PngPhysicalDimension
PngPhysicalDimension (Word -> Word32
to Word
dx) (Word -> Word32
to Word
dy) PngUnit
PngUnitMeter
  [PngRawChunk] -> Maybe [PngRawChunk]
forall a. a -> Maybe a
forall (f :: * -> *) a. Applicative f => a -> f a
pure [ByteString -> ByteString -> PngRawChunk
mkRawChunk ByteString
pHYsSignature (ByteString -> PngRawChunk) -> ByteString -> PngRawChunk
forall a b. (a -> b) -> a -> b
$ PngPhysicalDimension -> ByteString
forall a. Binary a => a -> ByteString
encode PngPhysicalDimension
dim]

encodeSingleMetadata :: Metadatas -> [PngRawChunk]
encodeSingleMetadata :: Metadatas -> [PngRawChunk]
encodeSingleMetadata = (Elem Keys -> [PngRawChunk]) -> Metadatas -> [PngRawChunk]
forall m. Monoid m => (Elem Keys -> m) -> Metadatas -> m
Met.foldMap Elem Keys -> [PngRawChunk]
go where
  go :: Elem Met.Keys -> [PngRawChunk]
  go :: Elem Keys -> [PngRawChunk]
go Elem Keys
v = case Elem Keys
v of
    Met.Exif ExifTag
_ :=> a
_ -> [PngRawChunk]
forall a. Monoid a => a
mempty
    Keys a
Met.DpiX :=> a
_ -> [PngRawChunk]
forall a. Monoid a => a
mempty
    Keys a
Met.DpiY :=> a
_ -> [PngRawChunk]
forall a. Monoid a => a
mempty
    Keys a
Met.Width :=> a
_ -> [PngRawChunk]
forall a. Monoid a => a
mempty
    Keys a
Met.Height :=> a
_ -> [PngRawChunk]
forall a. Monoid a => a
mempty
    Keys a
Met.Format :=> a
_ -> [PngRawChunk]
forall a. Monoid a => a
mempty
    Keys a
Met.Gamma       :=> a
g ->
      PngRawChunk -> [PngRawChunk]
forall a. a -> [a]
forall (f :: * -> *) a. Applicative f => a -> f a
pure (PngRawChunk -> [PngRawChunk]) -> PngRawChunk -> [PngRawChunk]
forall a b. (a -> b) -> a -> b
$ ByteString -> ByteString -> PngRawChunk
mkRawChunk ByteString
gammaSignature (ByteString -> PngRawChunk)
-> (PngGamma -> ByteString) -> PngGamma -> PngRawChunk
forall b c a. (b -> c) -> (a -> b) -> a -> c
. PngGamma -> ByteString
forall a. Binary a => a -> ByteString
encode (PngGamma -> PngRawChunk) -> PngGamma -> PngRawChunk
forall a b. (a -> b) -> a -> b
$ Double -> PngGamma
PngGamma a
Double
g
    Keys a
Met.ColorSpace  :=> a
_ -> [PngRawChunk]
forall a. Monoid a => a
mempty
    Keys a
Met.Title       :=> a
tx -> ByteString -> ByteString -> [PngRawChunk]
forall {f :: * -> *}.
Applicative f =>
ByteString -> ByteString -> f PngRawChunk
txt ByteString
"Title" (String -> ByteString
L.pack a
String
tx)
    Keys a
Met.Description :=> a
tx -> ByteString -> ByteString -> [PngRawChunk]
forall {f :: * -> *}.
Applicative f =>
ByteString -> ByteString -> f PngRawChunk
txt ByteString
"Description" (String -> ByteString
L.pack a
String
tx)
    Keys a
Met.Author      :=> a
tx -> ByteString -> ByteString -> [PngRawChunk]
forall {f :: * -> *}.
Applicative f =>
ByteString -> ByteString -> f PngRawChunk
txt ByteString
"Author" (String -> ByteString
L.pack a
String
tx)
    Keys a
Met.Copyright   :=> a
tx -> ByteString -> ByteString -> [PngRawChunk]
forall {f :: * -> *}.
Applicative f =>
ByteString -> ByteString -> f PngRawChunk
txt ByteString
"Copyright" (String -> ByteString
L.pack a
String
tx)
    Keys a
Met.Software    :=> a
tx -> ByteString -> ByteString -> [PngRawChunk]
forall {f :: * -> *}.
Applicative f =>
ByteString -> ByteString -> f PngRawChunk
txt ByteString
"Software" (String -> ByteString
L.pack a
String
tx)
    Keys a
Met.Comment     :=> a
tx -> ByteString -> ByteString -> [PngRawChunk]
forall {f :: * -> *}.
Applicative f =>
ByteString -> ByteString -> f PngRawChunk
txt ByteString
"Comment" (String -> ByteString
L.pack a
String
tx)
    Keys a
Met.Disclaimer  :=> a
tx -> ByteString -> ByteString -> [PngRawChunk]
forall {f :: * -> *}.
Applicative f =>
ByteString -> ByteString -> f PngRawChunk
txt ByteString
"Disclaimer" (String -> ByteString
L.pack a
String
tx)
    Keys a
Met.Source      :=> a
tx -> ByteString -> ByteString -> [PngRawChunk]
forall {f :: * -> *}.
Applicative f =>
ByteString -> ByteString -> f PngRawChunk
txt ByteString
"Source" (String -> ByteString
L.pack a
String
tx)
    Keys a
Met.Warning     :=> a
tx -> ByteString -> ByteString -> [PngRawChunk]
forall {f :: * -> *}.
Applicative f =>
ByteString -> ByteString -> f PngRawChunk
txt ByteString
"Warning" (String -> ByteString
L.pack a
String
tx)
    Met.Unknown String
k   :=> Met.String String
tx -> ByteString -> ByteString -> [PngRawChunk]
forall {f :: * -> *}.
Applicative f =>
ByteString -> ByteString -> f PngRawChunk
txt (String -> ByteString
L.pack String
k) (String -> ByteString
L.pack String
tx)
    Met.Unknown String
_   :=> a
_ -> [PngRawChunk]
forall a. Monoid a => a
mempty

  txt :: ByteString -> ByteString -> f PngRawChunk
txt ByteString
k ByteString
c = PngRawChunk -> f PngRawChunk
forall a. a -> f a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (PngRawChunk -> f PngRawChunk)
-> (PngText -> PngRawChunk) -> PngText -> f PngRawChunk
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString -> ByteString -> PngRawChunk
mkRawChunk ByteString
tEXtSignature (ByteString -> PngRawChunk)
-> (PngText -> ByteString) -> PngText -> PngRawChunk
forall b c a. (b -> c) -> (a -> b) -> a -> c
. PngText -> ByteString
forall a. Binary a => a -> ByteString
encode (PngText -> f PngRawChunk) -> PngText -> f PngRawChunk
forall a b. (a -> b) -> a -> b
$ ByteString -> ByteString -> PngText
PngText ByteString
k ByteString
c

encodeMetadatas :: Metadatas -> [PngRawChunk]
encodeMetadatas :: Metadatas -> [PngRawChunk]
encodeMetadatas Metadatas
m = Metadatas -> [PngRawChunk]
encodePhysicalMetadata Metadatas
m [PngRawChunk] -> [PngRawChunk] -> [PngRawChunk]
forall a. Semigroup a => a -> a -> a
<> Metadatas -> [PngRawChunk]
encodeSingleMetadata Metadatas
m