#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.GstTag.Functions
(
tagCheckLanguageCode ,
tagFreeformStringToUtf8 ,
tagFromId3Tag ,
tagFromId3UserTag ,
tagFromVorbisTag ,
tagGetId3v2TagSize ,
tagGetLanguageCodeIso6391 ,
tagGetLanguageCodeIso6392B ,
tagGetLanguageCodeIso6392T ,
tagGetLanguageCodes ,
tagGetLanguageName ,
tagGetLicenseDescription ,
tagGetLicenseFlags ,
tagGetLicenseJurisdiction ,
tagGetLicenseNick ,
tagGetLicenseTitle ,
tagGetLicenseVersion ,
tagGetLicenses ,
tagId3GenreCount ,
tagId3GenreGet ,
tagImageDataToImageSample ,
tagListAddId3Image ,
tagListFromExifBuffer ,
tagListFromExifBufferWithTiffHeader ,
tagListFromId3v2Tag ,
tagListFromVorbiscomment ,
tagListFromVorbiscommentBuffer ,
tagListFromXmpBuffer ,
tagListNewFromId3v1 ,
tagListToExifBuffer ,
tagListToExifBufferWithTiffHeader ,
tagListToVorbiscommentBuffer ,
tagListToXmpBuffer ,
tagParseExtendedComment ,
tagRegisterMusicbrainzTags ,
tagToId3Tag ,
tagToVorbisComments ,
tagToVorbisTag ,
tagXmpListSchemas ,
vorbisTagAdd ,
) where
import Data.GI.Base.ShortPrelude
import qualified Data.GI.Base.ShortPrelude as SP
import qualified Data.GI.Base.Overloading as O
import qualified Prelude as P
import qualified Data.GI.Base.Attributes as GI.Attributes
import qualified Data.GI.Base.BasicTypes as B.Types
import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
import qualified Data.GI.Base.GArray as B.GArray
import qualified Data.GI.Base.GClosure as B.GClosure
import qualified Data.GI.Base.GError as B.GError
import qualified Data.GI.Base.GHashTable as B.GHT
import qualified Data.GI.Base.GVariant as B.GVariant
import qualified Data.GI.Base.GValue as B.GValue
import qualified Data.GI.Base.GParamSpec as B.GParamSpec
import qualified Data.GI.Base.CallStack as B.CallStack
import qualified Data.GI.Base.Properties as B.Properties
import qualified Data.GI.Base.Signals as B.Signals
import qualified Control.Monad.IO.Class as MIO
import qualified Data.Coerce as Coerce
import qualified Data.Text as T
import qualified Data.Kind as DK
import qualified Data.ByteString.Char8 as B
import qualified Data.Map as Map
import qualified Foreign.Ptr as FP
import qualified GHC.OverloadedLabels as OL
import qualified GHC.Records as R
import qualified GI.Gst.Structs.Buffer as Gst.Buffer
import qualified GI.Gst.Structs.Sample as Gst.Sample
import qualified GI.Gst.Structs.TagList as Gst.TagList
import {-# SOURCE #-} qualified GI.GstTag.Enums as GstTag.Enums
import {-# SOURCE #-} qualified GI.GstTag.Flags as GstTag.Flags
foreign import ccall "gst_vorbis_tag_add" gst_vorbis_tag_add ::
Ptr Gst.TagList.TagList ->
CString ->
CString ->
IO ()
vorbisTagAdd ::
(B.CallStack.HasCallStack, MonadIO m) =>
Gst.TagList.TagList
-> T.Text
-> T.Text
-> m ()
vorbisTagAdd :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
TagList -> Text -> Text -> m ()
vorbisTagAdd TagList
list Text
tag Text
value = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr TagList
list' <- TagList -> IO (Ptr TagList)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr TagList
list
CString
tag' <- Text -> IO CString
textToCString Text
tag
CString
value' <- Text -> IO CString
textToCString Text
value
Ptr TagList -> CString -> CString -> IO ()
gst_vorbis_tag_add Ptr TagList
list' CString
tag' CString
value'
TagList -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr TagList
list
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
tag'
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
value'
() -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
foreign import ccall "gst_tag_xmp_list_schemas" gst_tag_xmp_list_schemas ::
IO (Ptr CString)
tagXmpListSchemas ::
(B.CallStack.HasCallStack, MonadIO m) =>
m [T.Text]
tagXmpListSchemas :: forall (m :: * -> *). (HasCallStack, MonadIO m) => m [Text]
tagXmpListSchemas = IO [Text] -> m [Text]
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO [Text] -> m [Text]) -> IO [Text] -> m [Text]
forall a b. (a -> b) -> a -> b
$ do
Ptr CString
result <- IO (Ptr CString)
gst_tag_xmp_list_schemas
Text -> Ptr CString -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"tagXmpListSchemas" Ptr CString
result
[Text]
result' <- HasCallStack => Ptr CString -> IO [Text]
Ptr CString -> IO [Text]
unpackZeroTerminatedUTF8CArray Ptr CString
result
[Text] -> IO [Text]
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return [Text]
result'
foreign import ccall "gst_tag_to_vorbis_tag" gst_tag_to_vorbis_tag ::
CString ->
IO CString
tagToVorbisTag ::
(B.CallStack.HasCallStack, MonadIO m) =>
T.Text
-> m (Maybe T.Text)
tagToVorbisTag :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Text -> m (Maybe Text)
tagToVorbisTag Text
gstTag = IO (Maybe Text) -> m (Maybe Text)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Text) -> m (Maybe Text))
-> IO (Maybe Text) -> m (Maybe Text)
forall a b. (a -> b) -> a -> b
$ do
CString
gstTag' <- Text -> IO CString
textToCString Text
gstTag
CString
result <- CString -> IO CString
gst_tag_to_vorbis_tag CString
gstTag'
Maybe Text
maybeResult <- CString -> (CString -> IO Text) -> IO (Maybe Text)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull CString
result ((CString -> IO Text) -> IO (Maybe Text))
-> (CString -> IO Text) -> IO (Maybe Text)
forall a b. (a -> b) -> a -> b
$ \CString
result' -> do
Text
result'' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result'
Text -> IO Text
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result''
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
gstTag'
Maybe Text -> IO (Maybe Text)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Text
maybeResult
foreign import ccall "gst_tag_to_vorbis_comments" ::
Ptr Gst.TagList.TagList ->
CString ->
IO (Ptr (GList CString))
tagToVorbisComments ::
(B.CallStack.HasCallStack, MonadIO m) =>
Gst.TagList.TagList
-> T.Text
-> m [T.Text]
TagList
list Text
tag = IO [Text] -> m [Text]
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO [Text] -> m [Text]) -> IO [Text] -> m [Text]
forall a b. (a -> b) -> a -> b
$ do
Ptr TagList
list' <- TagList -> IO (Ptr TagList)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr TagList
list
CString
tag' <- Text -> IO CString
textToCString Text
tag
Ptr (GList CString)
result <- Ptr TagList -> CString -> IO (Ptr (GList CString))
gst_tag_to_vorbis_comments Ptr TagList
list' CString
tag'
[CString]
result' <- Ptr (GList CString) -> IO [CString]
forall a. Ptr (GList (Ptr a)) -> IO [Ptr a]
unpackGList Ptr (GList CString)
result
[Text]
result'' <- (CString -> IO Text) -> [CString] -> IO [Text]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
mapM HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText [CString]
result'
(CString -> IO ()) -> Ptr (GList CString) -> IO ()
forall a b. (Ptr a -> IO b) -> Ptr (GList (Ptr a)) -> IO ()
mapGList CString -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr (GList CString)
result
Ptr (GList CString) -> IO ()
forall a. Ptr (GList a) -> IO ()
g_list_free Ptr (GList CString)
result
TagList -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr TagList
list
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
tag'
[Text] -> IO [Text]
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return [Text]
result''
foreign import ccall "gst_tag_to_id3_tag" gst_tag_to_id3_tag ::
CString ->
IO CString
tagToId3Tag ::
(B.CallStack.HasCallStack, MonadIO m) =>
T.Text
-> m (Maybe T.Text)
tagToId3Tag :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Text -> m (Maybe Text)
tagToId3Tag Text
gstTag = IO (Maybe Text) -> m (Maybe Text)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Text) -> m (Maybe Text))
-> IO (Maybe Text) -> m (Maybe Text)
forall a b. (a -> b) -> a -> b
$ do
CString
gstTag' <- Text -> IO CString
textToCString Text
gstTag
CString
result <- CString -> IO CString
gst_tag_to_id3_tag CString
gstTag'
Maybe Text
maybeResult <- CString -> (CString -> IO Text) -> IO (Maybe Text)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull CString
result ((CString -> IO Text) -> IO (Maybe Text))
-> (CString -> IO Text) -> IO (Maybe Text)
forall a b. (a -> b) -> a -> b
$ \CString
result' -> do
Text
result'' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result'
Text -> IO Text
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result''
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
gstTag'
Maybe Text -> IO (Maybe Text)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Text
maybeResult
foreign import ccall "gst_tag_register_musicbrainz_tags" gst_tag_register_musicbrainz_tags ::
IO ()
tagRegisterMusicbrainzTags ::
(B.CallStack.HasCallStack, MonadIO m) =>
m ()
tagRegisterMusicbrainzTags :: forall (m :: * -> *). (HasCallStack, MonadIO m) => m ()
tagRegisterMusicbrainzTags = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
IO ()
gst_tag_register_musicbrainz_tags
() -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
foreign import ccall "gst_tag_parse_extended_comment" ::
CString ->
Ptr CString ->
Ptr CString ->
Ptr CString ->
CInt ->
IO CInt
tagParseExtendedComment ::
(B.CallStack.HasCallStack, MonadIO m) =>
T.Text
-> Bool
-> m ((Bool, Maybe T.Text, Maybe T.Text, T.Text))
Text
extComment Bool
failIfNoKey = IO (Bool, Maybe Text, Maybe Text, Text)
-> m (Bool, Maybe Text, Maybe Text, Text)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Bool, Maybe Text, Maybe Text, Text)
-> m (Bool, Maybe Text, Maybe Text, Text))
-> IO (Bool, Maybe Text, Maybe Text, Text)
-> m (Bool, Maybe Text, Maybe Text, Text)
forall a b. (a -> b) -> a -> b
$ do
CString
extComment' <- Text -> IO CString
textToCString Text
extComment
Ptr CString
key <- IO (Ptr CString)
forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr CString)
Ptr CString
lang <- IO (Ptr CString)
forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr CString)
Ptr CString
value <- IO (Ptr CString)
forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr CString)
let failIfNoKey' :: CInt
failIfNoKey' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
P.fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
P.fromEnum) Bool
failIfNoKey
CInt
result <- CString
-> Ptr CString -> Ptr CString -> Ptr CString -> CInt -> IO CInt
gst_tag_parse_extended_comment CString
extComment' Ptr CString
key Ptr CString
lang Ptr CString
value CInt
failIfNoKey'
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
CString
key' <- Ptr CString -> IO CString
forall a. Storable a => Ptr a -> IO a
peek Ptr CString
key
Maybe Text
maybeKey' <- CString -> (CString -> IO Text) -> IO (Maybe Text)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull CString
key' ((CString -> IO Text) -> IO (Maybe Text))
-> (CString -> IO Text) -> IO (Maybe Text)
forall a b. (a -> b) -> a -> b
$ \CString
key'' -> do
Text
key''' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
key''
Text -> IO Text
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Text
key'''
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
key'
CString
lang' <- Ptr CString -> IO CString
forall a. Storable a => Ptr a -> IO a
peek Ptr CString
lang
Maybe Text
maybeLang' <- CString -> (CString -> IO Text) -> IO (Maybe Text)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull CString
lang' ((CString -> IO Text) -> IO (Maybe Text))
-> (CString -> IO Text) -> IO (Maybe Text)
forall a b. (a -> b) -> a -> b
$ \CString
lang'' -> do
Text
lang''' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
lang''
Text -> IO Text
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Text
lang'''
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
lang'
CString
value' <- Ptr CString -> IO CString
forall a. Storable a => Ptr a -> IO a
peek Ptr CString
value
Text
value'' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
value'
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
value'
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
extComment'
Ptr CString -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CString
key
Ptr CString -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CString
lang
Ptr CString -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CString
value
(Bool, Maybe Text, Maybe Text, Text)
-> IO (Bool, Maybe Text, Maybe Text, Text)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (Bool
result', Maybe Text
maybeKey', Maybe Text
maybeLang', Text
value'')
foreign import ccall "gst_tag_list_to_xmp_buffer" gst_tag_list_to_xmp_buffer ::
Ptr Gst.TagList.TagList ->
CInt ->
Ptr CString ->
IO (Ptr Gst.Buffer.Buffer)
tagListToXmpBuffer ::
(B.CallStack.HasCallStack, MonadIO m) =>
Gst.TagList.TagList
-> Bool
-> [T.Text]
-> m (Maybe Gst.Buffer.Buffer)
tagListToXmpBuffer :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
TagList -> Bool -> [Text] -> m (Maybe Buffer)
tagListToXmpBuffer TagList
list Bool
readOnly [Text]
schemas = IO (Maybe Buffer) -> m (Maybe Buffer)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Buffer) -> m (Maybe Buffer))
-> IO (Maybe Buffer) -> m (Maybe Buffer)
forall a b. (a -> b) -> a -> b
$ do
Ptr TagList
list' <- TagList -> IO (Ptr TagList)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr TagList
list
let readOnly' :: CInt
readOnly' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
P.fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
P.fromEnum) Bool
readOnly
Ptr CString
schemas' <- [Text] -> IO (Ptr CString)
packZeroTerminatedUTF8CArray [Text]
schemas
Ptr Buffer
result <- Ptr TagList -> CInt -> Ptr CString -> IO (Ptr Buffer)
gst_tag_list_to_xmp_buffer Ptr TagList
list' CInt
readOnly' Ptr CString
schemas'
Maybe Buffer
maybeResult <- Ptr Buffer -> (Ptr Buffer -> IO Buffer) -> IO (Maybe Buffer)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr Buffer
result ((Ptr Buffer -> IO Buffer) -> IO (Maybe Buffer))
-> (Ptr Buffer -> IO Buffer) -> IO (Maybe Buffer)
forall a b. (a -> b) -> a -> b
$ \Ptr Buffer
result' -> do
Buffer
result'' <- ((ManagedPtr Buffer -> Buffer) -> Ptr Buffer -> IO Buffer
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Buffer -> Buffer
Gst.Buffer.Buffer) Ptr Buffer
result'
Buffer -> IO Buffer
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Buffer
result''
TagList -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr TagList
list
(CString -> IO ()) -> Ptr CString -> IO ()
forall a b. (Ptr a -> IO b) -> Ptr (Ptr a) -> IO ()
mapZeroTerminatedCArray CString -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CString
schemas'
Ptr CString -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CString
schemas'
Maybe Buffer -> IO (Maybe Buffer)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Buffer
maybeResult
foreign import ccall "gst_tag_list_to_vorbiscomment_buffer" ::
Ptr Gst.TagList.TagList ->
Ptr Word8 ->
Word32 ->
CString ->
IO (Ptr Gst.Buffer.Buffer)
tagListToVorbiscommentBuffer ::
(B.CallStack.HasCallStack, MonadIO m) =>
Gst.TagList.TagList
-> ByteString
-> Maybe (T.Text)
-> m Gst.Buffer.Buffer
TagList
list ByteString
idData Maybe Text
vendorString = IO Buffer -> m Buffer
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Buffer -> m Buffer) -> IO Buffer -> m Buffer
forall a b. (a -> b) -> a -> b
$ do
let idDataLength :: Word32
idDataLength = Int -> Word32
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> Word32) -> Int -> Word32
forall a b. (a -> b) -> a -> b
$ ByteString -> Int
B.length ByteString
idData
Ptr TagList
list' <- TagList -> IO (Ptr TagList)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr TagList
list
Ptr Word8
idData' <- ByteString -> IO (Ptr Word8)
packByteString ByteString
idData
CString
maybeVendorString <- case Maybe Text
vendorString of
Maybe Text
Nothing -> CString -> IO CString
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return CString
forall a. Ptr a
nullPtr
Just Text
jVendorString -> do
CString
jVendorString' <- Text -> IO CString
textToCString Text
jVendorString
CString -> IO CString
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return CString
jVendorString'
Ptr Buffer
result <- Ptr TagList -> Ptr Word8 -> Word32 -> CString -> IO (Ptr Buffer)
gst_tag_list_to_vorbiscomment_buffer Ptr TagList
list' Ptr Word8
idData' Word32
idDataLength CString
maybeVendorString
Text -> Ptr Buffer -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"tagListToVorbiscommentBuffer" Ptr Buffer
result
Buffer
result' <- ((ManagedPtr Buffer -> Buffer) -> Ptr Buffer -> IO Buffer
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Buffer -> Buffer
Gst.Buffer.Buffer) Ptr Buffer
result
TagList -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr TagList
list
Ptr Word8 -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr Word8
idData'
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
maybeVendorString
Buffer -> IO Buffer
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Buffer
result'
foreign import ccall "gst_tag_list_to_exif_buffer_with_tiff_header" ::
Ptr Gst.TagList.TagList ->
IO (Ptr Gst.Buffer.Buffer)
tagListToExifBufferWithTiffHeader ::
(B.CallStack.HasCallStack, MonadIO m) =>
Gst.TagList.TagList
-> m Gst.Buffer.Buffer
TagList
taglist = IO Buffer -> m Buffer
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Buffer -> m Buffer) -> IO Buffer -> m Buffer
forall a b. (a -> b) -> a -> b
$ do
Ptr TagList
taglist' <- TagList -> IO (Ptr TagList)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr TagList
taglist
Ptr Buffer
result <- Ptr TagList -> IO (Ptr Buffer)
gst_tag_list_to_exif_buffer_with_tiff_header Ptr TagList
taglist'
Text -> Ptr Buffer -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"tagListToExifBufferWithTiffHeader" Ptr Buffer
result
Buffer
result' <- ((ManagedPtr Buffer -> Buffer) -> Ptr Buffer -> IO Buffer
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Buffer -> Buffer
Gst.Buffer.Buffer) Ptr Buffer
result
TagList -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr TagList
taglist
Buffer -> IO Buffer
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Buffer
result'
foreign import ccall "gst_tag_list_to_exif_buffer" gst_tag_list_to_exif_buffer ::
Ptr Gst.TagList.TagList ->
Int32 ->
Word32 ->
IO (Ptr Gst.Buffer.Buffer)
tagListToExifBuffer ::
(B.CallStack.HasCallStack, MonadIO m) =>
Gst.TagList.TagList
-> Int32
-> Word32
-> m Gst.Buffer.Buffer
tagListToExifBuffer :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
TagList -> Int32 -> Word32 -> m Buffer
tagListToExifBuffer TagList
taglist Int32
byteOrder Word32
baseOffset = IO Buffer -> m Buffer
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Buffer -> m Buffer) -> IO Buffer -> m Buffer
forall a b. (a -> b) -> a -> b
$ do
Ptr TagList
taglist' <- TagList -> IO (Ptr TagList)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr TagList
taglist
Ptr Buffer
result <- Ptr TagList -> Int32 -> Word32 -> IO (Ptr Buffer)
gst_tag_list_to_exif_buffer Ptr TagList
taglist' Int32
byteOrder Word32
baseOffset
Text -> Ptr Buffer -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"tagListToExifBuffer" Ptr Buffer
result
Buffer
result' <- ((ManagedPtr Buffer -> Buffer) -> Ptr Buffer -> IO Buffer
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Buffer -> Buffer
Gst.Buffer.Buffer) Ptr Buffer
result
TagList -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr TagList
taglist
Buffer -> IO Buffer
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Buffer
result'
foreign import ccall "gst_tag_list_new_from_id3v1" gst_tag_list_new_from_id3v1 ::
Ptr Word8 ->
IO (Ptr Gst.TagList.TagList)
tagListNewFromId3v1 ::
(B.CallStack.HasCallStack, MonadIO m) =>
ByteString
-> m (Maybe Gst.TagList.TagList)
tagListNewFromId3v1 :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
ByteString -> m (Maybe TagList)
tagListNewFromId3v1 ByteString
data_ = IO (Maybe TagList) -> m (Maybe TagList)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe TagList) -> m (Maybe TagList))
-> IO (Maybe TagList) -> m (Maybe TagList)
forall a b. (a -> b) -> a -> b
$ do
Ptr Word8
data_' <- ByteString -> IO (Ptr Word8)
packByteString ByteString
data_
Ptr TagList
result <- Ptr Word8 -> IO (Ptr TagList)
gst_tag_list_new_from_id3v1 Ptr Word8
data_'
Maybe TagList
maybeResult <- Ptr TagList -> (Ptr TagList -> IO TagList) -> IO (Maybe TagList)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr TagList
result ((Ptr TagList -> IO TagList) -> IO (Maybe TagList))
-> (Ptr TagList -> IO TagList) -> IO (Maybe TagList)
forall a b. (a -> b) -> a -> b
$ \Ptr TagList
result' -> do
TagList
result'' <- ((ManagedPtr TagList -> TagList) -> Ptr TagList -> IO TagList
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr TagList -> TagList
Gst.TagList.TagList) Ptr TagList
result'
TagList -> IO TagList
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return TagList
result''
Ptr Word8 -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr Word8
data_'
Maybe TagList -> IO (Maybe TagList)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe TagList
maybeResult
foreign import ccall "gst_tag_list_from_xmp_buffer" gst_tag_list_from_xmp_buffer ::
Ptr Gst.Buffer.Buffer ->
IO (Ptr Gst.TagList.TagList)
tagListFromXmpBuffer ::
(B.CallStack.HasCallStack, MonadIO m) =>
Gst.Buffer.Buffer
-> m (Maybe Gst.TagList.TagList)
tagListFromXmpBuffer :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Buffer -> m (Maybe TagList)
tagListFromXmpBuffer Buffer
buffer = IO (Maybe TagList) -> m (Maybe TagList)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe TagList) -> m (Maybe TagList))
-> IO (Maybe TagList) -> m (Maybe TagList)
forall a b. (a -> b) -> a -> b
$ do
Ptr Buffer
buffer' <- Buffer -> IO (Ptr Buffer)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Buffer
buffer
Ptr TagList
result <- Ptr Buffer -> IO (Ptr TagList)
gst_tag_list_from_xmp_buffer Ptr Buffer
buffer'
Maybe TagList
maybeResult <- Ptr TagList -> (Ptr TagList -> IO TagList) -> IO (Maybe TagList)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr TagList
result ((Ptr TagList -> IO TagList) -> IO (Maybe TagList))
-> (Ptr TagList -> IO TagList) -> IO (Maybe TagList)
forall a b. (a -> b) -> a -> b
$ \Ptr TagList
result' -> do
TagList
result'' <- ((ManagedPtr TagList -> TagList) -> Ptr TagList -> IO TagList
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr TagList -> TagList
Gst.TagList.TagList) Ptr TagList
result'
TagList -> IO TagList
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return TagList
result''
Buffer -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Buffer
buffer
Maybe TagList -> IO (Maybe TagList)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe TagList
maybeResult
foreign import ccall "gst_tag_list_from_vorbiscomment_buffer" ::
Ptr Gst.Buffer.Buffer ->
Ptr Word8 ->
Word32 ->
Ptr CString ->
IO (Ptr Gst.TagList.TagList)
tagListFromVorbiscommentBuffer ::
(B.CallStack.HasCallStack, MonadIO m) =>
Gst.Buffer.Buffer
-> ByteString
-> m ((Maybe Gst.TagList.TagList, T.Text))
Buffer
buffer ByteString
idData = IO (Maybe TagList, Text) -> m (Maybe TagList, Text)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe TagList, Text) -> m (Maybe TagList, Text))
-> IO (Maybe TagList, Text) -> m (Maybe TagList, Text)
forall a b. (a -> b) -> a -> b
$ do
let idDataLength :: Word32
idDataLength = Int -> Word32
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> Word32) -> Int -> Word32
forall a b. (a -> b) -> a -> b
$ ByteString -> Int
B.length ByteString
idData
Ptr Buffer
buffer' <- Buffer -> IO (Ptr Buffer)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Buffer
buffer
Ptr Word8
idData' <- ByteString -> IO (Ptr Word8)
packByteString ByteString
idData
Ptr CString
vendorString <- IO (Ptr CString)
forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr CString)
Ptr TagList
result <- Ptr Buffer
-> Ptr Word8 -> Word32 -> Ptr CString -> IO (Ptr TagList)
gst_tag_list_from_vorbiscomment_buffer Ptr Buffer
buffer' Ptr Word8
idData' Word32
idDataLength Ptr CString
vendorString
Maybe TagList
maybeResult <- Ptr TagList -> (Ptr TagList -> IO TagList) -> IO (Maybe TagList)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr TagList
result ((Ptr TagList -> IO TagList) -> IO (Maybe TagList))
-> (Ptr TagList -> IO TagList) -> IO (Maybe TagList)
forall a b. (a -> b) -> a -> b
$ \Ptr TagList
result' -> do
TagList
result'' <- ((ManagedPtr TagList -> TagList) -> Ptr TagList -> IO TagList
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr TagList -> TagList
Gst.TagList.TagList) Ptr TagList
result'
TagList -> IO TagList
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return TagList
result''
CString
vendorString' <- Ptr CString -> IO CString
forall a. Storable a => Ptr a -> IO a
peek Ptr CString
vendorString
Text
vendorString'' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
vendorString'
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
vendorString'
Buffer -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Buffer
buffer
Ptr Word8 -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr Word8
idData'
Ptr CString -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CString
vendorString
(Maybe TagList, Text) -> IO (Maybe TagList, Text)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (Maybe TagList
maybeResult, Text
vendorString'')
foreign import ccall "gst_tag_list_from_vorbiscomment" ::
Ptr Word8 ->
Word64 ->
Ptr Word8 ->
Word32 ->
Ptr CString ->
IO (Ptr Gst.TagList.TagList)
tagListFromVorbiscomment ::
(B.CallStack.HasCallStack, MonadIO m) =>
ByteString
-> ByteString
-> m ((Maybe Gst.TagList.TagList, T.Text))
ByteString
data_ ByteString
idData = IO (Maybe TagList, Text) -> m (Maybe TagList, Text)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe TagList, Text) -> m (Maybe TagList, Text))
-> IO (Maybe TagList, Text) -> m (Maybe TagList, Text)
forall a b. (a -> b) -> a -> b
$ do
let idDataLength :: Word32
idDataLength = Int -> Word32
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> Word32) -> Int -> Word32
forall a b. (a -> b) -> a -> b
$ ByteString -> Int
B.length ByteString
idData
let size :: Word64
size = Int -> Word64
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> Word64) -> Int -> Word64
forall a b. (a -> b) -> a -> b
$ ByteString -> Int
B.length ByteString
data_
Ptr Word8
data_' <- ByteString -> IO (Ptr Word8)
packByteString ByteString
data_
Ptr Word8
idData' <- ByteString -> IO (Ptr Word8)
packByteString ByteString
idData
Ptr CString
vendorString <- IO (Ptr CString)
forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr CString)
Ptr TagList
result <- Ptr Word8
-> Word64 -> Ptr Word8 -> Word32 -> Ptr CString -> IO (Ptr TagList)
gst_tag_list_from_vorbiscomment Ptr Word8
data_' Word64
size Ptr Word8
idData' Word32
idDataLength Ptr CString
vendorString
Maybe TagList
maybeResult <- Ptr TagList -> (Ptr TagList -> IO TagList) -> IO (Maybe TagList)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr TagList
result ((Ptr TagList -> IO TagList) -> IO (Maybe TagList))
-> (Ptr TagList -> IO TagList) -> IO (Maybe TagList)
forall a b. (a -> b) -> a -> b
$ \Ptr TagList
result' -> do
TagList
result'' <- ((ManagedPtr TagList -> TagList) -> Ptr TagList -> IO TagList
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr TagList -> TagList
Gst.TagList.TagList) Ptr TagList
result'
TagList -> IO TagList
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return TagList
result''
CString
vendorString' <- Ptr CString -> IO CString
forall a. Storable a => Ptr a -> IO a
peek Ptr CString
vendorString
Text
vendorString'' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
vendorString'
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
vendorString'
Ptr Word8 -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr Word8
data_'
Ptr Word8 -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr Word8
idData'
Ptr CString -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CString
vendorString
(Maybe TagList, Text) -> IO (Maybe TagList, Text)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (Maybe TagList
maybeResult, Text
vendorString'')
foreign import ccall "gst_tag_list_from_id3v2_tag" gst_tag_list_from_id3v2_tag ::
Ptr Gst.Buffer.Buffer ->
IO (Ptr Gst.TagList.TagList)
tagListFromId3v2Tag ::
(B.CallStack.HasCallStack, MonadIO m) =>
Gst.Buffer.Buffer
-> m (Maybe Gst.TagList.TagList)
tagListFromId3v2Tag :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Buffer -> m (Maybe TagList)
tagListFromId3v2Tag Buffer
buffer = IO (Maybe TagList) -> m (Maybe TagList)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe TagList) -> m (Maybe TagList))
-> IO (Maybe TagList) -> m (Maybe TagList)
forall a b. (a -> b) -> a -> b
$ do
Ptr Buffer
buffer' <- Buffer -> IO (Ptr Buffer)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Buffer
buffer
Ptr TagList
result <- Ptr Buffer -> IO (Ptr TagList)
gst_tag_list_from_id3v2_tag Ptr Buffer
buffer'
Maybe TagList
maybeResult <- Ptr TagList -> (Ptr TagList -> IO TagList) -> IO (Maybe TagList)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr TagList
result ((Ptr TagList -> IO TagList) -> IO (Maybe TagList))
-> (Ptr TagList -> IO TagList) -> IO (Maybe TagList)
forall a b. (a -> b) -> a -> b
$ \Ptr TagList
result' -> do
TagList
result'' <- ((ManagedPtr TagList -> TagList) -> Ptr TagList -> IO TagList
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr TagList -> TagList
Gst.TagList.TagList) Ptr TagList
result'
TagList -> IO TagList
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return TagList
result''
Buffer -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Buffer
buffer
Maybe TagList -> IO (Maybe TagList)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe TagList
maybeResult
foreign import ccall "gst_tag_list_from_exif_buffer_with_tiff_header" ::
Ptr Gst.Buffer.Buffer ->
IO (Ptr Gst.TagList.TagList)
tagListFromExifBufferWithTiffHeader ::
(B.CallStack.HasCallStack, MonadIO m) =>
Gst.Buffer.Buffer
-> m Gst.TagList.TagList
Buffer
buffer = IO TagList -> m TagList
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO TagList -> m TagList) -> IO TagList -> m TagList
forall a b. (a -> b) -> a -> b
$ do
Ptr Buffer
buffer' <- Buffer -> IO (Ptr Buffer)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Buffer
buffer
Ptr TagList
result <- Ptr Buffer -> IO (Ptr TagList)
gst_tag_list_from_exif_buffer_with_tiff_header Ptr Buffer
buffer'
Text -> Ptr TagList -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"tagListFromExifBufferWithTiffHeader" Ptr TagList
result
TagList
result' <- ((ManagedPtr TagList -> TagList) -> Ptr TagList -> IO TagList
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr TagList -> TagList
Gst.TagList.TagList) Ptr TagList
result
Buffer -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Buffer
buffer
TagList -> IO TagList
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return TagList
result'
foreign import ccall "gst_tag_list_from_exif_buffer" gst_tag_list_from_exif_buffer ::
Ptr Gst.Buffer.Buffer ->
Int32 ->
Word32 ->
IO (Ptr Gst.TagList.TagList)
tagListFromExifBuffer ::
(B.CallStack.HasCallStack, MonadIO m) =>
Gst.Buffer.Buffer
-> Int32
-> Word32
-> m Gst.TagList.TagList
tagListFromExifBuffer :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Buffer -> Int32 -> Word32 -> m TagList
tagListFromExifBuffer Buffer
buffer Int32
byteOrder Word32
baseOffset = IO TagList -> m TagList
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO TagList -> m TagList) -> IO TagList -> m TagList
forall a b. (a -> b) -> a -> b
$ do
Ptr Buffer
buffer' <- Buffer -> IO (Ptr Buffer)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Buffer
buffer
Ptr TagList
result <- Ptr Buffer -> Int32 -> Word32 -> IO (Ptr TagList)
gst_tag_list_from_exif_buffer Ptr Buffer
buffer' Int32
byteOrder Word32
baseOffset
Text -> Ptr TagList -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"tagListFromExifBuffer" Ptr TagList
result
TagList
result' <- ((ManagedPtr TagList -> TagList) -> Ptr TagList -> IO TagList
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr TagList -> TagList
Gst.TagList.TagList) Ptr TagList
result
Buffer -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Buffer
buffer
TagList -> IO TagList
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return TagList
result'
foreign import ccall "gst_tag_list_add_id3_image" gst_tag_list_add_id3_image ::
Ptr Gst.TagList.TagList ->
Ptr Word8 ->
Word32 ->
Word32 ->
IO CInt
tagListAddId3Image ::
(B.CallStack.HasCallStack, MonadIO m) =>
Gst.TagList.TagList
-> ByteString
-> Word32
-> m Bool
tagListAddId3Image :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
TagList -> ByteString -> Word32 -> m Bool
tagListAddId3Image TagList
tagList ByteString
imageData Word32
id3PictureType = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
let imageDataLen :: Word32
imageDataLen = Int -> Word32
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> Word32) -> Int -> Word32
forall a b. (a -> b) -> a -> b
$ ByteString -> Int
B.length ByteString
imageData
Ptr TagList
tagList' <- TagList -> IO (Ptr TagList)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr TagList
tagList
Ptr Word8
imageData' <- ByteString -> IO (Ptr Word8)
packByteString ByteString
imageData
CInt
result <- Ptr TagList -> Ptr Word8 -> Word32 -> Word32 -> IO CInt
gst_tag_list_add_id3_image Ptr TagList
tagList' Ptr Word8
imageData' Word32
imageDataLen Word32
id3PictureType
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
TagList -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr TagList
tagList
Ptr Word8 -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr Word8
imageData'
Bool -> IO Bool
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
foreign import ccall "gst_tag_image_data_to_image_sample" gst_tag_image_data_to_image_sample ::
Ptr Word8 ->
Word32 ->
CInt ->
IO (Ptr Gst.Sample.Sample)
tagImageDataToImageSample ::
(B.CallStack.HasCallStack, MonadIO m) =>
ByteString
-> GstTag.Enums.TagImageType
-> m (Maybe Gst.Sample.Sample)
tagImageDataToImageSample :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
ByteString -> TagImageType -> m (Maybe Sample)
tagImageDataToImageSample ByteString
imageData TagImageType
imageType = IO (Maybe Sample) -> m (Maybe Sample)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Sample) -> m (Maybe Sample))
-> IO (Maybe Sample) -> m (Maybe Sample)
forall a b. (a -> b) -> a -> b
$ do
let imageDataLen :: Word32
imageDataLen = Int -> Word32
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> Word32) -> Int -> Word32
forall a b. (a -> b) -> a -> b
$ ByteString -> Int
B.length ByteString
imageData
Ptr Word8
imageData' <- ByteString -> IO (Ptr Word8)
packByteString ByteString
imageData
let imageType' :: CInt
imageType' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CInt) -> (TagImageType -> Int) -> TagImageType -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. TagImageType -> Int
forall a. Enum a => a -> Int
fromEnum) TagImageType
imageType
Ptr Sample
result <- Ptr Word8 -> Word32 -> CInt -> IO (Ptr Sample)
gst_tag_image_data_to_image_sample Ptr Word8
imageData' Word32
imageDataLen CInt
imageType'
Maybe Sample
maybeResult <- Ptr Sample -> (Ptr Sample -> IO Sample) -> IO (Maybe Sample)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr Sample
result ((Ptr Sample -> IO Sample) -> IO (Maybe Sample))
-> (Ptr Sample -> IO Sample) -> IO (Maybe Sample)
forall a b. (a -> b) -> a -> b
$ \Ptr Sample
result' -> do
Sample
result'' <- ((ManagedPtr Sample -> Sample) -> Ptr Sample -> IO Sample
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Sample -> Sample
Gst.Sample.Sample) Ptr Sample
result'
Sample -> IO Sample
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Sample
result''
Ptr Word8 -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr Word8
imageData'
Maybe Sample -> IO (Maybe Sample)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Sample
maybeResult
foreign import ccall "gst_tag_id3_genre_get" gst_tag_id3_genre_get ::
Word32 ->
IO CString
tagId3GenreGet ::
(B.CallStack.HasCallStack, MonadIO m) =>
Word32
-> m (Maybe T.Text)
tagId3GenreGet :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Word32 -> m (Maybe Text)
tagId3GenreGet Word32
id = IO (Maybe Text) -> m (Maybe Text)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Text) -> m (Maybe Text))
-> IO (Maybe Text) -> m (Maybe Text)
forall a b. (a -> b) -> a -> b
$ do
CString
result <- Word32 -> IO CString
gst_tag_id3_genre_get Word32
id
Maybe Text
maybeResult <- CString -> (CString -> IO Text) -> IO (Maybe Text)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull CString
result ((CString -> IO Text) -> IO (Maybe Text))
-> (CString -> IO Text) -> IO (Maybe Text)
forall a b. (a -> b) -> a -> b
$ \CString
result' -> do
Text
result'' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result'
Text -> IO Text
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result''
Maybe Text -> IO (Maybe Text)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Text
maybeResult
foreign import ccall "gst_tag_id3_genre_count" gst_tag_id3_genre_count ::
IO Word32
tagId3GenreCount ::
(B.CallStack.HasCallStack, MonadIO m) =>
m Word32
tagId3GenreCount :: forall (m :: * -> *). (HasCallStack, MonadIO m) => m Word32
tagId3GenreCount = IO Word32 -> m Word32
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Word32 -> m Word32) -> IO Word32 -> m Word32
forall a b. (a -> b) -> a -> b
$ do
Word32
result <- IO Word32
gst_tag_id3_genre_count
Word32 -> IO Word32
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Word32
result
foreign import ccall "gst_tag_get_licenses" gst_tag_get_licenses ::
IO (Ptr CString)
tagGetLicenses ::
(B.CallStack.HasCallStack, MonadIO m) =>
m [T.Text]
tagGetLicenses :: forall (m :: * -> *). (HasCallStack, MonadIO m) => m [Text]
tagGetLicenses = IO [Text] -> m [Text]
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO [Text] -> m [Text]) -> IO [Text] -> m [Text]
forall a b. (a -> b) -> a -> b
$ do
Ptr CString
result <- IO (Ptr CString)
gst_tag_get_licenses
Text -> Ptr CString -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"tagGetLicenses" Ptr CString
result
[Text]
result' <- HasCallStack => Ptr CString -> IO [Text]
Ptr CString -> IO [Text]
unpackZeroTerminatedUTF8CArray Ptr CString
result
(CString -> IO ()) -> Ptr CString -> IO ()
forall a b. (Ptr a -> IO b) -> Ptr (Ptr a) -> IO ()
mapZeroTerminatedCArray CString -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CString
result
Ptr CString -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CString
result
[Text] -> IO [Text]
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return [Text]
result'
foreign import ccall "gst_tag_get_license_version" gst_tag_get_license_version ::
CString ->
IO CString
tagGetLicenseVersion ::
(B.CallStack.HasCallStack, MonadIO m) =>
T.Text
-> m (Maybe T.Text)
tagGetLicenseVersion :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Text -> m (Maybe Text)
tagGetLicenseVersion Text
licenseRef = IO (Maybe Text) -> m (Maybe Text)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Text) -> m (Maybe Text))
-> IO (Maybe Text) -> m (Maybe Text)
forall a b. (a -> b) -> a -> b
$ do
CString
licenseRef' <- Text -> IO CString
textToCString Text
licenseRef
CString
result <- CString -> IO CString
gst_tag_get_license_version CString
licenseRef'
Maybe Text
maybeResult <- CString -> (CString -> IO Text) -> IO (Maybe Text)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull CString
result ((CString -> IO Text) -> IO (Maybe Text))
-> (CString -> IO Text) -> IO (Maybe Text)
forall a b. (a -> b) -> a -> b
$ \CString
result' -> do
Text
result'' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result'
Text -> IO Text
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result''
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
licenseRef'
Maybe Text -> IO (Maybe Text)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Text
maybeResult
foreign import ccall "gst_tag_get_license_title" gst_tag_get_license_title ::
CString ->
IO CString
tagGetLicenseTitle ::
(B.CallStack.HasCallStack, MonadIO m) =>
T.Text
-> m (Maybe T.Text)
tagGetLicenseTitle :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Text -> m (Maybe Text)
tagGetLicenseTitle Text
licenseRef = IO (Maybe Text) -> m (Maybe Text)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Text) -> m (Maybe Text))
-> IO (Maybe Text) -> m (Maybe Text)
forall a b. (a -> b) -> a -> b
$ do
CString
licenseRef' <- Text -> IO CString
textToCString Text
licenseRef
CString
result <- CString -> IO CString
gst_tag_get_license_title CString
licenseRef'
Maybe Text
maybeResult <- CString -> (CString -> IO Text) -> IO (Maybe Text)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull CString
result ((CString -> IO Text) -> IO (Maybe Text))
-> (CString -> IO Text) -> IO (Maybe Text)
forall a b. (a -> b) -> a -> b
$ \CString
result' -> do
Text
result'' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result'
Text -> IO Text
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result''
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
licenseRef'
Maybe Text -> IO (Maybe Text)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Text
maybeResult
foreign import ccall "gst_tag_get_license_nick" gst_tag_get_license_nick ::
CString ->
IO CString
tagGetLicenseNick ::
(B.CallStack.HasCallStack, MonadIO m) =>
T.Text
-> m (Maybe T.Text)
tagGetLicenseNick :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Text -> m (Maybe Text)
tagGetLicenseNick Text
licenseRef = IO (Maybe Text) -> m (Maybe Text)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Text) -> m (Maybe Text))
-> IO (Maybe Text) -> m (Maybe Text)
forall a b. (a -> b) -> a -> b
$ do
CString
licenseRef' <- Text -> IO CString
textToCString Text
licenseRef
CString
result <- CString -> IO CString
gst_tag_get_license_nick CString
licenseRef'
Maybe Text
maybeResult <- CString -> (CString -> IO Text) -> IO (Maybe Text)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull CString
result ((CString -> IO Text) -> IO (Maybe Text))
-> (CString -> IO Text) -> IO (Maybe Text)
forall a b. (a -> b) -> a -> b
$ \CString
result' -> do
Text
result'' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result'
Text -> IO Text
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result''
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
licenseRef'
Maybe Text -> IO (Maybe Text)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Text
maybeResult
foreign import ccall "gst_tag_get_license_jurisdiction" gst_tag_get_license_jurisdiction ::
CString ->
IO CString
tagGetLicenseJurisdiction ::
(B.CallStack.HasCallStack, MonadIO m) =>
T.Text
-> m (Maybe T.Text)
tagGetLicenseJurisdiction :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Text -> m (Maybe Text)
tagGetLicenseJurisdiction Text
licenseRef = IO (Maybe Text) -> m (Maybe Text)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Text) -> m (Maybe Text))
-> IO (Maybe Text) -> m (Maybe Text)
forall a b. (a -> b) -> a -> b
$ do
CString
licenseRef' <- Text -> IO CString
textToCString Text
licenseRef
CString
result <- CString -> IO CString
gst_tag_get_license_jurisdiction CString
licenseRef'
Maybe Text
maybeResult <- CString -> (CString -> IO Text) -> IO (Maybe Text)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull CString
result ((CString -> IO Text) -> IO (Maybe Text))
-> (CString -> IO Text) -> IO (Maybe Text)
forall a b. (a -> b) -> a -> b
$ \CString
result' -> do
Text
result'' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result'
Text -> IO Text
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result''
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
licenseRef'
Maybe Text -> IO (Maybe Text)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Text
maybeResult
foreign import ccall "gst_tag_get_license_flags" gst_tag_get_license_flags ::
CString ->
IO CUInt
tagGetLicenseFlags ::
(B.CallStack.HasCallStack, MonadIO m) =>
T.Text
-> m [GstTag.Flags.TagLicenseFlags]
tagGetLicenseFlags :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Text -> m [TagLicenseFlags]
tagGetLicenseFlags Text
licenseRef = IO [TagLicenseFlags] -> m [TagLicenseFlags]
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO [TagLicenseFlags] -> m [TagLicenseFlags])
-> IO [TagLicenseFlags] -> m [TagLicenseFlags]
forall a b. (a -> b) -> a -> b
$ do
CString
licenseRef' <- Text -> IO CString
textToCString Text
licenseRef
CUInt
result <- CString -> IO CUInt
gst_tag_get_license_flags CString
licenseRef'
let result' :: [TagLicenseFlags]
result' = CUInt -> [TagLicenseFlags]
forall a b. (Storable a, Integral a, Bits a, IsGFlag b) => a -> [b]
wordToGFlags CUInt
result
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
licenseRef'
[TagLicenseFlags] -> IO [TagLicenseFlags]
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return [TagLicenseFlags]
result'
foreign import ccall "gst_tag_get_license_description" gst_tag_get_license_description ::
CString ->
IO CString
tagGetLicenseDescription ::
(B.CallStack.HasCallStack, MonadIO m) =>
T.Text
-> m (Maybe T.Text)
tagGetLicenseDescription :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Text -> m (Maybe Text)
tagGetLicenseDescription Text
licenseRef = IO (Maybe Text) -> m (Maybe Text)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Text) -> m (Maybe Text))
-> IO (Maybe Text) -> m (Maybe Text)
forall a b. (a -> b) -> a -> b
$ do
CString
licenseRef' <- Text -> IO CString
textToCString Text
licenseRef
CString
result <- CString -> IO CString
gst_tag_get_license_description CString
licenseRef'
Maybe Text
maybeResult <- CString -> (CString -> IO Text) -> IO (Maybe Text)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull CString
result ((CString -> IO Text) -> IO (Maybe Text))
-> (CString -> IO Text) -> IO (Maybe Text)
forall a b. (a -> b) -> a -> b
$ \CString
result' -> do
Text
result'' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result'
Text -> IO Text
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result''
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
licenseRef'
Maybe Text -> IO (Maybe Text)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Text
maybeResult
foreign import ccall "gst_tag_get_language_name" gst_tag_get_language_name ::
CString ->
IO CString
tagGetLanguageName ::
(B.CallStack.HasCallStack, MonadIO m) =>
T.Text
-> m (Maybe T.Text)
tagGetLanguageName :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Text -> m (Maybe Text)
tagGetLanguageName Text
languageCode = IO (Maybe Text) -> m (Maybe Text)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Text) -> m (Maybe Text))
-> IO (Maybe Text) -> m (Maybe Text)
forall a b. (a -> b) -> a -> b
$ do
CString
languageCode' <- Text -> IO CString
textToCString Text
languageCode
CString
result <- CString -> IO CString
gst_tag_get_language_name CString
languageCode'
Maybe Text
maybeResult <- CString -> (CString -> IO Text) -> IO (Maybe Text)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull CString
result ((CString -> IO Text) -> IO (Maybe Text))
-> (CString -> IO Text) -> IO (Maybe Text)
forall a b. (a -> b) -> a -> b
$ \CString
result' -> do
Text
result'' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result'
Text -> IO Text
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result''
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
languageCode'
Maybe Text -> IO (Maybe Text)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Text
maybeResult
foreign import ccall "gst_tag_get_language_codes" gst_tag_get_language_codes ::
IO (Ptr CString)
tagGetLanguageCodes ::
(B.CallStack.HasCallStack, MonadIO m) =>
m [T.Text]
tagGetLanguageCodes :: forall (m :: * -> *). (HasCallStack, MonadIO m) => m [Text]
tagGetLanguageCodes = IO [Text] -> m [Text]
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO [Text] -> m [Text]) -> IO [Text] -> m [Text]
forall a b. (a -> b) -> a -> b
$ do
Ptr CString
result <- IO (Ptr CString)
gst_tag_get_language_codes
Text -> Ptr CString -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"tagGetLanguageCodes" Ptr CString
result
[Text]
result' <- HasCallStack => Ptr CString -> IO [Text]
Ptr CString -> IO [Text]
unpackZeroTerminatedUTF8CArray Ptr CString
result
(CString -> IO ()) -> Ptr CString -> IO ()
forall a b. (Ptr a -> IO b) -> Ptr (Ptr a) -> IO ()
mapZeroTerminatedCArray CString -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CString
result
Ptr CString -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CString
result
[Text] -> IO [Text]
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return [Text]
result'
foreign import ccall "gst_tag_get_language_code_iso_639_2T" gst_tag_get_language_code_iso_639_2T ::
CString ->
IO CString
tagGetLanguageCodeIso6392T ::
(B.CallStack.HasCallStack, MonadIO m) =>
T.Text
-> m (Maybe T.Text)
tagGetLanguageCodeIso6392T :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Text -> m (Maybe Text)
tagGetLanguageCodeIso6392T Text
langCode = IO (Maybe Text) -> m (Maybe Text)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Text) -> m (Maybe Text))
-> IO (Maybe Text) -> m (Maybe Text)
forall a b. (a -> b) -> a -> b
$ do
CString
langCode' <- Text -> IO CString
textToCString Text
langCode
CString
result <- CString -> IO CString
gst_tag_get_language_code_iso_639_2T CString
langCode'
Maybe Text
maybeResult <- CString -> (CString -> IO Text) -> IO (Maybe Text)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull CString
result ((CString -> IO Text) -> IO (Maybe Text))
-> (CString -> IO Text) -> IO (Maybe Text)
forall a b. (a -> b) -> a -> b
$ \CString
result' -> do
Text
result'' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result'
Text -> IO Text
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result''
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
langCode'
Maybe Text -> IO (Maybe Text)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Text
maybeResult
foreign import ccall "gst_tag_get_language_code_iso_639_2B" gst_tag_get_language_code_iso_639_2B ::
CString ->
IO CString
tagGetLanguageCodeIso6392B ::
(B.CallStack.HasCallStack, MonadIO m) =>
T.Text
-> m (Maybe T.Text)
tagGetLanguageCodeIso6392B :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Text -> m (Maybe Text)
tagGetLanguageCodeIso6392B Text
langCode = IO (Maybe Text) -> m (Maybe Text)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Text) -> m (Maybe Text))
-> IO (Maybe Text) -> m (Maybe Text)
forall a b. (a -> b) -> a -> b
$ do
CString
langCode' <- Text -> IO CString
textToCString Text
langCode
CString
result <- CString -> IO CString
gst_tag_get_language_code_iso_639_2B CString
langCode'
Maybe Text
maybeResult <- CString -> (CString -> IO Text) -> IO (Maybe Text)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull CString
result ((CString -> IO Text) -> IO (Maybe Text))
-> (CString -> IO Text) -> IO (Maybe Text)
forall a b. (a -> b) -> a -> b
$ \CString
result' -> do
Text
result'' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result'
Text -> IO Text
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result''
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
langCode'
Maybe Text -> IO (Maybe Text)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Text
maybeResult
foreign import ccall "gst_tag_get_language_code_iso_639_1" gst_tag_get_language_code_iso_639_1 ::
CString ->
IO CString
tagGetLanguageCodeIso6391 ::
(B.CallStack.HasCallStack, MonadIO m) =>
T.Text
-> m (Maybe T.Text)
tagGetLanguageCodeIso6391 :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Text -> m (Maybe Text)
tagGetLanguageCodeIso6391 Text
langCode = IO (Maybe Text) -> m (Maybe Text)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Text) -> m (Maybe Text))
-> IO (Maybe Text) -> m (Maybe Text)
forall a b. (a -> b) -> a -> b
$ do
CString
langCode' <- Text -> IO CString
textToCString Text
langCode
CString
result <- CString -> IO CString
gst_tag_get_language_code_iso_639_1 CString
langCode'
Maybe Text
maybeResult <- CString -> (CString -> IO Text) -> IO (Maybe Text)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull CString
result ((CString -> IO Text) -> IO (Maybe Text))
-> (CString -> IO Text) -> IO (Maybe Text)
forall a b. (a -> b) -> a -> b
$ \CString
result' -> do
Text
result'' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result'
Text -> IO Text
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result''
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
langCode'
Maybe Text -> IO (Maybe Text)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Text
maybeResult
foreign import ccall "gst_tag_get_id3v2_tag_size" gst_tag_get_id3v2_tag_size ::
Ptr Gst.Buffer.Buffer ->
IO Word32
tagGetId3v2TagSize ::
(B.CallStack.HasCallStack, MonadIO m) =>
Gst.Buffer.Buffer
-> m Word32
tagGetId3v2TagSize :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Buffer -> m Word32
tagGetId3v2TagSize Buffer
buffer = IO Word32 -> m Word32
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Word32 -> m Word32) -> IO Word32 -> m Word32
forall a b. (a -> b) -> a -> b
$ do
Ptr Buffer
buffer' <- Buffer -> IO (Ptr Buffer)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Buffer
buffer
Word32
result <- Ptr Buffer -> IO Word32
gst_tag_get_id3v2_tag_size Ptr Buffer
buffer'
Buffer -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Buffer
buffer
Word32 -> IO Word32
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Word32
result
foreign import ccall "gst_tag_from_vorbis_tag" gst_tag_from_vorbis_tag ::
CString ->
IO CString
tagFromVorbisTag ::
(B.CallStack.HasCallStack, MonadIO m) =>
T.Text
-> m (Maybe T.Text)
tagFromVorbisTag :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Text -> m (Maybe Text)
tagFromVorbisTag Text
vorbisTag = IO (Maybe Text) -> m (Maybe Text)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Text) -> m (Maybe Text))
-> IO (Maybe Text) -> m (Maybe Text)
forall a b. (a -> b) -> a -> b
$ do
CString
vorbisTag' <- Text -> IO CString
textToCString Text
vorbisTag
CString
result <- CString -> IO CString
gst_tag_from_vorbis_tag CString
vorbisTag'
Maybe Text
maybeResult <- CString -> (CString -> IO Text) -> IO (Maybe Text)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull CString
result ((CString -> IO Text) -> IO (Maybe Text))
-> (CString -> IO Text) -> IO (Maybe Text)
forall a b. (a -> b) -> a -> b
$ \CString
result' -> do
Text
result'' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result'
Text -> IO Text
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result''
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
vorbisTag'
Maybe Text -> IO (Maybe Text)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Text
maybeResult
foreign import ccall "gst_tag_from_id3_user_tag" gst_tag_from_id3_user_tag ::
CString ->
CString ->
IO CString
tagFromId3UserTag ::
(B.CallStack.HasCallStack, MonadIO m) =>
T.Text
-> T.Text
-> m (Maybe T.Text)
tagFromId3UserTag :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Text -> Text -> m (Maybe Text)
tagFromId3UserTag Text
type_ Text
id3UserTag = IO (Maybe Text) -> m (Maybe Text)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Text) -> m (Maybe Text))
-> IO (Maybe Text) -> m (Maybe Text)
forall a b. (a -> b) -> a -> b
$ do
CString
type_' <- Text -> IO CString
textToCString Text
type_
CString
id3UserTag' <- Text -> IO CString
textToCString Text
id3UserTag
CString
result <- CString -> CString -> IO CString
gst_tag_from_id3_user_tag CString
type_' CString
id3UserTag'
Maybe Text
maybeResult <- CString -> (CString -> IO Text) -> IO (Maybe Text)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull CString
result ((CString -> IO Text) -> IO (Maybe Text))
-> (CString -> IO Text) -> IO (Maybe Text)
forall a b. (a -> b) -> a -> b
$ \CString
result' -> do
Text
result'' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result'
Text -> IO Text
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result''
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
type_'
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
id3UserTag'
Maybe Text -> IO (Maybe Text)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Text
maybeResult
foreign import ccall "gst_tag_from_id3_tag" gst_tag_from_id3_tag ::
CString ->
IO CString
tagFromId3Tag ::
(B.CallStack.HasCallStack, MonadIO m) =>
T.Text
-> m (Maybe T.Text)
tagFromId3Tag :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Text -> m (Maybe Text)
tagFromId3Tag Text
id3Tag = IO (Maybe Text) -> m (Maybe Text)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Text) -> m (Maybe Text))
-> IO (Maybe Text) -> m (Maybe Text)
forall a b. (a -> b) -> a -> b
$ do
CString
id3Tag' <- Text -> IO CString
textToCString Text
id3Tag
CString
result <- CString -> IO CString
gst_tag_from_id3_tag CString
id3Tag'
Maybe Text
maybeResult <- CString -> (CString -> IO Text) -> IO (Maybe Text)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull CString
result ((CString -> IO Text) -> IO (Maybe Text))
-> (CString -> IO Text) -> IO (Maybe Text)
forall a b. (a -> b) -> a -> b
$ \CString
result' -> do
Text
result'' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result'
Text -> IO Text
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result''
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
id3Tag'
Maybe Text -> IO (Maybe Text)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Text
maybeResult
foreign import ccall "gst_tag_freeform_string_to_utf8" gst_tag_freeform_string_to_utf8 ::
Ptr Int8 ->
Int32 ->
Ptr CString ->
IO CString
tagFreeformStringToUtf8 ::
(B.CallStack.HasCallStack, MonadIO m) =>
[Int8]
-> [T.Text]
-> m (Maybe T.Text)
tagFreeformStringToUtf8 :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
[Int8] -> [Text] -> m (Maybe Text)
tagFreeformStringToUtf8 [Int8]
data_ [Text]
envVars = IO (Maybe Text) -> m (Maybe Text)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Text) -> m (Maybe Text))
-> IO (Maybe Text) -> m (Maybe Text)
forall a b. (a -> b) -> a -> b
$ do
let size :: Int32
size = Int -> Int32
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> Int32) -> Int -> Int32
forall a b. (a -> b) -> a -> b
$ [Int8] -> Int
forall a. [a] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
P.length [Int8]
data_
Ptr Int8
data_' <- [Int8] -> IO (Ptr Int8)
forall a. Storable a => [a] -> IO (Ptr a)
packStorableArray [Int8]
data_
Ptr CString
envVars' <- [Text] -> IO (Ptr CString)
packZeroTerminatedUTF8CArray [Text]
envVars
CString
result <- Ptr Int8 -> Int32 -> Ptr CString -> IO CString
gst_tag_freeform_string_to_utf8 Ptr Int8
data_' Int32
size Ptr CString
envVars'
Maybe Text
maybeResult <- CString -> (CString -> IO Text) -> IO (Maybe Text)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull CString
result ((CString -> IO Text) -> IO (Maybe Text))
-> (CString -> IO Text) -> IO (Maybe Text)
forall a b. (a -> b) -> a -> b
$ \CString
result' -> do
Text
result'' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result'
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
result'
Text -> IO Text
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result''
Ptr Int8 -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr Int8
data_'
(CString -> IO ()) -> Ptr CString -> IO ()
forall a b. (Ptr a -> IO b) -> Ptr (Ptr a) -> IO ()
mapZeroTerminatedCArray CString -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CString
envVars'
Ptr CString -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CString
envVars'
Maybe Text -> IO (Maybe Text)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Text
maybeResult
foreign import ccall "gst_tag_check_language_code" gst_tag_check_language_code ::
CString ->
IO CInt
tagCheckLanguageCode ::
(B.CallStack.HasCallStack, MonadIO m) =>
T.Text
-> m Bool
tagCheckLanguageCode :: forall (m :: * -> *). (HasCallStack, MonadIO m) => Text -> m Bool
tagCheckLanguageCode Text
langCode = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
CString
langCode' <- Text -> IO CString
textToCString Text
langCode
CInt
result <- CString -> IO CInt
gst_tag_check_language_code CString
langCode'
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
langCode'
Bool -> IO Bool
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'