gi-gsttag 1.0.15 → 1.0.17

raw patch · 20 files changed

+3708/−10 lines, 20 filesdep ~haskell-gidep ~haskell-gi-basePVP: major bump suggested

API removals or changes: PVP suggests a major version bump

Dependency ranges changed: haskell-gi, haskell-gi-base

API changes (from Hackage documentation)

Files

• ChangeLog.md +8/−0
• GI/GstTag.hs +56/−0
• GI/GstTag/Constants.hs +342/−0
• GI/GstTag/Enums.hs +238/−0
• GI/GstTag/Enums.hs-boot +30/−0
• GI/GstTag/Flags.hs +173/−0
• GI/GstTag/Flags.hs-boot +28/−0
• GI/GstTag/Functions.hs +1646/−0
• GI/GstTag/Interfaces.hs +41/−0
• GI/GstTag/Interfaces/TagXmpWriter.hs +499/−0
• GI/GstTag/Interfaces/TagXmpWriter.hs-boot +47/−0
• GI/GstTag/Objects.hs +43/−0
• GI/GstTag/Objects/TagDemux.hs +236/−0
• GI/GstTag/Objects/TagDemux.hs-boot +29/−0
• GI/GstTag/Objects/TagMux.hs +228/−0
• GI/GstTag/Objects/TagMux.hs-boot +29/−0
• LICENSE +14/−0
• README.md +1/−1
• gi-gsttag.cabal +19/−8
• stack.yaml +1/−1

@@ -1,3 +1,11 @@+### 1.0.17+++ Update to haskell-gi(-base) 0.22++### 1.0.16+++ Update stack version to 12.10+ ### 1.0.15  + Remove enable-overloading flags, and use instead explicit CPP checks for 'haskell-gi-overloading-1.0', see [how to disable overloading](https://github.com/haskell-gi/haskell-gi/wiki/Overloading\#disabling-overloading).

@@ -0,0 +1,56 @@+++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc)+-}++#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \+       && !defined(__HADDOCK_VERSION__))++module GI.GstTag+    (     module GI.GstTag.Constants              ,+    module GI.GstTag.Enums                  ,+    module GI.GstTag.Flags                  ,+    module GI.GstTag.Functions              ,+    module GI.GstTag.Interfaces             ,+    module GI.GstTag.Objects                ,++++    module Data.GI.Base                     ,+++    ) where++import GI.GstTag.Constants+import GI.GstTag.Enums+import GI.GstTag.Flags+import GI.GstTag.Functions+import GI.GstTag.Interfaces+import GI.GstTag.Objects++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.ManagedPtr as B.ManagedPtr+import qualified Data.GI.Base.GClosure as B.GClosure+import qualified Data.GI.Base.GError as B.GError+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.Text as T+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 Data.GI.Base+

@@ -0,0 +1,342 @@+{-# LANGUAGE PatternSynonyms, ScopedTypeVariables, ViewPatterns #-}+++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc)+-}++#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \+       && !defined(__HADDOCK_VERSION__))++module GI.GstTag.Constants+    ( +    pattern TAG_MUSICBRAINZ_TRMID           ,+    pattern TAG_MUSICBRAINZ_TRACKID         ,+    pattern TAG_MUSICBRAINZ_ARTISTID        ,+    pattern TAG_MUSICBRAINZ_ALBUMID         ,+    pattern TAG_MUSICBRAINZ_ALBUMARTISTID   ,+    pattern TAG_MUSICAL_KEY                 ,+    pattern TAG_IMAGE_VERTICAL_PPI          ,+    pattern TAG_IMAGE_HORIZONTAL_PPI        ,+    pattern TAG_ID3V2_HEADER_SIZE           ,+    pattern TAG_CMML_STREAM                 ,+    pattern TAG_CMML_HEAD                   ,+    pattern TAG_CMML_CLIP                   ,+    pattern TAG_CDDA_MUSICBRAINZ_DISCID_FULL,+    pattern TAG_CDDA_MUSICBRAINZ_DISCID     ,+    pattern TAG_CDDA_CDDB_DISCID_FULL       ,+    pattern TAG_CDDA_CDDB_DISCID            ,+    pattern TAG_CAPTURING_WHITE_BALANCE     ,+    pattern TAG_CAPTURING_SOURCE            ,+    pattern TAG_CAPTURING_SHUTTER_SPEED     ,+    pattern TAG_CAPTURING_SHARPNESS         ,+    pattern TAG_CAPTURING_SCENE_CAPTURE_TYPE,+    pattern TAG_CAPTURING_SATURATION        ,+    pattern TAG_CAPTURING_METERING_MODE     ,+    pattern TAG_CAPTURING_ISO_SPEED         ,+    pattern TAG_CAPTURING_GAIN_ADJUSTMENT   ,+    pattern TAG_CAPTURING_FOCAL_RATIO       ,+    pattern TAG_CAPTURING_FOCAL_LENGTH_35_MM,+    pattern TAG_CAPTURING_FOCAL_LENGTH      ,+    pattern TAG_CAPTURING_FLASH_MODE        ,+    pattern TAG_CAPTURING_FLASH_FIRED       ,+    pattern TAG_CAPTURING_EXPOSURE_PROGRAM  ,+    pattern TAG_CAPTURING_EXPOSURE_MODE     ,+    pattern TAG_CAPTURING_EXPOSURE_COMPENSATION,+    pattern TAG_CAPTURING_DIGITAL_ZOOM_RATIO,+    pattern TAG_CAPTURING_CONTRAST          ,++    ) 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.ManagedPtr as B.ManagedPtr+import qualified Data.GI.Base.GClosure as B.GClosure+import qualified Data.GI.Base.GError as B.GError+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.Text as T+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+++{- |+MusicBrainz track TRM ID+-}+pattern TAG_MUSICBRAINZ_TRMID = "musicbrainz-trmid" :: T.Text++{- |+MusicBrainz track ID+-}+pattern TAG_MUSICBRAINZ_TRACKID = "musicbrainz-trackid" :: T.Text++{- |+MusicBrainz artist ID+-}+pattern TAG_MUSICBRAINZ_ARTISTID = "musicbrainz-artistid" :: T.Text++{- |+MusicBrainz album ID+-}+pattern TAG_MUSICBRAINZ_ALBUMID = "musicbrainz-albumid" :: T.Text++{- |+MusicBrainz album artist ID+-}+pattern TAG_MUSICBRAINZ_ALBUMARTISTID = "musicbrainz-albumartistid" :: T.Text++{- |+Musical key in which the sound starts. It is represented as a string+with a maximum length of three characters. The ground keys are+represented with \"A\",\"B\",\"C\",\"D\",\"E\", \"F\" and \"G\" and halfkeys+represented with \"b\" and \"#\". Minor is represented as \"m\" (e.g. \"Dbm\").+Off key is represented with an \"o\" only.+This notation might be extended in the future to support non-minor\/major+keys.++/Since: 1.2/+-}+pattern TAG_MUSICAL_KEY = "musical-key" :: T.Text++{- |+Media (image\/video) intended vertical pixel density in ppi. (double)+-}+pattern TAG_IMAGE_VERTICAL_PPI = "image-vertical-ppi" :: T.Text++{- |+Media (image\/video) intended horizontal pixel density in ppi. (double)+-}+pattern TAG_IMAGE_HORIZONTAL_PPI = "image-horizontal-ppi" :: T.Text++{- |+ID3V2 header size considered minimum input for some functions such as+'GI.GstTag.Functions.tagListFromId3v2Tag' and 'GI.GstTag.Functions.tagGetId3v2TagSize' for example.+-}+pattern TAG_ID3V2_HEADER_SIZE = 10 :: Int32++{- |+Annodex CMML stream element tag+-}+pattern TAG_CMML_STREAM = "cmml-stream" :: T.Text++{- |+Annodex CMML head element tag+-}+pattern TAG_CMML_HEAD = "cmml-head" :: T.Text++{- |+Annodex CMML clip element tag+-}+pattern TAG_CMML_CLIP = "cmml-clip" :: T.Text++{- |+Musicbrainz disc id details+-}+pattern TAG_CDDA_MUSICBRAINZ_DISCID_FULL = "musicbrainz-discid-full" :: T.Text++{- |+Musicbrainz disc id (e.g. \'ahg7JUcfR3vCYBphSDIogOOWrr0-\')+-}+pattern TAG_CDDA_MUSICBRAINZ_DISCID = "musicbrainz-discid" :: T.Text++{- |+CDDB disc id including all details+-}+pattern TAG_CDDA_CDDB_DISCID_FULL = "discid-full" :: T.Text++{- |+CDDB disc id in its short form (e.g. \'aa063d0f\')+-}+pattern TAG_CDDA_CDDB_DISCID = "discid" :: T.Text++{- |+White balance mode used when capturing an image. (string)++The allowed values are:+  \"auto\"+  \"manual\"+  \"daylight\"+  \"cloudy\"+  \"tungsten\"+  \"fluorescent\"+  \"fluorescent h\" (newer daylight-calibrated fluorescents)+  \"flash\"+-}+pattern TAG_CAPTURING_WHITE_BALANCE = "capturing-white-balance" :: T.Text++{- |+Indicates the source of capture. The device\/medium used to do the+capture. (string)++Allowed values are:+  \"dsc\" (= digital still camera)+  \"transparent-scanner\"+  \"reflex-scanner\"+  \"other\"+-}+pattern TAG_CAPTURING_SOURCE = "capturing-source" :: T.Text++{- |+Shutter speed used when capturing an image, in seconds. (fraction)+-}+pattern TAG_CAPTURING_SHUTTER_SPEED = "capturing-shutter-speed" :: T.Text++{- |+Direction of sharpness processing applied when capturing an image. (string)++The allowed values are:+ \"normal\"+ \"soft\"+ \"hard\"+-}+pattern TAG_CAPTURING_SHARPNESS = "capturing-sharpness" :: T.Text++{- |+Scene mode used when capturing an image. (string)++The allowed values are:+  \"standard\"+  \"landscape\"+  \"portrait\"+  \"night-scene\"+-}+pattern TAG_CAPTURING_SCENE_CAPTURE_TYPE = "capturing-scene-capture-type" :: T.Text++{- |+Direction of saturation processing applied when capturing an image. (string)++The allowed values are:+ \"normal\"+ \"low-saturation\"+ \"high-saturation\"+-}+pattern TAG_CAPTURING_SATURATION = "capturing-saturation" :: T.Text++{- |+Defines the way a camera determines the exposure. (string)++The allowed values are:+  \"unknown\"+  \"average\"+  \"center-weighted-average\"+  \"spot\"+  \"multi-spot\"+  \"pattern\"+  \"partial\"+  \"other\"+-}+pattern TAG_CAPTURING_METERING_MODE = "capturing-metering-mode" :: T.Text++{- |+ISO speed used when capturing an image. (integer)+-}+pattern TAG_CAPTURING_ISO_SPEED = "capturing-iso-speed" :: T.Text++{- |+Gain adjustment applied to an image. (string)++The allowed values are:+  \"none\"+  \"low-gain-up\"+  \"high-gain-up\"+  \"low-gain-down\"+  \"high-gain-down\"+-}+pattern TAG_CAPTURING_GAIN_ADJUSTMENT = "capturing-gain-adjustment" :: T.Text++{- |+Focal ratio (f-number) used when capturing an image. (double)++The value stored is the denominator of the focal ratio (f-number).+For example, if this tag value is 2, the focal ratio is f\/2.+-}+pattern TAG_CAPTURING_FOCAL_RATIO = "capturing-focal-ratio" :: T.Text++{- |+35 mm equivalent focal length used when capturing an image, in mm. (double)++/Since: 1.10/+-}+pattern TAG_CAPTURING_FOCAL_LENGTH_35_MM = "capturing-focal-length-35mm" :: T.Text++{- |+Focal length used when capturing an image, in mm. (double)+-}+pattern TAG_CAPTURING_FOCAL_LENGTH = "capturing-focal-length" :: T.Text++{- |+The flash mode selected during the capture of an image. (string)++The allowed values are:+ \"auto\"+ \"always\"+ \"never\"+-}+pattern TAG_CAPTURING_FLASH_MODE = "capturing-flash-mode" :: T.Text++{- |+If flash was fired during the capture of an image. (boolean)++Note that if this tag isn\'t present, it should not be assumed that+the flash did not fire. It should be treated as unknown.+-}+pattern TAG_CAPTURING_FLASH_FIRED = "capturing-flash-fired" :: T.Text++{- |+Type of exposure control used when capturing an image. (string)++The allowed values are:+  \"undefined\"+  \"manual\"+  \"normal\" - automatically controlled+  \"aperture-priority\" - user selects aperture value+  \"shutter-priority\" - user selects shutter speed+  \"creative\" - biased towards depth of field+  \"action\" - biased towards fast shutter speed+  \"portrait\" - closeup, leaving background out of focus+  \"landscape\" - landscape photos, background in focus+-}+pattern TAG_CAPTURING_EXPOSURE_PROGRAM = "capturing-exposure-program" :: T.Text++{- |+Exposure mode used when capturing an image. (string)++The allowed values are:+  \"auto-exposure\"+  \"manual-exposure\"+  \"auto-bracket\"+-}+pattern TAG_CAPTURING_EXPOSURE_MODE = "capturing-exposure-mode" :: T.Text++{- |+Exposure compensation using when capturing an image in EV. (double)+-}+pattern TAG_CAPTURING_EXPOSURE_COMPENSATION = "capturing-exposure-compensation" :: T.Text++{- |+Digital zoom ratio used when capturing an image. (double)+-}+pattern TAG_CAPTURING_DIGITAL_ZOOM_RATIO = "capturing-digital-zoom-ratio" :: T.Text++{- |+Direction of contrast processing applied when capturing an image. (string)++The allowed values are:+ \"normal\"+ \"soft\"+ \"hard\"+-}+pattern TAG_CAPTURING_CONTRAST = "capturing-contrast" :: T.Text++

@@ -0,0 +1,238 @@+++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc)+-}++#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \+       && !defined(__HADDOCK_VERSION__))++module GI.GstTag.Enums+    ( ++ -- * Enumerations+-- ** TagDemuxResult #enum:TagDemuxResult#++    TagDemuxResult(..)                      ,+++-- ** TagImageType #enum:TagImageType#++    TagImageType(..)                        ,+++++    ) 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.ManagedPtr as B.ManagedPtr+import qualified Data.GI.Base.GClosure as B.GClosure+import qualified Data.GI.Base.GError as B.GError+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.Text as T+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+++-- Enum TagImageType+{- |+Type of image contained in an image tag (specified as \"image-type\" field in+the info structure in the image\'s 'GI.Gst.Structs.Sample.Sample')+-}+data TagImageType = +      TagImageTypeNone+    {- ^+    No image type. Can be used to+         tell functions such as 'GI.GstTag.Functions.tagImageDataToImageSample' that no+         image type should be set.+    -}+    | TagImageTypeUndefined+    {- ^+    Undefined\/other image type+    -}+    | TagImageTypeFrontCover+    {- ^+    Cover (front)+    -}+    | TagImageTypeBackCover+    {- ^+    Cover (back)+    -}+    | TagImageTypeLeafletPage+    {- ^+    Leaflet page+    -}+    | TagImageTypeMedium+    {- ^+    Medium (e.g. label side of CD)+    -}+    | TagImageTypeLeadArtist+    {- ^+    Lead artist\/lead performer\/soloist+    -}+    | TagImageTypeArtist+    {- ^+    Artist\/performer+    -}+    | TagImageTypeConductor+    {- ^+    Conductor+    -}+    | TagImageTypeBandOrchestra+    {- ^+    Band\/orchestra+    -}+    | TagImageTypeComposer+    {- ^+    Composer+    -}+    | TagImageTypeLyricist+    {- ^+    Lyricist\/text writer+    -}+    | TagImageTypeRecordingLocation+    {- ^+    Recording location+    -}+    | TagImageTypeDuringRecording+    {- ^+    During recording+    -}+    | TagImageTypeDuringPerformance+    {- ^+    During performance+    -}+    | TagImageTypeVideoCapture+    {- ^+    Movie\/video screen capture+    -}+    | TagImageTypeFish+    {- ^+    A fish as funny as the ID3v2 spec+    -}+    | TagImageTypeIllustration+    {- ^+    Illustration+    -}+    | TagImageTypeBandArtistLogo+    {- ^+    Band\/artist logotype+    -}+    | TagImageTypePublisherStudioLogo+    {- ^+    Publisher\/studio logotype+    -}+    | AnotherTagImageType Int+    -- ^ Catch-all for unknown values+    deriving (Show, Eq)++instance P.Enum TagImageType where+    fromEnum TagImageTypeNone = -1+    fromEnum TagImageTypeUndefined = 0+    fromEnum TagImageTypeFrontCover = 1+    fromEnum TagImageTypeBackCover = 2+    fromEnum TagImageTypeLeafletPage = 3+    fromEnum TagImageTypeMedium = 4+    fromEnum TagImageTypeLeadArtist = 5+    fromEnum TagImageTypeArtist = 6+    fromEnum TagImageTypeConductor = 7+    fromEnum TagImageTypeBandOrchestra = 8+    fromEnum TagImageTypeComposer = 9+    fromEnum TagImageTypeLyricist = 10+    fromEnum TagImageTypeRecordingLocation = 11+    fromEnum TagImageTypeDuringRecording = 12+    fromEnum TagImageTypeDuringPerformance = 13+    fromEnum TagImageTypeVideoCapture = 14+    fromEnum TagImageTypeFish = 15+    fromEnum TagImageTypeIllustration = 16+    fromEnum TagImageTypeBandArtistLogo = 17+    fromEnum TagImageTypePublisherStudioLogo = 18+    fromEnum (AnotherTagImageType k) = k++    toEnum -1 = TagImageTypeNone+    toEnum 0 = TagImageTypeUndefined+    toEnum 1 = TagImageTypeFrontCover+    toEnum 2 = TagImageTypeBackCover+    toEnum 3 = TagImageTypeLeafletPage+    toEnum 4 = TagImageTypeMedium+    toEnum 5 = TagImageTypeLeadArtist+    toEnum 6 = TagImageTypeArtist+    toEnum 7 = TagImageTypeConductor+    toEnum 8 = TagImageTypeBandOrchestra+    toEnum 9 = TagImageTypeComposer+    toEnum 10 = TagImageTypeLyricist+    toEnum 11 = TagImageTypeRecordingLocation+    toEnum 12 = TagImageTypeDuringRecording+    toEnum 13 = TagImageTypeDuringPerformance+    toEnum 14 = TagImageTypeVideoCapture+    toEnum 15 = TagImageTypeFish+    toEnum 16 = TagImageTypeIllustration+    toEnum 17 = TagImageTypeBandArtistLogo+    toEnum 18 = TagImageTypePublisherStudioLogo+    toEnum k = AnotherTagImageType k++instance P.Ord TagImageType where+    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)++foreign import ccall "gst_tag_image_type_get_type" c_gst_tag_image_type_get_type :: +    IO GType++instance BoxedEnum TagImageType where+    boxedEnumType _ = c_gst_tag_image_type_get_type++-- Enum TagDemuxResult+{- |+Result values from the parse_tag virtual function.+-}+data TagDemuxResult = +      TagDemuxResultBrokenTag+    {- ^+    cannot parse tag, just skip it+    -}+    | TagDemuxResultAgain+    {- ^+    call again with less or more data+    -}+    | TagDemuxResultOk+    {- ^+    parsed tag successfully+    -}+    | AnotherTagDemuxResult Int+    -- ^ Catch-all for unknown values+    deriving (Show, Eq)++instance P.Enum TagDemuxResult where+    fromEnum TagDemuxResultBrokenTag = 0+    fromEnum TagDemuxResultAgain = 1+    fromEnum TagDemuxResultOk = 2+    fromEnum (AnotherTagDemuxResult k) = k++    toEnum 0 = TagDemuxResultBrokenTag+    toEnum 1 = TagDemuxResultAgain+    toEnum 2 = TagDemuxResultOk+    toEnum k = AnotherTagDemuxResult k++instance P.Ord TagDemuxResult where+    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)++foreign import ccall "gst_tag_demux_result_get_type" c_gst_tag_demux_result_get_type :: +    IO GType++instance BoxedEnum TagDemuxResult where+    boxedEnumType _ = c_gst_tag_demux_result_get_type++

@@ -0,0 +1,30 @@+#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \+       && !defined(__HADDOCK_VERSION__))+module GI.GstTag.Enums 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.ManagedPtr as B.ManagedPtr+import qualified Data.GI.Base.GClosure as B.GClosure+import qualified Data.GI.Base.GError as B.GError+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.Text as T+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++data TagImageType+instance P.Enum TagImageType where+instance BoxedEnum TagImageType where+data TagDemuxResult+instance P.Enum TagDemuxResult where+instance BoxedEnum TagDemuxResult where

@@ -0,0 +1,173 @@+++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc)+-}++#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \+       && !defined(__HADDOCK_VERSION__))++module GI.GstTag.Flags+    ( ++ -- * Flags+-- ** TagLicenseFlags #flag:TagLicenseFlags#++    TagLicenseFlags(..)                     ,+++++    ) 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.ManagedPtr as B.ManagedPtr+import qualified Data.GI.Base.GClosure as B.GClosure+import qualified Data.GI.Base.GError as B.GError+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.Text as T+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+++-- Flags TagLicenseFlags+{- |+See http:\/\/creativecommons.org\/ns for more information.+-}+data TagLicenseFlags = +      TagLicenseFlagsPermitsReproduction+    {- ^+    making multiple copies+        is allowed+    -}+    | TagLicenseFlagsPermitsDistribution+    {- ^+    distribution, public display+        and public performance are allowed+    -}+    | TagLicenseFlagsPermitsDerivativeWorks+    {- ^+    distribution of derivative+        works is allowed+    -}+    | TagLicenseFlagsPermitsSharing+    {- ^+    commercial derivatives are allowed,+        but only non-commercial distribution is allowed+    -}+    | TagLicenseFlagsRequiresNotice+    {- ^+    copyright and license notices+        must be kept intact+    -}+    | TagLicenseFlagsRequiresAttribution+    {- ^+    credit must be given to+        copyright holder and\/or author+    -}+    | TagLicenseFlagsRequiresShareAlike+    {- ^+    derivative works must be+        licensed under the same terms or compatible terms as the original work+    -}+    | TagLicenseFlagsRequiresSourceCode+    {- ^+    source code (the preferred+        form for making modifications) must be provided when exercising some+        rights granted by the license+    -}+    | TagLicenseFlagsRequiresCopyleft+    {- ^+    derivative and combined works+        must be licensed under specified terms, similar to those of the original+        work+    -}+    | TagLicenseFlagsRequiresLesserCopyleft+    {- ^+    derivative works must be+        licensed under specified terms, with at least the same conditions as+        the original work; combinations with the work may be licensed under+        different terms+    -}+    | TagLicenseFlagsProhibitsCommercialUse+    {- ^+    exercising rights for+        commercial purposes is prohibited+    -}+    | TagLicenseFlagsProhibitsHighIncomeNationUse+    {- ^+    use in a+        non-developing country is prohibited+    -}+    | TagLicenseFlagsCreativeCommonsLicense+    {- ^+    this license was created+        by the Creative Commons project+    -}+    | TagLicenseFlagsFreeSoftwareFoundationLicense+    {- ^+    this license was+        created by the Free Software Foundation (FSF)+    -}+    | AnotherTagLicenseFlags Int+    -- ^ Catch-all for unknown values+    deriving (Show, Eq)++instance P.Enum TagLicenseFlags where+    fromEnum TagLicenseFlagsPermitsReproduction = 1+    fromEnum TagLicenseFlagsPermitsDistribution = 2+    fromEnum TagLicenseFlagsPermitsDerivativeWorks = 4+    fromEnum TagLicenseFlagsPermitsSharing = 8+    fromEnum TagLicenseFlagsRequiresNotice = 256+    fromEnum TagLicenseFlagsRequiresAttribution = 512+    fromEnum TagLicenseFlagsRequiresShareAlike = 1024+    fromEnum TagLicenseFlagsRequiresSourceCode = 2048+    fromEnum TagLicenseFlagsRequiresCopyleft = 4096+    fromEnum TagLicenseFlagsRequiresLesserCopyleft = 8192+    fromEnum TagLicenseFlagsProhibitsCommercialUse = 65536+    fromEnum TagLicenseFlagsProhibitsHighIncomeNationUse = 131072+    fromEnum TagLicenseFlagsCreativeCommonsLicense = 16777216+    fromEnum TagLicenseFlagsFreeSoftwareFoundationLicense = 33554432+    fromEnum (AnotherTagLicenseFlags k) = k++    toEnum 1 = TagLicenseFlagsPermitsReproduction+    toEnum 2 = TagLicenseFlagsPermitsDistribution+    toEnum 4 = TagLicenseFlagsPermitsDerivativeWorks+    toEnum 8 = TagLicenseFlagsPermitsSharing+    toEnum 256 = TagLicenseFlagsRequiresNotice+    toEnum 512 = TagLicenseFlagsRequiresAttribution+    toEnum 1024 = TagLicenseFlagsRequiresShareAlike+    toEnum 2048 = TagLicenseFlagsRequiresSourceCode+    toEnum 4096 = TagLicenseFlagsRequiresCopyleft+    toEnum 8192 = TagLicenseFlagsRequiresLesserCopyleft+    toEnum 65536 = TagLicenseFlagsProhibitsCommercialUse+    toEnum 131072 = TagLicenseFlagsProhibitsHighIncomeNationUse+    toEnum 16777216 = TagLicenseFlagsCreativeCommonsLicense+    toEnum 33554432 = TagLicenseFlagsFreeSoftwareFoundationLicense+    toEnum k = AnotherTagLicenseFlags k++instance P.Ord TagLicenseFlags where+    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)++foreign import ccall "gst_tag_license_flags_get_type" c_gst_tag_license_flags_get_type :: +    IO GType++instance BoxedFlags TagLicenseFlags where+    boxedFlagsType _ = c_gst_tag_license_flags_get_type++instance IsGFlag TagLicenseFlags++

@@ -0,0 +1,28 @@+#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \+       && !defined(__HADDOCK_VERSION__))+module GI.GstTag.Flags 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.ManagedPtr as B.ManagedPtr+import qualified Data.GI.Base.GClosure as B.GClosure+import qualified Data.GI.Base.GError as B.GError+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.Text as T+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++data TagLicenseFlags+instance P.Enum TagLicenseFlags where+instance BoxedFlags TagLicenseFlags where+instance IsGFlag TagLicenseFlags

@@ -0,0 +1,1646 @@+++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc)+-}++#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \+       && !defined(__HADDOCK_VERSION__))++module GI.GstTag.Functions+    ( ++ -- * Methods+-- ** tagCheckLanguageCode #method:tagCheckLanguageCode#++    tagCheckLanguageCode                    ,+++-- ** tagFreeformStringToUtf8 #method:tagFreeformStringToUtf8#++    tagFreeformStringToUtf8                 ,+++-- ** tagFromId3Tag #method:tagFromId3Tag#++    tagFromId3Tag                           ,+++-- ** tagFromId3UserTag #method:tagFromId3UserTag#++    tagFromId3UserTag                       ,+++-- ** tagFromVorbisTag #method:tagFromVorbisTag#++    tagFromVorbisTag                        ,+++-- ** tagGetId3v2TagSize #method:tagGetId3v2TagSize#++    tagGetId3v2TagSize                      ,+++-- ** tagGetLanguageCodeIso6391 #method:tagGetLanguageCodeIso6391#++    tagGetLanguageCodeIso6391               ,+++-- ** tagGetLanguageCodeIso6392B #method:tagGetLanguageCodeIso6392B#++    tagGetLanguageCodeIso6392B              ,+++-- ** tagGetLanguageCodeIso6392T #method:tagGetLanguageCodeIso6392T#++    tagGetLanguageCodeIso6392T              ,+++-- ** tagGetLanguageCodes #method:tagGetLanguageCodes#++    tagGetLanguageCodes                     ,+++-- ** tagGetLanguageName #method:tagGetLanguageName#++    tagGetLanguageName                      ,+++-- ** tagGetLicenseDescription #method:tagGetLicenseDescription#++    tagGetLicenseDescription                ,+++-- ** tagGetLicenseFlags #method:tagGetLicenseFlags#++    tagGetLicenseFlags                      ,+++-- ** tagGetLicenseJurisdiction #method:tagGetLicenseJurisdiction#++    tagGetLicenseJurisdiction               ,+++-- ** tagGetLicenseNick #method:tagGetLicenseNick#++    tagGetLicenseNick                       ,+++-- ** tagGetLicenseTitle #method:tagGetLicenseTitle#++    tagGetLicenseTitle                      ,+++-- ** tagGetLicenseVersion #method:tagGetLicenseVersion#++    tagGetLicenseVersion                    ,+++-- ** tagGetLicenses #method:tagGetLicenses#++    tagGetLicenses                          ,+++-- ** tagId3GenreCount #method:tagId3GenreCount#++    tagId3GenreCount                        ,+++-- ** tagId3GenreGet #method:tagId3GenreGet#++    tagId3GenreGet                          ,+++-- ** tagImageDataToImageSample #method:tagImageDataToImageSample#++    tagImageDataToImageSample               ,+++-- ** tagListAddId3Image #method:tagListAddId3Image#++    tagListAddId3Image                      ,+++-- ** tagListFromExifBuffer #method:tagListFromExifBuffer#++    tagListFromExifBuffer                   ,+++-- ** tagListFromExifBufferWithTiffHeader #method:tagListFromExifBufferWithTiffHeader#++    tagListFromExifBufferWithTiffHeader     ,+++-- ** tagListFromId3v2Tag #method:tagListFromId3v2Tag#++    tagListFromId3v2Tag                     ,+++-- ** tagListFromVorbiscomment #method:tagListFromVorbiscomment#++    tagListFromVorbiscomment                ,+++-- ** tagListFromVorbiscommentBuffer #method:tagListFromVorbiscommentBuffer#++    tagListFromVorbiscommentBuffer          ,+++-- ** tagListFromXmpBuffer #method:tagListFromXmpBuffer#++    tagListFromXmpBuffer                    ,+++-- ** tagListNewFromId3v1 #method:tagListNewFromId3v1#++    tagListNewFromId3v1                     ,+++-- ** tagListToExifBuffer #method:tagListToExifBuffer#++    tagListToExifBuffer                     ,+++-- ** tagListToExifBufferWithTiffHeader #method:tagListToExifBufferWithTiffHeader#++    tagListToExifBufferWithTiffHeader       ,+++-- ** tagListToVorbiscommentBuffer #method:tagListToVorbiscommentBuffer#++    tagListToVorbiscommentBuffer            ,+++-- ** tagListToXmpBuffer #method:tagListToXmpBuffer#++    tagListToXmpBuffer                      ,+++-- ** tagParseExtendedComment #method:tagParseExtendedComment#++    tagParseExtendedComment                 ,+++-- ** tagRegisterMusicbrainzTags #method:tagRegisterMusicbrainzTags#++    tagRegisterMusicbrainzTags              ,+++-- ** tagToId3Tag #method:tagToId3Tag#++    tagToId3Tag                             ,+++-- ** tagToVorbisComments #method:tagToVorbisComments#++    tagToVorbisComments                     ,+++-- ** tagToVorbisTag #method:tagToVorbisTag#++    tagToVorbisTag                          ,+++-- ** tagXmpListSchemas #method:tagXmpListSchemas#++    tagXmpListSchemas                       ,+++-- ** vorbisTagAdd #method:vorbisTagAdd#++    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.ManagedPtr as B.ManagedPtr+import qualified Data.GI.Base.GClosure as B.GClosure+import qualified Data.GI.Base.GError as B.GError+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.Text as T+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 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++-- function gst_vorbis_tag_add+-- Args : [Arg {argCName = "list", argType = TInterface (Name {namespace = "Gst", name = "TagList"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstTagList", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "tag", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a vorbiscomment tag string (key in key=value), must be valid UTF-8", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a vorbiscomment value string (value in key=value), must be valid UTF-8", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Nothing+-- throws : False+-- Skip return : False++foreign import ccall "gst_vorbis_tag_add" gst_vorbis_tag_add :: +    Ptr Gst.TagList.TagList ->              -- list : TInterface (Name {namespace = "Gst", name = "TagList"})+    CString ->                              -- tag : TBasicType TUTF8+    CString ->                              -- value : TBasicType TUTF8+    IO ()++{- |+Convenience function using 'GI.GstTag.Functions.tagFromVorbisTag', parsing+a vorbis comment string into the right type and adding it to the+given taglist /@list@/.++Unknown vorbiscomment tags will be added to the tag list in form+of a 'GI.Gst.Constants.TAG_EXTENDED_COMMENT'.+-}+vorbisTagAdd ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    Gst.TagList.TagList+    {- ^ /@list@/: a 'GI.Gst.Structs.TagList.TagList' -}+    -> T.Text+    {- ^ /@tag@/: a vorbiscomment tag string (key in key=value), must be valid UTF-8 -}+    -> T.Text+    {- ^ /@value@/: a vorbiscomment value string (value in key=value), must be valid UTF-8 -}+    -> m ()+vorbisTagAdd list tag value = liftIO $ do+    list' <- unsafeManagedPtrGetPtr list+    tag' <- textToCString tag+    value' <- textToCString value+    gst_vorbis_tag_add list' tag' value'+    touchManagedPtr list+    freeMem tag'+    freeMem value'+    return ()+++-- function gst_tag_xmp_list_schemas+-- Args : []+-- Lengths : []+-- returnType : Just (TCArray True (-1) (-1) (TBasicType TUTF8))+-- throws : False+-- Skip return : False++foreign import ccall "gst_tag_xmp_list_schemas" gst_tag_xmp_list_schemas :: +    IO (Ptr CString)++{- |+Gets the list of supported schemas in the xmp lib+-}+tagXmpListSchemas ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    m [T.Text]+    {- ^ __Returns:__ a 'Nothing' terminated array of strings with the+    schema names -}+tagXmpListSchemas  = liftIO $ do+    result <- gst_tag_xmp_list_schemas+    checkUnexpectedReturnNULL "tagXmpListSchemas" result+    result' <- unpackZeroTerminatedUTF8CArray result+    return result'+++-- function gst_tag_to_vorbis_tag+-- Args : [Arg {argCName = "gst_tag", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "GStreamer tag to convert to vorbiscomment tag", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TUTF8)+-- throws : False+-- Skip return : False++foreign import ccall "gst_tag_to_vorbis_tag" gst_tag_to_vorbis_tag :: +    CString ->                              -- gst_tag : TBasicType TUTF8+    IO CString++{- |+Looks up the vorbiscomment tag for a GStreamer tag.+-}+tagToVorbisTag ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    T.Text+    {- ^ /@gstTag@/: GStreamer tag to convert to vorbiscomment tag -}+    -> m T.Text+    {- ^ __Returns:__ The corresponding vorbiscomment tag or NULL if none exists. -}+tagToVorbisTag gstTag = liftIO $ do+    gstTag' <- textToCString gstTag+    result <- gst_tag_to_vorbis_tag gstTag'+    checkUnexpectedReturnNULL "tagToVorbisTag" result+    result' <- cstringToText result+    freeMem gstTag'+    return result'+++-- function gst_tag_to_vorbis_comments+-- Args : [Arg {argCName = "list", argType = TInterface (Name {namespace = "Gst", name = "TagList"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstTagList", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "tag", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a GStreamer tag identifier, such as #GST_TAG_ARTIST", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TGList (TBasicType TUTF8))+-- throws : False+-- Skip return : False++foreign import ccall "gst_tag_to_vorbis_comments" gst_tag_to_vorbis_comments :: +    Ptr Gst.TagList.TagList ->              -- list : TInterface (Name {namespace = "Gst", name = "TagList"})+    CString ->                              -- tag : TBasicType TUTF8+    IO (Ptr (GList CString))++{- |+Creates a new tag list that contains the information parsed out of a+vorbiscomment packet.+-}+tagToVorbisComments ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    Gst.TagList.TagList+    {- ^ /@list@/: a 'GI.Gst.Structs.TagList.TagList' -}+    -> T.Text+    {- ^ /@tag@/: a GStreamer tag identifier, such as 'GI.Gst.Constants.TAG_ARTIST' -}+    -> m [T.Text]+    {- ^ __Returns:__ A 'GI.GLib.Structs.List.List' of newly-allocated+    key=value strings. Free with g_list_foreach (list, (GFunc) g_free, NULL)+    plus g_list_free (list) -}+tagToVorbisComments list tag = liftIO $ do+    list' <- unsafeManagedPtrGetPtr list+    tag' <- textToCString tag+    result <- gst_tag_to_vorbis_comments list' tag'+    result' <- unpackGList result+    result'' <- mapM cstringToText result'+    mapGList freeMem result+    g_list_free result+    touchManagedPtr list+    freeMem tag'+    return result''+++-- function gst_tag_to_id3_tag+-- Args : [Arg {argCName = "gst_tag", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "GStreamer tag to convert to vorbiscomment tag", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TUTF8)+-- throws : False+-- Skip return : False++foreign import ccall "gst_tag_to_id3_tag" gst_tag_to_id3_tag :: +    CString ->                              -- gst_tag : TBasicType TUTF8+    IO CString++{- |+Looks up the ID3v2 tag for a GStreamer tag.+-}+tagToId3Tag ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    T.Text+    {- ^ /@gstTag@/: GStreamer tag to convert to vorbiscomment tag -}+    -> m T.Text+    {- ^ __Returns:__ The corresponding ID3v2 tag or NULL if none exists. -}+tagToId3Tag gstTag = liftIO $ do+    gstTag' <- textToCString gstTag+    result <- gst_tag_to_id3_tag gstTag'+    checkUnexpectedReturnNULL "tagToId3Tag" result+    result' <- cstringToText result+    freeMem gstTag'+    return result'+++-- function gst_tag_register_musicbrainz_tags+-- Args : []+-- Lengths : []+-- returnType : Nothing+-- throws : False+-- Skip return : False++foreign import ccall "gst_tag_register_musicbrainz_tags" gst_tag_register_musicbrainz_tags :: +    IO ()++{- |+Registers additional musicbrainz-specific tags with the GStreamer tag+system. Plugins and applications that use these tags should call this+function before using them. Can be called multiple times.+-}+tagRegisterMusicbrainzTags ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    m ()+tagRegisterMusicbrainzTags  = liftIO $ do+    gst_tag_register_musicbrainz_tags+    return ()+++-- function gst_tag_parse_extended_comment+-- Args : [Arg {argCName = "ext_comment", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "an extended comment string, see #GST_TAG_EXTENDED_COMMENT", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "key", argType = TBasicType TUTF8, direction = DirectionOut, mayBeNull = True, argDoc = Documentation {rawDocText = Just "\n    return location for the comment description key, or NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "lang", argType = TBasicType TUTF8, direction = DirectionOut, mayBeNull = True, argDoc = Documentation {rawDocText = Just "\n    return location for the comment ISO-639 language code, or NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "value", argType = TBasicType TUTF8, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "return location for the actual comment string, or NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "fail_if_no_key", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "whether to fail if strings are not in key=value form", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TBoolean)+-- throws : False+-- Skip return : False++foreign import ccall "gst_tag_parse_extended_comment" gst_tag_parse_extended_comment :: +    CString ->                              -- ext_comment : TBasicType TUTF8+    Ptr CString ->                          -- key : TBasicType TUTF8+    Ptr CString ->                          -- lang : TBasicType TUTF8+    Ptr CString ->                          -- value : TBasicType TUTF8+    CInt ->                                 -- fail_if_no_key : TBasicType TBoolean+    IO CInt++{- |+Convenience function to parse a GST_TAG_EXTENDED_COMMENT string and+separate it into its components.++If successful, /@key@/, /@lang@/ and\/or /@value@/ will be set to newly allocated+strings that you need to free with 'GI.GLib.Functions.free' when done. /@key@/ and /@lang@/+may also be set to NULL by this function if there is no key or no language+code in the extended comment string.+-}+tagParseExtendedComment ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    T.Text+    {- ^ /@extComment@/: an extended comment string, see 'GI.Gst.Constants.TAG_EXTENDED_COMMENT' -}+    -> Bool+    {- ^ /@failIfNoKey@/: whether to fail if strings are not in key=value form -}+    -> m ((Bool, Maybe T.Text, Maybe T.Text, T.Text))+    {- ^ __Returns:__ TRUE if the string could be parsed, otherwise FALSE -}+tagParseExtendedComment extComment failIfNoKey = liftIO $ do+    extComment' <- textToCString extComment+    key <- allocMem :: IO (Ptr CString)+    lang <- allocMem :: IO (Ptr CString)+    value <- allocMem :: IO (Ptr CString)+    let failIfNoKey' = (fromIntegral . fromEnum) failIfNoKey+    result <- gst_tag_parse_extended_comment extComment' key lang value failIfNoKey'+    let result' = (/= 0) result+    key' <- peek key+    maybeKey' <- convertIfNonNull key' $ \key'' -> do+        key''' <- cstringToText key''+        return key'''+    freeMem key'+    lang' <- peek lang+    maybeLang' <- convertIfNonNull lang' $ \lang'' -> do+        lang''' <- cstringToText lang''+        return lang'''+    freeMem lang'+    value' <- peek value+    value'' <- cstringToText value'+    freeMem value'+    freeMem extComment'+    freeMem key+    freeMem lang+    freeMem value+    return (result', maybeKey', maybeLang', value'')+++-- function gst_tag_list_to_xmp_buffer+-- Args : [Arg {argCName = "list", argType = TInterface (Name {namespace = "Gst", name = "TagList"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "tags", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "read_only", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "does the container forbid inplace editing", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "schemas", argType = TCArray True (-1) (-1) (TBasicType TUTF8), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "\n    %NULL terminated array of schemas to be used on serialization", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TInterface (Name {namespace = "Gst", name = "Buffer"}))+-- throws : False+-- Skip return : False++foreign import ccall "gst_tag_list_to_xmp_buffer" gst_tag_list_to_xmp_buffer :: +    Ptr Gst.TagList.TagList ->              -- list : TInterface (Name {namespace = "Gst", name = "TagList"})+    CInt ->                                 -- read_only : TBasicType TBoolean+    Ptr CString ->                          -- schemas : TCArray True (-1) (-1) (TBasicType TUTF8)+    IO (Ptr Gst.Buffer.Buffer)++{- |+Formats a taglist as a xmp packet using only the selected+schemas. An empty list ('Nothing') means that all schemas should+be used+-}+tagListToXmpBuffer ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    Gst.TagList.TagList+    {- ^ /@list@/: tags -}+    -> Bool+    {- ^ /@readOnly@/: does the container forbid inplace editing -}+    -> [T.Text]+    {- ^ /@schemas@/: +    'Nothing' terminated array of schemas to be used on serialization -}+    -> m Gst.Buffer.Buffer+    {- ^ __Returns:__ new buffer or 'Nothing', unref the buffer when done -}+tagListToXmpBuffer list readOnly schemas = liftIO $ do+    list' <- unsafeManagedPtrGetPtr list+    let readOnly' = (fromIntegral . fromEnum) readOnly+    schemas' <- packZeroTerminatedUTF8CArray schemas+    result <- gst_tag_list_to_xmp_buffer list' readOnly' schemas'+    checkUnexpectedReturnNULL "tagListToXmpBuffer" result+    result' <- (wrapBoxed Gst.Buffer.Buffer) result+    touchManagedPtr list+    mapZeroTerminatedCArray freeMem schemas'+    freeMem schemas'+    return result'+++-- function gst_tag_list_to_vorbiscomment_buffer+-- Args : [Arg {argCName = "list", argType = TInterface (Name {namespace = "Gst", name = "TagList"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "tag list to convert", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "id_data", argType = TCArray False (-1) 2 (TBasicType TUInt8), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "identification data at start of stream", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "id_data_length", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "length of identification data, may be 0 if @id_data is NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "vendor_string", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "string that describes the vendor string or NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : [Arg {argCName = "id_data_length", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "length of identification data, may be 0 if @id_data is NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- returnType : Just (TInterface (Name {namespace = "Gst", name = "Buffer"}))+-- throws : False+-- Skip return : False++foreign import ccall "gst_tag_list_to_vorbiscomment_buffer" gst_tag_list_to_vorbiscomment_buffer :: +    Ptr Gst.TagList.TagList ->              -- list : TInterface (Name {namespace = "Gst", name = "TagList"})+    Ptr Word8 ->                            -- id_data : TCArray False (-1) 2 (TBasicType TUInt8)+    Word32 ->                               -- id_data_length : TBasicType TUInt+    CString ->                              -- vendor_string : TBasicType TUTF8+    IO (Ptr Gst.Buffer.Buffer)++{- |+Creates a new vorbiscomment buffer from a tag list.+-}+tagListToVorbiscommentBuffer ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    Gst.TagList.TagList+    {- ^ /@list@/: tag list to convert -}+    -> ByteString+    {- ^ /@idData@/: identification data at start of stream -}+    -> Maybe (T.Text)+    {- ^ /@vendorString@/: string that describes the vendor string or NULL -}+    -> m Gst.Buffer.Buffer+    {- ^ __Returns:__ A new 'GI.Gst.Structs.Buffer.Buffer' containing a vorbiscomment buffer with all tags+         that could be converted from the given tag list. -}+tagListToVorbiscommentBuffer list idData vendorString = liftIO $ do+    let idDataLength = fromIntegral $ B.length idData+    list' <- unsafeManagedPtrGetPtr list+    idData' <- packByteString idData+    maybeVendorString <- case vendorString of+        Nothing -> return nullPtr+        Just jVendorString -> do+            jVendorString' <- textToCString jVendorString+            return jVendorString'+    result <- gst_tag_list_to_vorbiscomment_buffer list' idData' idDataLength maybeVendorString+    checkUnexpectedReturnNULL "tagListToVorbiscommentBuffer" result+    result' <- (wrapBoxed Gst.Buffer.Buffer) result+    touchManagedPtr list+    freeMem idData'+    freeMem maybeVendorString+    return result'+++-- function gst_tag_list_to_exif_buffer_with_tiff_header+-- Args : [Arg {argCName = "taglist", argType = TInterface (Name {namespace = "Gst", name = "TagList"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The taglist", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TInterface (Name {namespace = "Gst", name = "Buffer"}))+-- throws : False+-- Skip return : False++foreign import ccall "gst_tag_list_to_exif_buffer_with_tiff_header" gst_tag_list_to_exif_buffer_with_tiff_header :: +    Ptr Gst.TagList.TagList ->              -- taglist : TInterface (Name {namespace = "Gst", name = "TagList"})+    IO (Ptr Gst.Buffer.Buffer)++{- |+Formats the tags in taglist into exif structure, a tiff header+is put in the beginning of the buffer.+-}+tagListToExifBufferWithTiffHeader ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    Gst.TagList.TagList+    {- ^ /@taglist@/: The taglist -}+    -> m Gst.Buffer.Buffer+    {- ^ __Returns:__ A GstBuffer containing the data -}+tagListToExifBufferWithTiffHeader taglist = liftIO $ do+    taglist' <- unsafeManagedPtrGetPtr taglist+    result <- gst_tag_list_to_exif_buffer_with_tiff_header taglist'+    checkUnexpectedReturnNULL "tagListToExifBufferWithTiffHeader" result+    result' <- (wrapBoxed Gst.Buffer.Buffer) result+    touchManagedPtr taglist+    return result'+++-- function gst_tag_list_to_exif_buffer+-- Args : [Arg {argCName = "taglist", argType = TInterface (Name {namespace = "Gst", name = "TagList"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The taglist", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "byte_order", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "byte order used in writing (G_LITTLE_ENDIAN or G_BIG_ENDIAN)", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "base_offset", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Offset from the tiff header first byte", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TInterface (Name {namespace = "Gst", name = "Buffer"}))+-- throws : False+-- Skip return : False++foreign import ccall "gst_tag_list_to_exif_buffer" gst_tag_list_to_exif_buffer :: +    Ptr Gst.TagList.TagList ->              -- taglist : TInterface (Name {namespace = "Gst", name = "TagList"})+    Int32 ->                                -- byte_order : TBasicType TInt+    Word32 ->                               -- base_offset : TBasicType TUInt32+    IO (Ptr Gst.Buffer.Buffer)++{- |+Formats the tags in taglist on exif format. The resulting buffer contains+the tags IFD and is followed by the data pointed by the tag entries.+-}+tagListToExifBuffer ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    Gst.TagList.TagList+    {- ^ /@taglist@/: The taglist -}+    -> Int32+    {- ^ /@byteOrder@/: byte order used in writing (G_LITTLE_ENDIAN or G_BIG_ENDIAN) -}+    -> Word32+    {- ^ /@baseOffset@/: Offset from the tiff header first byte -}+    -> m Gst.Buffer.Buffer+    {- ^ __Returns:__ A GstBuffer containing the tag entries followed by the tag data -}+tagListToExifBuffer taglist byteOrder baseOffset = liftIO $ do+    taglist' <- unsafeManagedPtrGetPtr taglist+    result <- gst_tag_list_to_exif_buffer taglist' byteOrder baseOffset+    checkUnexpectedReturnNULL "tagListToExifBuffer" result+    result' <- (wrapBoxed Gst.Buffer.Buffer) result+    touchManagedPtr taglist+    return result'+++-- function gst_tag_list_new_from_id3v1+-- Args : [Arg {argCName = "data", argType = TCArray False 128 (-1) (TBasicType TUInt8), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "128 bytes of data containing the ID3v1 tag", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TInterface (Name {namespace = "Gst", name = "TagList"}))+-- throws : False+-- Skip return : False++foreign import ccall "gst_tag_list_new_from_id3v1" gst_tag_list_new_from_id3v1 :: +    Ptr Word8 ->                            -- data : TCArray False 128 (-1) (TBasicType TUInt8)+    IO (Ptr Gst.TagList.TagList)++{- |+Parses the data containing an ID3v1 tag and returns a 'GI.Gst.Structs.TagList.TagList' from the+parsed data.+-}+tagListNewFromId3v1 ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    ByteString+    {- ^ /@data@/: 128 bytes of data containing the ID3v1 tag -}+    -> m Gst.TagList.TagList+    {- ^ __Returns:__ A new tag list or NULL if the data was not an ID3v1 tag. -}+tagListNewFromId3v1 data_ = liftIO $ do+    data_' <- packByteString data_+    result <- gst_tag_list_new_from_id3v1 data_'+    checkUnexpectedReturnNULL "tagListNewFromId3v1" result+    result' <- (wrapBoxed Gst.TagList.TagList) result+    freeMem data_'+    return result'+++-- function gst_tag_list_from_xmp_buffer+-- Args : [Arg {argCName = "buffer", argType = TInterface (Name {namespace = "Gst", name = "Buffer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "buffer", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TInterface (Name {namespace = "Gst", name = "TagList"}))+-- throws : False+-- Skip return : False++foreign import ccall "gst_tag_list_from_xmp_buffer" gst_tag_list_from_xmp_buffer :: +    Ptr Gst.Buffer.Buffer ->                -- buffer : TInterface (Name {namespace = "Gst", name = "Buffer"})+    IO (Ptr Gst.TagList.TagList)++{- |+Parse a xmp packet into a taglist.+-}+tagListFromXmpBuffer ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    Gst.Buffer.Buffer+    {- ^ /@buffer@/: buffer -}+    -> m Gst.TagList.TagList+    {- ^ __Returns:__ new taglist or 'Nothing', free the list when done -}+tagListFromXmpBuffer buffer = liftIO $ do+    buffer' <- unsafeManagedPtrGetPtr buffer+    result <- gst_tag_list_from_xmp_buffer buffer'+    checkUnexpectedReturnNULL "tagListFromXmpBuffer" result+    result' <- (wrapBoxed Gst.TagList.TagList) result+    touchManagedPtr buffer+    return result'+++-- function gst_tag_list_from_vorbiscomment_buffer+-- Args : [Arg {argCName = "buffer", argType = TInterface (Name {namespace = "Gst", name = "Buffer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "buffer to convert", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "id_data", argType = TCArray False (-1) 2 (TBasicType TUInt8), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "identification data at start of stream", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "id_data_length", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "length of identification data", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "vendor_string", argType = TBasicType TUTF8, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "pointer to a string that should take the\n    vendor string of this vorbis comment or NULL if you don't need it.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]+-- Lengths : [Arg {argCName = "id_data_length", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "length of identification data", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- returnType : Just (TInterface (Name {namespace = "Gst", name = "TagList"}))+-- throws : False+-- Skip return : False++foreign import ccall "gst_tag_list_from_vorbiscomment_buffer" gst_tag_list_from_vorbiscomment_buffer :: +    Ptr Gst.Buffer.Buffer ->                -- buffer : TInterface (Name {namespace = "Gst", name = "Buffer"})+    Ptr Word8 ->                            -- id_data : TCArray False (-1) 2 (TBasicType TUInt8)+    Word32 ->                               -- id_data_length : TBasicType TUInt+    Ptr CString ->                          -- vendor_string : TBasicType TUTF8+    IO (Ptr Gst.TagList.TagList)++{- |+Creates a new tag list that contains the information parsed out of a+vorbiscomment packet.+-}+tagListFromVorbiscommentBuffer ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    Gst.Buffer.Buffer+    {- ^ /@buffer@/: buffer to convert -}+    -> ByteString+    {- ^ /@idData@/: identification data at start of stream -}+    -> m ((Gst.TagList.TagList, T.Text))+    {- ^ __Returns:__ A new 'GI.Gst.Structs.TagList.TagList' with all tags that could be extracted from the+         given vorbiscomment buffer or NULL on error. -}+tagListFromVorbiscommentBuffer buffer idData = liftIO $ do+    let idDataLength = fromIntegral $ B.length idData+    buffer' <- unsafeManagedPtrGetPtr buffer+    idData' <- packByteString idData+    vendorString <- allocMem :: IO (Ptr CString)+    result <- gst_tag_list_from_vorbiscomment_buffer buffer' idData' idDataLength vendorString+    checkUnexpectedReturnNULL "tagListFromVorbiscommentBuffer" result+    result' <- (wrapBoxed Gst.TagList.TagList) result+    vendorString' <- peek vendorString+    vendorString'' <- cstringToText vendorString'+    freeMem vendorString'+    touchManagedPtr buffer+    freeMem idData'+    freeMem vendorString+    return (result', vendorString'')+++-- function gst_tag_list_from_vorbiscomment+-- Args : [Arg {argCName = "data", argType = TCArray False (-1) 1 (TBasicType TUInt8), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "data to convert", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "size", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "size of @data", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "id_data", argType = TCArray False (-1) 3 (TBasicType TUInt8), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "identification data at start of stream", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "id_data_length", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "length of identification data", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "vendor_string", argType = TBasicType TUTF8, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "pointer to a string that should take the\n    vendor string of this vorbis comment or NULL if you don't need it.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]+-- Lengths : [Arg {argCName = "id_data_length", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "length of identification data", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "size", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "size of @data", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- returnType : Just (TInterface (Name {namespace = "Gst", name = "TagList"}))+-- throws : False+-- Skip return : False++foreign import ccall "gst_tag_list_from_vorbiscomment" gst_tag_list_from_vorbiscomment :: +    Ptr Word8 ->                            -- data : TCArray False (-1) 1 (TBasicType TUInt8)+    Word64 ->                               -- size : TBasicType TUInt64+    Ptr Word8 ->                            -- id_data : TCArray False (-1) 3 (TBasicType TUInt8)+    Word32 ->                               -- id_data_length : TBasicType TUInt+    Ptr CString ->                          -- vendor_string : TBasicType TUTF8+    IO (Ptr Gst.TagList.TagList)++{- |+Creates a new tag list that contains the information parsed out of a+vorbiscomment packet.+-}+tagListFromVorbiscomment ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    ByteString+    {- ^ /@data@/: data to convert -}+    -> ByteString+    {- ^ /@idData@/: identification data at start of stream -}+    -> m ((Gst.TagList.TagList, T.Text))+    {- ^ __Returns:__ A new 'GI.Gst.Structs.TagList.TagList' with all tags that could be extracted from the+         given vorbiscomment buffer or NULL on error. -}+tagListFromVorbiscomment data_ idData = liftIO $ do+    let idDataLength = fromIntegral $ B.length idData+    let size = fromIntegral $ B.length data_+    data_' <- packByteString data_+    idData' <- packByteString idData+    vendorString <- allocMem :: IO (Ptr CString)+    result <- gst_tag_list_from_vorbiscomment data_' size idData' idDataLength vendorString+    checkUnexpectedReturnNULL "tagListFromVorbiscomment" result+    result' <- (wrapBoxed Gst.TagList.TagList) result+    vendorString' <- peek vendorString+    vendorString'' <- cstringToText vendorString'+    freeMem vendorString'+    freeMem data_'+    freeMem idData'+    freeMem vendorString+    return (result', vendorString'')+++-- function gst_tag_list_from_id3v2_tag+-- Args : [Arg {argCName = "buffer", argType = TInterface (Name {namespace = "Gst", name = "Buffer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "buffer to convert", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TInterface (Name {namespace = "Gst", name = "TagList"}))+-- throws : False+-- Skip return : False++foreign import ccall "gst_tag_list_from_id3v2_tag" gst_tag_list_from_id3v2_tag :: +    Ptr Gst.Buffer.Buffer ->                -- buffer : TInterface (Name {namespace = "Gst", name = "Buffer"})+    IO (Ptr Gst.TagList.TagList)++{- |+Creates a new tag list that contains the information parsed out of a+ID3 tag.+-}+tagListFromId3v2Tag ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    Gst.Buffer.Buffer+    {- ^ /@buffer@/: buffer to convert -}+    -> m Gst.TagList.TagList+    {- ^ __Returns:__ A new 'GI.Gst.Structs.TagList.TagList' with all tags that could be extracted from the+         given vorbiscomment buffer or NULL on error. -}+tagListFromId3v2Tag buffer = liftIO $ do+    buffer' <- unsafeManagedPtrGetPtr buffer+    result <- gst_tag_list_from_id3v2_tag buffer'+    checkUnexpectedReturnNULL "tagListFromId3v2Tag" result+    result' <- (wrapBoxed Gst.TagList.TagList) result+    touchManagedPtr buffer+    return result'+++-- function gst_tag_list_from_exif_buffer_with_tiff_header+-- Args : [Arg {argCName = "buffer", argType = TInterface (Name {namespace = "Gst", name = "Buffer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The exif buffer", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TInterface (Name {namespace = "Gst", name = "TagList"}))+-- throws : False+-- Skip return : False++foreign import ccall "gst_tag_list_from_exif_buffer_with_tiff_header" gst_tag_list_from_exif_buffer_with_tiff_header :: +    Ptr Gst.Buffer.Buffer ->                -- buffer : TInterface (Name {namespace = "Gst", name = "Buffer"})+    IO (Ptr Gst.TagList.TagList)++{- |+Parses the exif tags starting with a tiff header structure.+-}+tagListFromExifBufferWithTiffHeader ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    Gst.Buffer.Buffer+    {- ^ /@buffer@/: The exif buffer -}+    -> m Gst.TagList.TagList+    {- ^ __Returns:__ The taglist -}+tagListFromExifBufferWithTiffHeader buffer = liftIO $ do+    buffer' <- unsafeManagedPtrGetPtr buffer+    result <- gst_tag_list_from_exif_buffer_with_tiff_header buffer'+    checkUnexpectedReturnNULL "tagListFromExifBufferWithTiffHeader" result+    result' <- (wrapBoxed Gst.TagList.TagList) result+    touchManagedPtr buffer+    return result'+++-- function gst_tag_list_from_exif_buffer+-- Args : [Arg {argCName = "buffer", argType = TInterface (Name {namespace = "Gst", name = "Buffer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The exif buffer", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "byte_order", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "byte order of the data", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "base_offset", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Offset from the tiff header to this buffer", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TInterface (Name {namespace = "Gst", name = "TagList"}))+-- throws : False+-- Skip return : False++foreign import ccall "gst_tag_list_from_exif_buffer" gst_tag_list_from_exif_buffer :: +    Ptr Gst.Buffer.Buffer ->                -- buffer : TInterface (Name {namespace = "Gst", name = "Buffer"})+    Int32 ->                                -- byte_order : TBasicType TInt+    Word32 ->                               -- base_offset : TBasicType TUInt32+    IO (Ptr Gst.TagList.TagList)++{- |+Parses the IFD and IFD tags data contained in the buffer and puts it+on a taglist. The base_offset is used to subtract from the offset in+the tag entries and be able to get the offset relative to the buffer+start+-}+tagListFromExifBuffer ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    Gst.Buffer.Buffer+    {- ^ /@buffer@/: The exif buffer -}+    -> Int32+    {- ^ /@byteOrder@/: byte order of the data -}+    -> Word32+    {- ^ /@baseOffset@/: Offset from the tiff header to this buffer -}+    -> m Gst.TagList.TagList+    {- ^ __Returns:__ The parsed taglist -}+tagListFromExifBuffer buffer byteOrder baseOffset = liftIO $ do+    buffer' <- unsafeManagedPtrGetPtr buffer+    result <- gst_tag_list_from_exif_buffer buffer' byteOrder baseOffset+    checkUnexpectedReturnNULL "tagListFromExifBuffer" result+    result' <- (wrapBoxed Gst.TagList.TagList) result+    touchManagedPtr buffer+    return result'+++-- function gst_tag_list_add_id3_image+-- Args : [Arg {argCName = "tag_list", argType = TInterface (Name {namespace = "Gst", name = "TagList"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a tag list", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "image_data", argType = TCArray False (-1) 2 (TBasicType TUInt8), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the (encoded) image", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "image_data_len", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the length of the encoded image data at @image_data", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "id3_picture_type", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "picture type as per the ID3 (v2.4.0) specification for\n   the APIC frame (0 = unknown/other)", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : [Arg {argCName = "image_data_len", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the length of the encoded image data at @image_data", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- returnType : Just (TBasicType TBoolean)+-- throws : False+-- Skip return : False++foreign import ccall "gst_tag_list_add_id3_image" gst_tag_list_add_id3_image :: +    Ptr Gst.TagList.TagList ->              -- tag_list : TInterface (Name {namespace = "Gst", name = "TagList"})+    Ptr Word8 ->                            -- image_data : TCArray False (-1) 2 (TBasicType TUInt8)+    Word32 ->                               -- image_data_len : TBasicType TUInt+    Word32 ->                               -- id3_picture_type : TBasicType TUInt+    IO CInt++{- |+Adds an image from an ID3 APIC frame (or similar, such as used in FLAC)+to the given tag list. Also see 'GI.GstTag.Functions.tagImageDataToImageSample' for+more information on image tags in GStreamer.+-}+tagListAddId3Image ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    Gst.TagList.TagList+    {- ^ /@tagList@/: a tag list -}+    -> ByteString+    {- ^ /@imageData@/: the (encoded) image -}+    -> Word32+    {- ^ /@id3PictureType@/: picture type as per the ID3 (v2.4.0) specification for+   the APIC frame (0 = unknown\/other) -}+    -> m Bool+    {- ^ __Returns:__ 'True' if the image was processed, otherwise 'False' -}+tagListAddId3Image tagList imageData id3PictureType = liftIO $ do+    let imageDataLen = fromIntegral $ B.length imageData+    tagList' <- unsafeManagedPtrGetPtr tagList+    imageData' <- packByteString imageData+    result <- gst_tag_list_add_id3_image tagList' imageData' imageDataLen id3PictureType+    let result' = (/= 0) result+    touchManagedPtr tagList+    freeMem imageData'+    return result'+++-- function gst_tag_image_data_to_image_sample+-- Args : [Arg {argCName = "image_data", argType = TCArray False (-1) 1 (TBasicType TUInt8), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the (encoded) image", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "image_data_len", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the length of the encoded image data at @image_data", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "image_type", argType = TInterface (Name {namespace = "GstTag", name = "TagImageType"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "type of the image, or #GST_TAG_IMAGE_TYPE_UNDEFINED. Pass\n    #GST_TAG_IMAGE_TYPE_NONE if no image type should be set at all (e.g.\n    for preview images)", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : [Arg {argCName = "image_data_len", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the length of the encoded image data at @image_data", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- returnType : Just (TInterface (Name {namespace = "Gst", name = "Sample"}))+-- throws : False+-- Skip return : False++foreign import ccall "gst_tag_image_data_to_image_sample" gst_tag_image_data_to_image_sample :: +    Ptr Word8 ->                            -- image_data : TCArray False (-1) 1 (TBasicType TUInt8)+    Word32 ->                               -- image_data_len : TBasicType TUInt+    CInt ->                                 -- image_type : TInterface (Name {namespace = "GstTag", name = "TagImageType"})+    IO (Ptr Gst.Sample.Sample)++{- |+Helper function for tag-reading plugins to create a 'GI.Gst.Structs.Sample.Sample' suitable to+add to a 'GI.Gst.Structs.TagList.TagList' as an image tag (such as 'GI.Gst.Constants.TAG_IMAGE' or+'GI.Gst.Constants.TAG_PREVIEW_IMAGE') from the encoded image data and an (optional) image+type.++Background: cover art and other images in tags are usually stored as a+blob of binary image data, often accompanied by a MIME type or some other+content type string (e.g. \'png\', \'jpeg\', \'jpg\'). Sometimes there is also an+\'image type\' to indicate what kind of image this is (e.g. front cover,+back cover, artist, etc.). The image data may also be an URI to the image+rather than the image itself.++In GStreamer, image tags are 'GI.Gst.Structs.Sample.Sample'\<!-- -->s containing the raw image+data, with the sample caps describing the content type of the image+(e.g. image\/jpeg, image\/png, text\/uri-list). The sample info may contain+an additional \'image-type\' field of @/GST_TYPE_TAG_IMAGE_TYPE/@ to describe+the type of image (front cover, back cover etc.). 'GI.Gst.Constants.TAG_PREVIEW_IMAGE'+tags should not carry an image type, their type is already indicated via+the special tag name.++This function will do various checks and typefind the encoded image+data (we can\'t trust the declared mime type).+-}+tagImageDataToImageSample ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    ByteString+    {- ^ /@imageData@/: the (encoded) image -}+    -> GstTag.Enums.TagImageType+    {- ^ /@imageType@/: type of the image, or @/GST_TAG_IMAGE_TYPE_UNDEFINED/@. Pass+    @/GST_TAG_IMAGE_TYPE_NONE/@ if no image type should be set at all (e.g.+    for preview images) -}+    -> m Gst.Sample.Sample+    {- ^ __Returns:__ a newly-allocated image sample for use in tag lists, or NULL -}+tagImageDataToImageSample imageData imageType = liftIO $ do+    let imageDataLen = fromIntegral $ B.length imageData+    imageData' <- packByteString imageData+    let imageType' = (fromIntegral . fromEnum) imageType+    result <- gst_tag_image_data_to_image_sample imageData' imageDataLen imageType'+    checkUnexpectedReturnNULL "tagImageDataToImageSample" result+    result' <- (wrapBoxed Gst.Sample.Sample) result+    freeMem imageData'+    return result'+++-- function gst_tag_id3_genre_get+-- Args : [Arg {argCName = "id", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "ID of genre to query", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TUTF8)+-- throws : False+-- Skip return : False++foreign import ccall "gst_tag_id3_genre_get" gst_tag_id3_genre_get :: +    Word32 ->                               -- id : TBasicType TUInt+    IO CString++{- |+Gets the ID3v1 genre name for a given ID.+-}+tagId3GenreGet ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    Word32+    {- ^ /@id@/: ID of genre to query -}+    -> m T.Text+    {- ^ __Returns:__ the genre or NULL if no genre is associated with that ID. -}+tagId3GenreGet id = liftIO $ do+    result <- gst_tag_id3_genre_get id+    checkUnexpectedReturnNULL "tagId3GenreGet" result+    result' <- cstringToText result+    return result'+++-- function gst_tag_id3_genre_count+-- Args : []+-- Lengths : []+-- returnType : Just (TBasicType TUInt)+-- throws : False+-- Skip return : False++foreign import ccall "gst_tag_id3_genre_count" gst_tag_id3_genre_count :: +    IO Word32++{- |+Gets the number of ID3v1 genres that can be identified. Winamp genres are+included.+-}+tagId3GenreCount ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    m Word32+    {- ^ __Returns:__ the number of ID3v1 genres that can be identified -}+tagId3GenreCount  = liftIO $ do+    result <- gst_tag_id3_genre_count+    return result+++-- function gst_tag_get_licenses+-- Args : []+-- Lengths : []+-- returnType : Just (TCArray True (-1) (-1) (TBasicType TUTF8))+-- throws : False+-- Skip return : False++foreign import ccall "gst_tag_get_licenses" gst_tag_get_licenses :: +    IO (Ptr CString)++{- |+Returns a list of known license references (in form of URIs). This is+useful for UIs to build a list of available licenses for tagging purposes+(e.g. to tag an audio track appropriately in a video or audio editor, or+an image in a camera application).+-}+tagGetLicenses ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    m [T.Text]+    {- ^ __Returns:__ NULL-terminated array of license strings. Free+    with 'GI.GLib.Functions.strfreev' when no longer needed. -}+tagGetLicenses  = liftIO $ do+    result <- gst_tag_get_licenses+    checkUnexpectedReturnNULL "tagGetLicenses" result+    result' <- unpackZeroTerminatedUTF8CArray result+    mapZeroTerminatedCArray freeMem result+    freeMem result+    return result'+++-- function gst_tag_get_license_version+-- Args : [Arg {argCName = "license_ref", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a license reference string in form of a URI,\n    e.g. \"http://creativecommons.org/licenses/by-nc-nd/2.0/\"", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TUTF8)+-- throws : False+-- Skip return : False++foreign import ccall "gst_tag_get_license_version" gst_tag_get_license_version :: +    CString ->                              -- license_ref : TBasicType TUTF8+    IO CString++{- |+Get the version of a license.+-}+tagGetLicenseVersion ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    T.Text+    {- ^ /@licenseRef@/: a license reference string in form of a URI,+    e.g. \"http:\/\/creativecommons.org\/licenses\/by-nc-nd\/2.0\/\" -}+    -> m T.Text+    {- ^ __Returns:__ the version of the license, or NULL if the license is not known or+   has no version -}+tagGetLicenseVersion licenseRef = liftIO $ do+    licenseRef' <- textToCString licenseRef+    result <- gst_tag_get_license_version licenseRef'+    checkUnexpectedReturnNULL "tagGetLicenseVersion" result+    result' <- cstringToText result+    freeMem licenseRef'+    return result'+++-- function gst_tag_get_license_title+-- Args : [Arg {argCName = "license_ref", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a license reference string in form of a URI,\n    e.g. \"http://creativecommons.org/licenses/by-nc-nd/2.0/\"", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TUTF8)+-- throws : False+-- Skip return : False++foreign import ccall "gst_tag_get_license_title" gst_tag_get_license_title :: +    CString ->                              -- license_ref : TBasicType TUTF8+    IO CString++{- |+Get the title of a license, which is a short translated description+of the license\'s features (generally not very pretty though).+-}+tagGetLicenseTitle ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    T.Text+    {- ^ /@licenseRef@/: a license reference string in form of a URI,+    e.g. \"http:\/\/creativecommons.org\/licenses\/by-nc-nd\/2.0\/\" -}+    -> m T.Text+    {- ^ __Returns:__ the title of the license, or NULL if the license is unknown or+   no title is available. -}+tagGetLicenseTitle licenseRef = liftIO $ do+    licenseRef' <- textToCString licenseRef+    result <- gst_tag_get_license_title licenseRef'+    checkUnexpectedReturnNULL "tagGetLicenseTitle" result+    result' <- cstringToText result+    freeMem licenseRef'+    return result'+++-- function gst_tag_get_license_nick+-- Args : [Arg {argCName = "license_ref", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a license reference string in form of a URI,\n    e.g. \"http://creativecommons.org/licenses/by-nc-nd/2.0/\"", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TUTF8)+-- throws : False+-- Skip return : False++foreign import ccall "gst_tag_get_license_nick" gst_tag_get_license_nick :: +    CString ->                              -- license_ref : TBasicType TUTF8+    IO CString++{- |+Get the nick name of a license, which is a short (untranslated) string+such as e.g. \"CC BY-NC-ND 2.0 UK\".+-}+tagGetLicenseNick ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    T.Text+    {- ^ /@licenseRef@/: a license reference string in form of a URI,+    e.g. \"http:\/\/creativecommons.org\/licenses\/by-nc-nd\/2.0\/\" -}+    -> m T.Text+    {- ^ __Returns:__ the nick name of the license, or NULL if the license is unknown -}+tagGetLicenseNick licenseRef = liftIO $ do+    licenseRef' <- textToCString licenseRef+    result <- gst_tag_get_license_nick licenseRef'+    checkUnexpectedReturnNULL "tagGetLicenseNick" result+    result' <- cstringToText result+    freeMem licenseRef'+    return result'+++-- function gst_tag_get_license_jurisdiction+-- Args : [Arg {argCName = "license_ref", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a license reference string in form of a URI,\n    e.g. \"http://creativecommons.org/licenses/by-nc-nd/2.0/\"", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TUTF8)+-- throws : False+-- Skip return : False++foreign import ccall "gst_tag_get_license_jurisdiction" gst_tag_get_license_jurisdiction :: +    CString ->                              -- license_ref : TBasicType TUTF8+    IO CString++{- |+Get the jurisdiction code of a license. This is usually a two-letter+ISO 3166-1 alpha-2 code, but there is also the special case of Scotland,+for which no code exists and which is thus represented as \"scotland\".++Known jurisdictions: ar, at, au, be, bg, br, ca, ch, cl, cn, co, de,+dk, es, fi, fr, hr, hu, il, in, it, jp, kr, mk, mt, mx, my, nl, pe, pl,+pt, scotland, se, si, tw, uk, us, za.+-}+tagGetLicenseJurisdiction ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    T.Text+    {- ^ /@licenseRef@/: a license reference string in form of a URI,+    e.g. \"http:\/\/creativecommons.org\/licenses\/by-nc-nd\/2.0\/\" -}+    -> m T.Text+    {- ^ __Returns:__ the jurisdiction code of the license, or NULL if the license is+   unknown or is not specific to a particular jurisdiction. -}+tagGetLicenseJurisdiction licenseRef = liftIO $ do+    licenseRef' <- textToCString licenseRef+    result <- gst_tag_get_license_jurisdiction licenseRef'+    checkUnexpectedReturnNULL "tagGetLicenseJurisdiction" result+    result' <- cstringToText result+    freeMem licenseRef'+    return result'+++-- function gst_tag_get_license_flags+-- Args : [Arg {argCName = "license_ref", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a license reference string in form of a URI,\n    e.g. \"http://creativecommons.org/licenses/by-nc-nd/2.0/\"", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TInterface (Name {namespace = "GstTag", name = "TagLicenseFlags"}))+-- throws : False+-- Skip return : False++foreign import ccall "gst_tag_get_license_flags" gst_tag_get_license_flags :: +    CString ->                              -- license_ref : TBasicType TUTF8+    IO CUInt++{- |+Get the flags of a license, which describe most of the features of+a license in their most general form.+-}+tagGetLicenseFlags ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    T.Text+    {- ^ /@licenseRef@/: a license reference string in form of a URI,+    e.g. \"http:\/\/creativecommons.org\/licenses\/by-nc-nd\/2.0\/\" -}+    -> m [GstTag.Flags.TagLicenseFlags]+    {- ^ __Returns:__ the flags of the license, or 0 if the license is unknown -}+tagGetLicenseFlags licenseRef = liftIO $ do+    licenseRef' <- textToCString licenseRef+    result <- gst_tag_get_license_flags licenseRef'+    let result' = wordToGFlags result+    freeMem licenseRef'+    return result'+++-- function gst_tag_get_license_description+-- Args : [Arg {argCName = "license_ref", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a license reference string in form of a URI,\n    e.g. \"http://creativecommons.org/licenses/by-nc-nd/2.0/\"", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TUTF8)+-- throws : False+-- Skip return : False++foreign import ccall "gst_tag_get_license_description" gst_tag_get_license_description :: +    CString ->                              -- license_ref : TBasicType TUTF8+    IO CString++{- |+Get the description of a license, which is a translated description+of the license\'s main features.+-}+tagGetLicenseDescription ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    T.Text+    {- ^ /@licenseRef@/: a license reference string in form of a URI,+    e.g. \"http:\/\/creativecommons.org\/licenses\/by-nc-nd\/2.0\/\" -}+    -> m T.Text+    {- ^ __Returns:__ the description of the license, or NULL if the license is unknown+   or a description is not available. -}+tagGetLicenseDescription licenseRef = liftIO $ do+    licenseRef' <- textToCString licenseRef+    result <- gst_tag_get_license_description licenseRef'+    checkUnexpectedReturnNULL "tagGetLicenseDescription" result+    result' <- cstringToText result+    freeMem licenseRef'+    return result'+++-- function gst_tag_get_language_name+-- Args : [Arg {argCName = "language_code", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "two or three-letter ISO-639 language code", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TUTF8)+-- throws : False+-- Skip return : False++foreign import ccall "gst_tag_get_language_name" gst_tag_get_language_name :: +    CString ->                              -- language_code : TBasicType TUTF8+    IO CString++{- |+Returns the name of the language given an ISO-639 language code as+found in a GST_TAG_LANGUAGE_CODE tag. The name will be translated+according to the current locale (if the library was built against the+iso-codes package, otherwise the English name will be returned).++Language codes are case-sensitive and expected to be lower case.+-}+tagGetLanguageName ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    T.Text+    {- ^ /@languageCode@/: two or three-letter ISO-639 language code -}+    -> m T.Text+    {- ^ __Returns:__ language name in UTF-8 format, or NULL if /@languageCode@/ could+    not be mapped to a language name. The returned string must not be+    modified and does not need to freed; it will stay valid until the+    application is terminated. -}+tagGetLanguageName languageCode = liftIO $ do+    languageCode' <- textToCString languageCode+    result <- gst_tag_get_language_name languageCode'+    checkUnexpectedReturnNULL "tagGetLanguageName" result+    result' <- cstringToText result+    freeMem languageCode'+    return result'+++-- function gst_tag_get_language_codes+-- Args : []+-- Lengths : []+-- returnType : Just (TCArray True (-1) (-1) (TBasicType TUTF8))+-- throws : False+-- Skip return : False++foreign import ccall "gst_tag_get_language_codes" gst_tag_get_language_codes :: +    IO (Ptr CString)++{- |+Returns a list of known language codes (in form of two-letter ISO-639-1+codes). This is useful for UIs to build a list of available languages for+tagging purposes (e.g. to tag an audio track appropriately in a video or+audio editor).+-}+tagGetLanguageCodes ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    m [T.Text]+    {- ^ __Returns:__ NULL-terminated string array with two-letter+    language codes. Free with 'GI.GLib.Functions.strfreev' when no longer needed. -}+tagGetLanguageCodes  = liftIO $ do+    result <- gst_tag_get_language_codes+    checkUnexpectedReturnNULL "tagGetLanguageCodes" result+    result' <- unpackZeroTerminatedUTF8CArray result+    mapZeroTerminatedCArray freeMem result+    freeMem result+    return result'+++-- function gst_tag_get_language_code_iso_639_2T+-- Args : [Arg {argCName = "lang_code", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "ISO-639 language code (e.g. \"deu\" or \"ger\" or \"de\")", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TUTF8)+-- throws : False+-- Skip return : False++foreign import ccall "gst_tag_get_language_code_iso_639_2T" gst_tag_get_language_code_iso_639_2T :: +    CString ->                              -- lang_code : TBasicType TUTF8+    IO CString++{- |+Returns three-letter ISO-639-2 \"terminological\" language code given a+two-letter ISO-639-1 language code or a three-letter ISO-639-2 language+code (both are accepted for convenience).++The \"terminological\" code is derived from the local name of the language+(e.g. \"deu\" for German instead of \"ger\"). In most scenarios, the+\"terminological\" codes are prefered over the \"bibliographic\" ones.++Language codes are case-sensitive and expected to be lower case.+-}+tagGetLanguageCodeIso6392T ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    T.Text+    {- ^ /@langCode@/: ISO-639 language code (e.g. \"deu\" or \"ger\" or \"de\") -}+    -> m T.Text+    {- ^ __Returns:__ three-letter ISO-639-2 language code string that maps to /@langCode@/,+    or NULL if no mapping is known. The returned string must not be+    modified or freed. -}+tagGetLanguageCodeIso6392T langCode = liftIO $ do+    langCode' <- textToCString langCode+    result <- gst_tag_get_language_code_iso_639_2T langCode'+    checkUnexpectedReturnNULL "tagGetLanguageCodeIso6392T" result+    result' <- cstringToText result+    freeMem langCode'+    return result'+++-- function gst_tag_get_language_code_iso_639_2B+-- Args : [Arg {argCName = "lang_code", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "ISO-639 language code (e.g. \"deu\" or \"ger\" or \"de\")", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TUTF8)+-- throws : False+-- Skip return : False++foreign import ccall "gst_tag_get_language_code_iso_639_2B" gst_tag_get_language_code_iso_639_2B :: +    CString ->                              -- lang_code : TBasicType TUTF8+    IO CString++{- |+Returns three-letter ISO-639-2 \"bibliographic\" language code given a+two-letter ISO-639-1 language code or a three-letter ISO-639-2 language+code (both are accepted for convenience).++The \"bibliographic\" code is derived from the English name of the language+(e.g. \"ger\" for German instead of \"de\" or \"deu\"). In most scenarios, the+\"terminological\" codes are prefered.++Language codes are case-sensitive and expected to be lower case.+-}+tagGetLanguageCodeIso6392B ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    T.Text+    {- ^ /@langCode@/: ISO-639 language code (e.g. \"deu\" or \"ger\" or \"de\") -}+    -> m T.Text+    {- ^ __Returns:__ three-letter ISO-639-2 language code string that maps to /@langCode@/,+    or NULL if no mapping is known. The returned string must not be+    modified or freed. -}+tagGetLanguageCodeIso6392B langCode = liftIO $ do+    langCode' <- textToCString langCode+    result <- gst_tag_get_language_code_iso_639_2B langCode'+    checkUnexpectedReturnNULL "tagGetLanguageCodeIso6392B" result+    result' <- cstringToText result+    freeMem langCode'+    return result'+++-- function gst_tag_get_language_code_iso_639_1+-- Args : [Arg {argCName = "lang_code", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "ISO-639 language code (e.g. \"deu\" or \"ger\" or \"de\")", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TUTF8)+-- throws : False+-- Skip return : False++foreign import ccall "gst_tag_get_language_code_iso_639_1" gst_tag_get_language_code_iso_639_1 :: +    CString ->                              -- lang_code : TBasicType TUTF8+    IO CString++{- |+Returns two-letter ISO-639-1 language code given a three-letter ISO-639-2+language code or two-letter ISO-639-1 language code (both are accepted for+convenience).++Language codes are case-sensitive and expected to be lower case.+-}+tagGetLanguageCodeIso6391 ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    T.Text+    {- ^ /@langCode@/: ISO-639 language code (e.g. \"deu\" or \"ger\" or \"de\") -}+    -> m T.Text+    {- ^ __Returns:__ two-letter ISO-639-1 language code string that maps to /@langCode@/,+    or NULL if no mapping is known. The returned string must not be+    modified or freed. -}+tagGetLanguageCodeIso6391 langCode = liftIO $ do+    langCode' <- textToCString langCode+    result <- gst_tag_get_language_code_iso_639_1 langCode'+    checkUnexpectedReturnNULL "tagGetLanguageCodeIso6391" result+    result' <- cstringToText result+    freeMem langCode'+    return result'+++-- function gst_tag_get_id3v2_tag_size+-- Args : [Arg {argCName = "buffer", argType = TInterface (Name {namespace = "Gst", name = "Buffer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "buffer holding ID3v2 tag (or at least the start of one)", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TUInt)+-- throws : False+-- Skip return : False++foreign import ccall "gst_tag_get_id3v2_tag_size" gst_tag_get_id3v2_tag_size :: +    Ptr Gst.Buffer.Buffer ->                -- buffer : TInterface (Name {namespace = "Gst", name = "Buffer"})+    IO Word32++{- |+Determines size of an ID3v2 tag on buffer containing at least ID3v2 header,+i.e. at least 'GI.GstTag.Constants.TAG_ID3V2_HEADER_SIZE' (10) bytes;+-}+tagGetId3v2TagSize ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    Gst.Buffer.Buffer+    {- ^ /@buffer@/: buffer holding ID3v2 tag (or at least the start of one) -}+    -> m Word32+    {- ^ __Returns:__ Size of tag, or 0 if header is invalid or too small. -}+tagGetId3v2TagSize buffer = liftIO $ do+    buffer' <- unsafeManagedPtrGetPtr buffer+    result <- gst_tag_get_id3v2_tag_size buffer'+    touchManagedPtr buffer+    return result+++-- function gst_tag_from_vorbis_tag+-- Args : [Arg {argCName = "vorbis_tag", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "vorbiscomment tag to convert to GStreamer tag", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TUTF8)+-- throws : False+-- Skip return : False++foreign import ccall "gst_tag_from_vorbis_tag" gst_tag_from_vorbis_tag :: +    CString ->                              -- vorbis_tag : TBasicType TUTF8+    IO CString++{- |+Looks up the GStreamer tag for a vorbiscomment tag.+-}+tagFromVorbisTag ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    T.Text+    {- ^ /@vorbisTag@/: vorbiscomment tag to convert to GStreamer tag -}+    -> m T.Text+    {- ^ __Returns:__ The corresponding GStreamer tag or NULL if none exists. -}+tagFromVorbisTag vorbisTag = liftIO $ do+    vorbisTag' <- textToCString vorbisTag+    result <- gst_tag_from_vorbis_tag vorbisTag'+    checkUnexpectedReturnNULL "tagFromVorbisTag" result+    result' <- cstringToText result+    freeMem vorbisTag'+    return result'+++-- function gst_tag_from_id3_user_tag+-- Args : [Arg {argCName = "type", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the type of ID3v2 user tag (e.g. \"TXXX\" or \"UDIF\")", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "id3_user_tag", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "ID3v2 user tag to convert to GStreamer tag", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TUTF8)+-- throws : False+-- Skip return : False++foreign import ccall "gst_tag_from_id3_user_tag" gst_tag_from_id3_user_tag :: +    CString ->                              -- type : TBasicType TUTF8+    CString ->                              -- id3_user_tag : TBasicType TUTF8+    IO CString++{- |+Looks up the GStreamer tag for an ID3v2 user tag (e.g. description in+TXXX frame or owner in UFID frame).+-}+tagFromId3UserTag ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    T.Text+    {- ^ /@type@/: the type of ID3v2 user tag (e.g. \"TXXX\" or \"UDIF\") -}+    -> T.Text+    {- ^ /@id3UserTag@/: ID3v2 user tag to convert to GStreamer tag -}+    -> m T.Text+    {- ^ __Returns:__ The corresponding GStreamer tag or NULL if none exists. -}+tagFromId3UserTag type_ id3UserTag = liftIO $ do+    type_' <- textToCString type_+    id3UserTag' <- textToCString id3UserTag+    result <- gst_tag_from_id3_user_tag type_' id3UserTag'+    checkUnexpectedReturnNULL "tagFromId3UserTag" result+    result' <- cstringToText result+    freeMem type_'+    freeMem id3UserTag'+    return result'+++-- function gst_tag_from_id3_tag+-- Args : [Arg {argCName = "id3_tag", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "ID3v2 tag to convert to GStreamer tag", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TUTF8)+-- throws : False+-- Skip return : False++foreign import ccall "gst_tag_from_id3_tag" gst_tag_from_id3_tag :: +    CString ->                              -- id3_tag : TBasicType TUTF8+    IO CString++{- |+Looks up the GStreamer tag for a ID3v2 tag.+-}+tagFromId3Tag ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    T.Text+    {- ^ /@id3Tag@/: ID3v2 tag to convert to GStreamer tag -}+    -> m T.Text+    {- ^ __Returns:__ The corresponding GStreamer tag or NULL if none exists. -}+tagFromId3Tag id3Tag = liftIO $ do+    id3Tag' <- textToCString id3Tag+    result <- gst_tag_from_id3_tag id3Tag'+    checkUnexpectedReturnNULL "tagFromId3Tag" result+    result' <- cstringToText result+    freeMem id3Tag'+    return result'+++-- function gst_tag_freeform_string_to_utf8+-- Args : [Arg {argCName = "data", argType = TCArray False (-1) 1 (TBasicType TInt8), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "string data", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "size", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "length of string data, or -1 if the string is NUL-terminated", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "env_vars", argType = TCArray True (-1) (-1) (TBasicType TUTF8), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "\n   a NULL-terminated string array of environment variable names, or NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : [Arg {argCName = "size", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "length of string data, or -1 if the string is NUL-terminated", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- returnType : Just (TBasicType TUTF8)+-- throws : False+-- Skip return : False++foreign import ccall "gst_tag_freeform_string_to_utf8" gst_tag_freeform_string_to_utf8 :: +    Ptr Int8 ->                             -- data : TCArray False (-1) 1 (TBasicType TInt8)+    Int32 ->                                -- size : TBasicType TInt+    Ptr CString ->                          -- env_vars : TCArray True (-1) (-1) (TBasicType TUTF8)+    IO CString++{- |+Convenience function to read a string with unknown character encoding. If+the string is already in UTF-8 encoding, it will be returned right away.+If not it tries to detect byte-order-mark for UTF-16\/32 cases and use that.+Otherwise, the environment will be searched for a number of environment+variables (whose names are specified in the NULL-terminated string array+/@envVars@/) containing a list of character encodings to try\/use. If none+are specified, the current locale will be tried. If that also doesn\'t work,+WINDOWS-1252\/ISO-8859-1 is assumed (which will almost always succeed).+-}+tagFreeformStringToUtf8 ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    [Int8]+    {- ^ /@data@/: string data -}+    -> [T.Text]+    {- ^ /@envVars@/: +   a NULL-terminated string array of environment variable names, or NULL -}+    -> m T.Text+    {- ^ __Returns:__ a newly-allocated string in UTF-8 encoding, or NULL -}+tagFreeformStringToUtf8 data_ envVars = liftIO $ do+    let size = fromIntegral $ length data_+    data_' <- packStorableArray data_+    envVars' <- packZeroTerminatedUTF8CArray envVars+    result <- gst_tag_freeform_string_to_utf8 data_' size envVars'+    checkUnexpectedReturnNULL "tagFreeformStringToUtf8" result+    result' <- cstringToText result+    freeMem result+    freeMem data_'+    mapZeroTerminatedCArray freeMem envVars'+    freeMem envVars'+    return result'+++-- function gst_tag_check_language_code+-- Args : [Arg {argCName = "lang_code", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "ISO-639 language code (e.g. \"deu\" or \"ger\" or \"de\")", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TBoolean)+-- throws : False+-- Skip return : False++foreign import ccall "gst_tag_check_language_code" gst_tag_check_language_code :: +    CString ->                              -- lang_code : TBasicType TUTF8+    IO CInt++{- |+Check if a given string contains a known ISO 639 language code.++This is useful in situations where it\'s not clear whether a given+string is a language code (which should be put into a 'GI.Gst.Constants.TAG_LANGUAGE_CODE'+tag) or a free-form language name descriptor (which should be put into a+'GI.Gst.Constants.TAG_LANGUAGE_NAME' tag instead).+-}+tagCheckLanguageCode ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    T.Text+    {- ^ /@langCode@/: ISO-639 language code (e.g. \"deu\" or \"ger\" or \"de\") -}+    -> m Bool+    {- ^ __Returns:__ TRUE if the two- or three-letter language code in /@langCode@/+    is a valid ISO-639 language code. -}+tagCheckLanguageCode langCode = liftIO $ do+    langCode' <- textToCString langCode+    result <- gst_tag_check_language_code langCode'+    let result' = (/= 0) result+    freeMem langCode'+    return result'+++

@@ -0,0 +1,41 @@+++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc)+-}++#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \+       && !defined(__HADDOCK_VERSION__))++module GI.GstTag.Interfaces+    (     module GI.GstTag.Interfaces.TagXmpWriter,+++    ) where++import GI.GstTag.Interfaces.TagXmpWriter++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.ManagedPtr as B.ManagedPtr+import qualified Data.GI.Base.GClosure as B.GClosure+import qualified Data.GI.Base.GError as B.GError+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.Text as T+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+++

@@ -0,0 +1,499 @@+++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc)++This interface is implemented by elements that are able to do XMP serialization. Examples for+such elements are @/jifmux/@ and @/qtmux/@.++Applications can use this interface to configure which XMP schemas should be used when serializing+tags into XMP. Schemas are represented by their names, a full list of the supported schemas can be+obtained from 'GI.GstTag.Functions.tagXmpListSchemas'. By default, all schemas are used.+-}++#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \+       && !defined(__HADDOCK_VERSION__))++module GI.GstTag.Interfaces.TagXmpWriter+    ( ++-- * Exported types+    TagXmpWriter(..)                        ,+    noTagXmpWriter                          ,+    IsTagXmpWriter                          ,+    toTagXmpWriter                          ,+++ -- * Methods+-- ** addAllSchemas #method:addAllSchemas#++#if ENABLE_OVERLOADING+    TagXmpWriterAddAllSchemasMethodInfo     ,+#endif+    tagXmpWriterAddAllSchemas               ,+++-- ** addSchema #method:addSchema#++#if ENABLE_OVERLOADING+    TagXmpWriterAddSchemaMethodInfo         ,+#endif+    tagXmpWriterAddSchema                   ,+++-- ** hasSchema #method:hasSchema#++#if ENABLE_OVERLOADING+    TagXmpWriterHasSchemaMethodInfo         ,+#endif+    tagXmpWriterHasSchema                   ,+++-- ** removeAllSchemas #method:removeAllSchemas#++#if ENABLE_OVERLOADING+    TagXmpWriterRemoveAllSchemasMethodInfo  ,+#endif+    tagXmpWriterRemoveAllSchemas            ,+++-- ** removeSchema #method:removeSchema#++#if ENABLE_OVERLOADING+    TagXmpWriterRemoveSchemaMethodInfo      ,+#endif+    tagXmpWriterRemoveSchema                ,+++-- ** tagListToXmpBuffer #method:tagListToXmpBuffer#++#if ENABLE_OVERLOADING+    TagXmpWriterTagListToXmpBufferMethodInfo,+#endif+    tagXmpWriterTagListToXmpBuffer          ,+++++    ) 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.ManagedPtr as B.ManagedPtr+import qualified Data.GI.Base.GClosure as B.GClosure+import qualified Data.GI.Base.GError as B.GError+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.Text as T+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 GI.GObject.Objects.Object as GObject.Object+import qualified GI.Gst.Objects.Element as Gst.Element+import qualified GI.Gst.Objects.Object as Gst.Object+import qualified GI.Gst.Structs.Buffer as Gst.Buffer+import qualified GI.Gst.Structs.TagList as Gst.TagList++-- interface TagXmpWriter +-- | Memory-managed wrapper type.+newtype TagXmpWriter = TagXmpWriter (ManagedPtr TagXmpWriter)+-- | A convenience alias for `Nothing` :: `Maybe` `TagXmpWriter`.+noTagXmpWriter :: Maybe TagXmpWriter+noTagXmpWriter = Nothing++#if ENABLE_OVERLOADING+type instance O.SignalList TagXmpWriter = TagXmpWriterSignalList+type TagXmpWriterSignalList = ('[ '("deepNotify", Gst.Object.ObjectDeepNotifySignalInfo), '("noMorePads", Gst.Element.ElementNoMorePadsSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo), '("padAdded", Gst.Element.ElementPadAddedSignalInfo), '("padRemoved", Gst.Element.ElementPadRemovedSignalInfo)] :: [(Symbol, *)])++#endif++foreign import ccall "gst_tag_xmp_writer_get_type"+    c_gst_tag_xmp_writer_get_type :: IO GType++instance GObject TagXmpWriter where+    gobjectType = c_gst_tag_xmp_writer_get_type+    ++-- | Type class for types which can be safely cast to `TagXmpWriter`, for instance with `toTagXmpWriter`.+class (GObject o, O.IsDescendantOf TagXmpWriter o) => IsTagXmpWriter o+instance (GObject o, O.IsDescendantOf TagXmpWriter o) => IsTagXmpWriter o++instance O.HasParentTypes TagXmpWriter+type instance O.ParentTypes TagXmpWriter = '[Gst.Element.Element, Gst.Object.Object, GObject.Object.Object]++-- | Cast to `TagXmpWriter`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`.+toTagXmpWriter :: (MonadIO m, IsTagXmpWriter o) => o -> m TagXmpWriter+toTagXmpWriter = liftIO . unsafeCastTo TagXmpWriter++#if ENABLE_OVERLOADING+instance O.HasAttributeList TagXmpWriter+type instance O.AttributeList TagXmpWriter = TagXmpWriterAttributeList+type TagXmpWriterAttributeList = ('[ '("name", Gst.Object.ObjectNamePropertyInfo), '("parent", Gst.Object.ObjectParentPropertyInfo)] :: [(Symbol, *)])+#endif++#if ENABLE_OVERLOADING+#endif++#if ENABLE_OVERLOADING+type family ResolveTagXmpWriterMethod (t :: Symbol) (o :: *) :: * where+    ResolveTagXmpWriterMethod "abortState" o = Gst.Element.ElementAbortStateMethodInfo+    ResolveTagXmpWriterMethod "addAllSchemas" o = TagXmpWriterAddAllSchemasMethodInfo+    ResolveTagXmpWriterMethod "addControlBinding" o = Gst.Object.ObjectAddControlBindingMethodInfo+    ResolveTagXmpWriterMethod "addPad" o = Gst.Element.ElementAddPadMethodInfo+    ResolveTagXmpWriterMethod "addPropertyDeepNotifyWatch" o = Gst.Element.ElementAddPropertyDeepNotifyWatchMethodInfo+    ResolveTagXmpWriterMethod "addPropertyNotifyWatch" o = Gst.Element.ElementAddPropertyNotifyWatchMethodInfo+    ResolveTagXmpWriterMethod "addSchema" o = TagXmpWriterAddSchemaMethodInfo+    ResolveTagXmpWriterMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo+    ResolveTagXmpWriterMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo+    ResolveTagXmpWriterMethod "callAsync" o = Gst.Element.ElementCallAsyncMethodInfo+    ResolveTagXmpWriterMethod "changeState" o = Gst.Element.ElementChangeStateMethodInfo+    ResolveTagXmpWriterMethod "continueState" o = Gst.Element.ElementContinueStateMethodInfo+    ResolveTagXmpWriterMethod "createAllPads" o = Gst.Element.ElementCreateAllPadsMethodInfo+    ResolveTagXmpWriterMethod "defaultError" o = Gst.Object.ObjectDefaultErrorMethodInfo+    ResolveTagXmpWriterMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo+    ResolveTagXmpWriterMethod "foreachPad" o = Gst.Element.ElementForeachPadMethodInfo+    ResolveTagXmpWriterMethod "foreachSinkPad" o = Gst.Element.ElementForeachSinkPadMethodInfo+    ResolveTagXmpWriterMethod "foreachSrcPad" o = Gst.Element.ElementForeachSrcPadMethodInfo+    ResolveTagXmpWriterMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo+    ResolveTagXmpWriterMethod "getv" o = GObject.Object.ObjectGetvMethodInfo+    ResolveTagXmpWriterMethod "hasActiveControlBindings" o = Gst.Object.ObjectHasActiveControlBindingsMethodInfo+    ResolveTagXmpWriterMethod "hasAncestor" o = Gst.Object.ObjectHasAncestorMethodInfo+    ResolveTagXmpWriterMethod "hasAsAncestor" o = Gst.Object.ObjectHasAsAncestorMethodInfo+    ResolveTagXmpWriterMethod "hasAsParent" o = Gst.Object.ObjectHasAsParentMethodInfo+    ResolveTagXmpWriterMethod "hasSchema" o = TagXmpWriterHasSchemaMethodInfo+    ResolveTagXmpWriterMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo+    ResolveTagXmpWriterMethod "isLockedState" o = Gst.Element.ElementIsLockedStateMethodInfo+    ResolveTagXmpWriterMethod "iteratePads" o = Gst.Element.ElementIteratePadsMethodInfo+    ResolveTagXmpWriterMethod "iterateSinkPads" o = Gst.Element.ElementIterateSinkPadsMethodInfo+    ResolveTagXmpWriterMethod "iterateSrcPads" o = Gst.Element.ElementIterateSrcPadsMethodInfo+    ResolveTagXmpWriterMethod "link" o = Gst.Element.ElementLinkMethodInfo+    ResolveTagXmpWriterMethod "linkFiltered" o = Gst.Element.ElementLinkFilteredMethodInfo+    ResolveTagXmpWriterMethod "linkPads" o = Gst.Element.ElementLinkPadsMethodInfo+    ResolveTagXmpWriterMethod "linkPadsFiltered" o = Gst.Element.ElementLinkPadsFilteredMethodInfo+    ResolveTagXmpWriterMethod "linkPadsFull" o = Gst.Element.ElementLinkPadsFullMethodInfo+    ResolveTagXmpWriterMethod "lostState" o = Gst.Element.ElementLostStateMethodInfo+    ResolveTagXmpWriterMethod "messageFull" o = Gst.Element.ElementMessageFullMethodInfo+    ResolveTagXmpWriterMethod "messageFullWithDetails" o = Gst.Element.ElementMessageFullWithDetailsMethodInfo+    ResolveTagXmpWriterMethod "noMorePads" o = Gst.Element.ElementNoMorePadsMethodInfo+    ResolveTagXmpWriterMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo+    ResolveTagXmpWriterMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo+    ResolveTagXmpWriterMethod "postMessage" o = Gst.Element.ElementPostMessageMethodInfo+    ResolveTagXmpWriterMethod "provideClock" o = Gst.Element.ElementProvideClockMethodInfo+    ResolveTagXmpWriterMethod "query" o = Gst.Element.ElementQueryMethodInfo+    ResolveTagXmpWriterMethod "queryConvert" o = Gst.Element.ElementQueryConvertMethodInfo+    ResolveTagXmpWriterMethod "queryDuration" o = Gst.Element.ElementQueryDurationMethodInfo+    ResolveTagXmpWriterMethod "queryPosition" o = Gst.Element.ElementQueryPositionMethodInfo+    ResolveTagXmpWriterMethod "ref" o = Gst.Object.ObjectRefMethodInfo+    ResolveTagXmpWriterMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo+    ResolveTagXmpWriterMethod "releaseRequestPad" o = Gst.Element.ElementReleaseRequestPadMethodInfo+    ResolveTagXmpWriterMethod "removeAllSchemas" o = TagXmpWriterRemoveAllSchemasMethodInfo+    ResolveTagXmpWriterMethod "removeControlBinding" o = Gst.Object.ObjectRemoveControlBindingMethodInfo+    ResolveTagXmpWriterMethod "removePad" o = Gst.Element.ElementRemovePadMethodInfo+    ResolveTagXmpWriterMethod "removePropertyNotifyWatch" o = Gst.Element.ElementRemovePropertyNotifyWatchMethodInfo+    ResolveTagXmpWriterMethod "removeSchema" o = TagXmpWriterRemoveSchemaMethodInfo+    ResolveTagXmpWriterMethod "requestPad" o = Gst.Element.ElementRequestPadMethodInfo+    ResolveTagXmpWriterMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo+    ResolveTagXmpWriterMethod "seek" o = Gst.Element.ElementSeekMethodInfo+    ResolveTagXmpWriterMethod "seekSimple" o = Gst.Element.ElementSeekSimpleMethodInfo+    ResolveTagXmpWriterMethod "sendEvent" o = Gst.Element.ElementSendEventMethodInfo+    ResolveTagXmpWriterMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo+    ResolveTagXmpWriterMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo+    ResolveTagXmpWriterMethod "suggestNextSync" o = Gst.Object.ObjectSuggestNextSyncMethodInfo+    ResolveTagXmpWriterMethod "syncStateWithParent" o = Gst.Element.ElementSyncStateWithParentMethodInfo+    ResolveTagXmpWriterMethod "syncValues" o = Gst.Object.ObjectSyncValuesMethodInfo+    ResolveTagXmpWriterMethod "tagListToXmpBuffer" o = TagXmpWriterTagListToXmpBufferMethodInfo+    ResolveTagXmpWriterMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo+    ResolveTagXmpWriterMethod "unlink" o = Gst.Element.ElementUnlinkMethodInfo+    ResolveTagXmpWriterMethod "unlinkPads" o = Gst.Element.ElementUnlinkPadsMethodInfo+    ResolveTagXmpWriterMethod "unparent" o = Gst.Object.ObjectUnparentMethodInfo+    ResolveTagXmpWriterMethod "unref" o = Gst.Object.ObjectUnrefMethodInfo+    ResolveTagXmpWriterMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo+    ResolveTagXmpWriterMethod "getBaseTime" o = Gst.Element.ElementGetBaseTimeMethodInfo+    ResolveTagXmpWriterMethod "getBus" o = Gst.Element.ElementGetBusMethodInfo+    ResolveTagXmpWriterMethod "getClock" o = Gst.Element.ElementGetClockMethodInfo+    ResolveTagXmpWriterMethod "getCompatiblePad" o = Gst.Element.ElementGetCompatiblePadMethodInfo+    ResolveTagXmpWriterMethod "getCompatiblePadTemplate" o = Gst.Element.ElementGetCompatiblePadTemplateMethodInfo+    ResolveTagXmpWriterMethod "getContext" o = Gst.Element.ElementGetContextMethodInfo+    ResolveTagXmpWriterMethod "getContextUnlocked" o = Gst.Element.ElementGetContextUnlockedMethodInfo+    ResolveTagXmpWriterMethod "getContexts" o = Gst.Element.ElementGetContextsMethodInfo+    ResolveTagXmpWriterMethod "getControlBinding" o = Gst.Object.ObjectGetControlBindingMethodInfo+    ResolveTagXmpWriterMethod "getControlRate" o = Gst.Object.ObjectGetControlRateMethodInfo+    ResolveTagXmpWriterMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo+    ResolveTagXmpWriterMethod "getFactory" o = Gst.Element.ElementGetFactoryMethodInfo+    ResolveTagXmpWriterMethod "getGValueArray" o = Gst.Object.ObjectGetGValueArrayMethodInfo+    ResolveTagXmpWriterMethod "getMetadata" o = Gst.Element.ElementGetMetadataMethodInfo+    ResolveTagXmpWriterMethod "getName" o = Gst.Object.ObjectGetNameMethodInfo+    ResolveTagXmpWriterMethod "getPadTemplate" o = Gst.Element.ElementGetPadTemplateMethodInfo+    ResolveTagXmpWriterMethod "getPadTemplateList" o = Gst.Element.ElementGetPadTemplateListMethodInfo+    ResolveTagXmpWriterMethod "getParent" o = Gst.Object.ObjectGetParentMethodInfo+    ResolveTagXmpWriterMethod "getPathString" o = Gst.Object.ObjectGetPathStringMethodInfo+    ResolveTagXmpWriterMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo+    ResolveTagXmpWriterMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo+    ResolveTagXmpWriterMethod "getRequestPad" o = Gst.Element.ElementGetRequestPadMethodInfo+    ResolveTagXmpWriterMethod "getStartTime" o = Gst.Element.ElementGetStartTimeMethodInfo+    ResolveTagXmpWriterMethod "getState" o = Gst.Element.ElementGetStateMethodInfo+    ResolveTagXmpWriterMethod "getStaticPad" o = Gst.Element.ElementGetStaticPadMethodInfo+    ResolveTagXmpWriterMethod "getValue" o = Gst.Object.ObjectGetValueMethodInfo+    ResolveTagXmpWriterMethod "setBaseTime" o = Gst.Element.ElementSetBaseTimeMethodInfo+    ResolveTagXmpWriterMethod "setBus" o = Gst.Element.ElementSetBusMethodInfo+    ResolveTagXmpWriterMethod "setClock" o = Gst.Element.ElementSetClockMethodInfo+    ResolveTagXmpWriterMethod "setContext" o = Gst.Element.ElementSetContextMethodInfo+    ResolveTagXmpWriterMethod "setControlBindingDisabled" o = Gst.Object.ObjectSetControlBindingDisabledMethodInfo+    ResolveTagXmpWriterMethod "setControlBindingsDisabled" o = Gst.Object.ObjectSetControlBindingsDisabledMethodInfo+    ResolveTagXmpWriterMethod "setControlRate" o = Gst.Object.ObjectSetControlRateMethodInfo+    ResolveTagXmpWriterMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo+    ResolveTagXmpWriterMethod "setLockedState" o = Gst.Element.ElementSetLockedStateMethodInfo+    ResolveTagXmpWriterMethod "setName" o = Gst.Object.ObjectSetNameMethodInfo+    ResolveTagXmpWriterMethod "setParent" o = Gst.Object.ObjectSetParentMethodInfo+    ResolveTagXmpWriterMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo+    ResolveTagXmpWriterMethod "setStartTime" o = Gst.Element.ElementSetStartTimeMethodInfo+    ResolveTagXmpWriterMethod "setState" o = Gst.Element.ElementSetStateMethodInfo+    ResolveTagXmpWriterMethod l o = O.MethodResolutionFailed l o++instance (info ~ ResolveTagXmpWriterMethod t TagXmpWriter, O.MethodInfo info TagXmpWriter p) => OL.IsLabel t (TagXmpWriter -> p) where+#if MIN_VERSION_base(4,10,0)+    fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)+#else+    fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)+#endif++#endif++-- method TagXmpWriter::add_all_schemas+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "config", argType = TInterface (Name {namespace = "GstTag", name = "TagXmpWriter"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstTagXmpWriter", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Nothing+-- throws : False+-- Skip return : False++foreign import ccall "gst_tag_xmp_writer_add_all_schemas" gst_tag_xmp_writer_add_all_schemas :: +    Ptr TagXmpWriter ->                     -- config : TInterface (Name {namespace = "GstTag", name = "TagXmpWriter"})+    IO ()++{- |+Adds all available XMP schemas to the configuration. Meaning that+all will be used.+-}+tagXmpWriterAddAllSchemas ::+    (B.CallStack.HasCallStack, MonadIO m, IsTagXmpWriter a) =>+    a+    {- ^ /@config@/: a 'GI.GstTag.Interfaces.TagXmpWriter.TagXmpWriter' -}+    -> m ()+tagXmpWriterAddAllSchemas config = liftIO $ do+    config' <- unsafeManagedPtrCastPtr config+    gst_tag_xmp_writer_add_all_schemas config'+    touchManagedPtr config+    return ()++#if ENABLE_OVERLOADING+data TagXmpWriterAddAllSchemasMethodInfo+instance (signature ~ (m ()), MonadIO m, IsTagXmpWriter a) => O.MethodInfo TagXmpWriterAddAllSchemasMethodInfo a signature where+    overloadedMethod _ = tagXmpWriterAddAllSchemas++#endif++-- method TagXmpWriter::add_schema+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "config", argType = TInterface (Name {namespace = "GstTag", name = "TagXmpWriter"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstTagXmpWriter", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "schema", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the schema to be added", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Nothing+-- throws : False+-- Skip return : False++foreign import ccall "gst_tag_xmp_writer_add_schema" gst_tag_xmp_writer_add_schema :: +    Ptr TagXmpWriter ->                     -- config : TInterface (Name {namespace = "GstTag", name = "TagXmpWriter"})+    CString ->                              -- schema : TBasicType TUTF8+    IO ()++{- |+Adds /@schema@/ to the list schemas+-}+tagXmpWriterAddSchema ::+    (B.CallStack.HasCallStack, MonadIO m, IsTagXmpWriter a) =>+    a+    {- ^ /@config@/: a 'GI.GstTag.Interfaces.TagXmpWriter.TagXmpWriter' -}+    -> T.Text+    {- ^ /@schema@/: the schema to be added -}+    -> m ()+tagXmpWriterAddSchema config schema = liftIO $ do+    config' <- unsafeManagedPtrCastPtr config+    schema' <- textToCString schema+    gst_tag_xmp_writer_add_schema config' schema'+    touchManagedPtr config+    freeMem schema'+    return ()++#if ENABLE_OVERLOADING+data TagXmpWriterAddSchemaMethodInfo+instance (signature ~ (T.Text -> m ()), MonadIO m, IsTagXmpWriter a) => O.MethodInfo TagXmpWriterAddSchemaMethodInfo a signature where+    overloadedMethod _ = tagXmpWriterAddSchema++#endif++-- method TagXmpWriter::has_schema+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "config", argType = TInterface (Name {namespace = "GstTag", name = "TagXmpWriter"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstTagXmpWriter", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "schema", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the schema to test", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TBoolean)+-- throws : False+-- Skip return : False++foreign import ccall "gst_tag_xmp_writer_has_schema" gst_tag_xmp_writer_has_schema :: +    Ptr TagXmpWriter ->                     -- config : TInterface (Name {namespace = "GstTag", name = "TagXmpWriter"})+    CString ->                              -- schema : TBasicType TUTF8+    IO CInt++{- |+Checks if /@schema@/ is going to be used+-}+tagXmpWriterHasSchema ::+    (B.CallStack.HasCallStack, MonadIO m, IsTagXmpWriter a) =>+    a+    {- ^ /@config@/: a 'GI.GstTag.Interfaces.TagXmpWriter.TagXmpWriter' -}+    -> T.Text+    {- ^ /@schema@/: the schema to test -}+    -> m Bool+    {- ^ __Returns:__ 'True' if it is going to be used -}+tagXmpWriterHasSchema config schema = liftIO $ do+    config' <- unsafeManagedPtrCastPtr config+    schema' <- textToCString schema+    result <- gst_tag_xmp_writer_has_schema config' schema'+    let result' = (/= 0) result+    touchManagedPtr config+    freeMem schema'+    return result'++#if ENABLE_OVERLOADING+data TagXmpWriterHasSchemaMethodInfo+instance (signature ~ (T.Text -> m Bool), MonadIO m, IsTagXmpWriter a) => O.MethodInfo TagXmpWriterHasSchemaMethodInfo a signature where+    overloadedMethod _ = tagXmpWriterHasSchema++#endif++-- method TagXmpWriter::remove_all_schemas+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "config", argType = TInterface (Name {namespace = "GstTag", name = "TagXmpWriter"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstTagXmpWriter", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Nothing+-- throws : False+-- Skip return : False++foreign import ccall "gst_tag_xmp_writer_remove_all_schemas" gst_tag_xmp_writer_remove_all_schemas :: +    Ptr TagXmpWriter ->                     -- config : TInterface (Name {namespace = "GstTag", name = "TagXmpWriter"})+    IO ()++{- |+Removes all schemas from the list of schemas to use. Meaning that no+XMP will be generated.+-}+tagXmpWriterRemoveAllSchemas ::+    (B.CallStack.HasCallStack, MonadIO m, IsTagXmpWriter a) =>+    a+    {- ^ /@config@/: a 'GI.GstTag.Interfaces.TagXmpWriter.TagXmpWriter' -}+    -> m ()+tagXmpWriterRemoveAllSchemas config = liftIO $ do+    config' <- unsafeManagedPtrCastPtr config+    gst_tag_xmp_writer_remove_all_schemas config'+    touchManagedPtr config+    return ()++#if ENABLE_OVERLOADING+data TagXmpWriterRemoveAllSchemasMethodInfo+instance (signature ~ (m ()), MonadIO m, IsTagXmpWriter a) => O.MethodInfo TagXmpWriterRemoveAllSchemasMethodInfo a signature where+    overloadedMethod _ = tagXmpWriterRemoveAllSchemas++#endif++-- method TagXmpWriter::remove_schema+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "config", argType = TInterface (Name {namespace = "GstTag", name = "TagXmpWriter"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstTagXmpWriter", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "schema", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the schema to remove", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Nothing+-- throws : False+-- Skip return : False++foreign import ccall "gst_tag_xmp_writer_remove_schema" gst_tag_xmp_writer_remove_schema :: +    Ptr TagXmpWriter ->                     -- config : TInterface (Name {namespace = "GstTag", name = "TagXmpWriter"})+    CString ->                              -- schema : TBasicType TUTF8+    IO ()++{- |+Removes a schema from the list of schemas to use. Nothing is done if+the schema wasn\'t in the list+-}+tagXmpWriterRemoveSchema ::+    (B.CallStack.HasCallStack, MonadIO m, IsTagXmpWriter a) =>+    a+    {- ^ /@config@/: a 'GI.GstTag.Interfaces.TagXmpWriter.TagXmpWriter' -}+    -> T.Text+    {- ^ /@schema@/: the schema to remove -}+    -> m ()+tagXmpWriterRemoveSchema config schema = liftIO $ do+    config' <- unsafeManagedPtrCastPtr config+    schema' <- textToCString schema+    gst_tag_xmp_writer_remove_schema config' schema'+    touchManagedPtr config+    freeMem schema'+    return ()++#if ENABLE_OVERLOADING+data TagXmpWriterRemoveSchemaMethodInfo+instance (signature ~ (T.Text -> m ()), MonadIO m, IsTagXmpWriter a) => O.MethodInfo TagXmpWriterRemoveSchemaMethodInfo a signature where+    overloadedMethod _ = tagXmpWriterRemoveSchema++#endif++-- method TagXmpWriter::tag_list_to_xmp_buffer+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "config", argType = TInterface (Name {namespace = "GstTag", name = "TagXmpWriter"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "taglist", argType = TInterface (Name {namespace = "Gst", name = "TagList"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "read_only", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TInterface (Name {namespace = "Gst", name = "Buffer"}))+-- throws : False+-- Skip return : False++foreign import ccall "gst_tag_xmp_writer_tag_list_to_xmp_buffer" gst_tag_xmp_writer_tag_list_to_xmp_buffer :: +    Ptr TagXmpWriter ->                     -- config : TInterface (Name {namespace = "GstTag", name = "TagXmpWriter"})+    Ptr Gst.TagList.TagList ->              -- taglist : TInterface (Name {namespace = "Gst", name = "TagList"})+    CInt ->                                 -- read_only : TBasicType TBoolean+    IO (Ptr Gst.Buffer.Buffer)++{- |+/No description available in the introspection data./+-}+tagXmpWriterTagListToXmpBuffer ::+    (B.CallStack.HasCallStack, MonadIO m, IsTagXmpWriter a) =>+    a+    -> Gst.TagList.TagList+    -> Bool+    -> m Gst.Buffer.Buffer+tagXmpWriterTagListToXmpBuffer config taglist readOnly = liftIO $ do+    config' <- unsafeManagedPtrCastPtr config+    taglist' <- unsafeManagedPtrGetPtr taglist+    let readOnly' = (fromIntegral . fromEnum) readOnly+    result <- gst_tag_xmp_writer_tag_list_to_xmp_buffer config' taglist' readOnly'+    checkUnexpectedReturnNULL "tagXmpWriterTagListToXmpBuffer" result+    result' <- (wrapBoxed Gst.Buffer.Buffer) result+    touchManagedPtr config+    touchManagedPtr taglist+    return result'++#if ENABLE_OVERLOADING+data TagXmpWriterTagListToXmpBufferMethodInfo+instance (signature ~ (Gst.TagList.TagList -> Bool -> m Gst.Buffer.Buffer), MonadIO m, IsTagXmpWriter a) => O.MethodInfo TagXmpWriterTagListToXmpBufferMethodInfo a signature where+    overloadedMethod _ = tagXmpWriterTagListToXmpBuffer++#endif++

@@ -0,0 +1,47 @@+#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \+       && !defined(__HADDOCK_VERSION__))+module GI.GstTag.Interfaces.TagXmpWriter 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.ManagedPtr as B.ManagedPtr+import qualified Data.GI.Base.GClosure as B.GClosure+import qualified Data.GI.Base.GError as B.GError+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.Text as T+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++newtype TagXmpWriter = TagXmpWriter (ManagedPtr TagXmpWriter)+instance GObject TagXmpWriter where+class (GObject o, O.IsDescendantOf TagXmpWriter o) => IsTagXmpWriter o+instance (GObject o, O.IsDescendantOf TagXmpWriter o) => IsTagXmpWriter o+instance O.HasParentTypes TagXmpWriter+#if ENABLE_OVERLOADING+data TagXmpWriterAddAllSchemasMethodInfo+#endif+#if ENABLE_OVERLOADING+data TagXmpWriterAddSchemaMethodInfo+#endif+#if ENABLE_OVERLOADING+data TagXmpWriterHasSchemaMethodInfo+#endif+#if ENABLE_OVERLOADING+data TagXmpWriterRemoveAllSchemasMethodInfo+#endif+#if ENABLE_OVERLOADING+data TagXmpWriterRemoveSchemaMethodInfo+#endif+#if ENABLE_OVERLOADING+data TagXmpWriterTagListToXmpBufferMethodInfo+#endif

@@ -0,0 +1,43 @@+++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc)+-}++#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \+       && !defined(__HADDOCK_VERSION__))++module GI.GstTag.Objects+    (     module GI.GstTag.Objects.TagDemux       ,+    module GI.GstTag.Objects.TagMux         ,+++    ) where++import GI.GstTag.Objects.TagDemux+import GI.GstTag.Objects.TagMux++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.ManagedPtr as B.ManagedPtr+import qualified Data.GI.Base.GClosure as B.GClosure+import qualified Data.GI.Base.GError as B.GError+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.Text as T+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+++

@@ -0,0 +1,236 @@+++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc)++Provides a base class for demuxing tags at the beginning or end of a+stream and handles things like typefinding, querying, seeking, and+different modes of operation (chain-based, pull_range-based, and providing+downstream elements with random access if upstream supports that). The tag+is stripped from the output, and all offsets are adjusted for the tag+sizes, so that to the downstream element the stream will appear as if+there was no tag at all. Also, once the tag has been parsed, GstTagDemux+will try to determine the media type of the resulting stream and add a+source pad with the appropriate caps in order to facilitate auto-plugging.++== Deriving from GstTagDemux++Subclasses have to do four things:++ * In their base init function, they must add a pad template for the sink+   pad to the element class, describing the media type they can parse in+   the caps of the pad template.+ * In their class init function, they must override+   GST_TAG_DEMUX_CLASS(demux_klass)->identify_tag with their own identify+   function.+ * In their class init function, they must override+ GST_TAG_DEMUX_CLASS(demux_klass)->parse_tag with their own parse+ function.+ * In their class init function, they must also set+   GST_TAG_DEMUX_CLASS(demux_klass)->min_start_size and\/or+ GST_TAG_DEMUX_CLASS(demux_klass)->min_end_size to the minimum size required+ for the identify function to decide whether the stream has a supported tag+ or not. A class parsing ID3v1 tags, for example, would set min_end_size to+ 128 bytes.+-}++#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \+       && !defined(__HADDOCK_VERSION__))++module GI.GstTag.Objects.TagDemux+    ( ++-- * Exported types+    TagDemux(..)                            ,+    IsTagDemux                              ,+    toTagDemux                              ,+    noTagDemux                              ,+++    ) 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.ManagedPtr as B.ManagedPtr+import qualified Data.GI.Base.GClosure as B.GClosure+import qualified Data.GI.Base.GError as B.GError+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.Text as T+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 GI.GObject.Objects.Object as GObject.Object+import qualified GI.Gst.Objects.Element as Gst.Element+import qualified GI.Gst.Objects.Object as Gst.Object++-- | Memory-managed wrapper type.+newtype TagDemux = TagDemux (ManagedPtr TagDemux)+foreign import ccall "gst_tag_demux_get_type"+    c_gst_tag_demux_get_type :: IO GType++instance GObject TagDemux where+    gobjectType = c_gst_tag_demux_get_type+    ++-- | Type class for types which can be safely cast to `TagDemux`, for instance with `toTagDemux`.+class (GObject o, O.IsDescendantOf TagDemux o) => IsTagDemux o+instance (GObject o, O.IsDescendantOf TagDemux o) => IsTagDemux o++instance O.HasParentTypes TagDemux+type instance O.ParentTypes TagDemux = '[Gst.Element.Element, Gst.Object.Object, GObject.Object.Object]++-- | Cast to `TagDemux`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`.+toTagDemux :: (MonadIO m, IsTagDemux o) => o -> m TagDemux+toTagDemux = liftIO . unsafeCastTo TagDemux++-- | A convenience alias for `Nothing` :: `Maybe` `TagDemux`.+noTagDemux :: Maybe TagDemux+noTagDemux = Nothing++#if ENABLE_OVERLOADING+type family ResolveTagDemuxMethod (t :: Symbol) (o :: *) :: * where+    ResolveTagDemuxMethod "abortState" o = Gst.Element.ElementAbortStateMethodInfo+    ResolveTagDemuxMethod "addControlBinding" o = Gst.Object.ObjectAddControlBindingMethodInfo+    ResolveTagDemuxMethod "addPad" o = Gst.Element.ElementAddPadMethodInfo+    ResolveTagDemuxMethod "addPropertyDeepNotifyWatch" o = Gst.Element.ElementAddPropertyDeepNotifyWatchMethodInfo+    ResolveTagDemuxMethod "addPropertyNotifyWatch" o = Gst.Element.ElementAddPropertyNotifyWatchMethodInfo+    ResolveTagDemuxMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo+    ResolveTagDemuxMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo+    ResolveTagDemuxMethod "callAsync" o = Gst.Element.ElementCallAsyncMethodInfo+    ResolveTagDemuxMethod "changeState" o = Gst.Element.ElementChangeStateMethodInfo+    ResolveTagDemuxMethod "continueState" o = Gst.Element.ElementContinueStateMethodInfo+    ResolveTagDemuxMethod "createAllPads" o = Gst.Element.ElementCreateAllPadsMethodInfo+    ResolveTagDemuxMethod "defaultError" o = Gst.Object.ObjectDefaultErrorMethodInfo+    ResolveTagDemuxMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo+    ResolveTagDemuxMethod "foreachPad" o = Gst.Element.ElementForeachPadMethodInfo+    ResolveTagDemuxMethod "foreachSinkPad" o = Gst.Element.ElementForeachSinkPadMethodInfo+    ResolveTagDemuxMethod "foreachSrcPad" o = Gst.Element.ElementForeachSrcPadMethodInfo+    ResolveTagDemuxMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo+    ResolveTagDemuxMethod "getv" o = GObject.Object.ObjectGetvMethodInfo+    ResolveTagDemuxMethod "hasActiveControlBindings" o = Gst.Object.ObjectHasActiveControlBindingsMethodInfo+    ResolveTagDemuxMethod "hasAncestor" o = Gst.Object.ObjectHasAncestorMethodInfo+    ResolveTagDemuxMethod "hasAsAncestor" o = Gst.Object.ObjectHasAsAncestorMethodInfo+    ResolveTagDemuxMethod "hasAsParent" o = Gst.Object.ObjectHasAsParentMethodInfo+    ResolveTagDemuxMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo+    ResolveTagDemuxMethod "isLockedState" o = Gst.Element.ElementIsLockedStateMethodInfo+    ResolveTagDemuxMethod "iteratePads" o = Gst.Element.ElementIteratePadsMethodInfo+    ResolveTagDemuxMethod "iterateSinkPads" o = Gst.Element.ElementIterateSinkPadsMethodInfo+    ResolveTagDemuxMethod "iterateSrcPads" o = Gst.Element.ElementIterateSrcPadsMethodInfo+    ResolveTagDemuxMethod "link" o = Gst.Element.ElementLinkMethodInfo+    ResolveTagDemuxMethod "linkFiltered" o = Gst.Element.ElementLinkFilteredMethodInfo+    ResolveTagDemuxMethod "linkPads" o = Gst.Element.ElementLinkPadsMethodInfo+    ResolveTagDemuxMethod "linkPadsFiltered" o = Gst.Element.ElementLinkPadsFilteredMethodInfo+    ResolveTagDemuxMethod "linkPadsFull" o = Gst.Element.ElementLinkPadsFullMethodInfo+    ResolveTagDemuxMethod "lostState" o = Gst.Element.ElementLostStateMethodInfo+    ResolveTagDemuxMethod "messageFull" o = Gst.Element.ElementMessageFullMethodInfo+    ResolveTagDemuxMethod "messageFullWithDetails" o = Gst.Element.ElementMessageFullWithDetailsMethodInfo+    ResolveTagDemuxMethod "noMorePads" o = Gst.Element.ElementNoMorePadsMethodInfo+    ResolveTagDemuxMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo+    ResolveTagDemuxMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo+    ResolveTagDemuxMethod "postMessage" o = Gst.Element.ElementPostMessageMethodInfo+    ResolveTagDemuxMethod "provideClock" o = Gst.Element.ElementProvideClockMethodInfo+    ResolveTagDemuxMethod "query" o = Gst.Element.ElementQueryMethodInfo+    ResolveTagDemuxMethod "queryConvert" o = Gst.Element.ElementQueryConvertMethodInfo+    ResolveTagDemuxMethod "queryDuration" o = Gst.Element.ElementQueryDurationMethodInfo+    ResolveTagDemuxMethod "queryPosition" o = Gst.Element.ElementQueryPositionMethodInfo+    ResolveTagDemuxMethod "ref" o = Gst.Object.ObjectRefMethodInfo+    ResolveTagDemuxMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo+    ResolveTagDemuxMethod "releaseRequestPad" o = Gst.Element.ElementReleaseRequestPadMethodInfo+    ResolveTagDemuxMethod "removeControlBinding" o = Gst.Object.ObjectRemoveControlBindingMethodInfo+    ResolveTagDemuxMethod "removePad" o = Gst.Element.ElementRemovePadMethodInfo+    ResolveTagDemuxMethod "removePropertyNotifyWatch" o = Gst.Element.ElementRemovePropertyNotifyWatchMethodInfo+    ResolveTagDemuxMethod "requestPad" o = Gst.Element.ElementRequestPadMethodInfo+    ResolveTagDemuxMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo+    ResolveTagDemuxMethod "seek" o = Gst.Element.ElementSeekMethodInfo+    ResolveTagDemuxMethod "seekSimple" o = Gst.Element.ElementSeekSimpleMethodInfo+    ResolveTagDemuxMethod "sendEvent" o = Gst.Element.ElementSendEventMethodInfo+    ResolveTagDemuxMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo+    ResolveTagDemuxMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo+    ResolveTagDemuxMethod "suggestNextSync" o = Gst.Object.ObjectSuggestNextSyncMethodInfo+    ResolveTagDemuxMethod "syncStateWithParent" o = Gst.Element.ElementSyncStateWithParentMethodInfo+    ResolveTagDemuxMethod "syncValues" o = Gst.Object.ObjectSyncValuesMethodInfo+    ResolveTagDemuxMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo+    ResolveTagDemuxMethod "unlink" o = Gst.Element.ElementUnlinkMethodInfo+    ResolveTagDemuxMethod "unlinkPads" o = Gst.Element.ElementUnlinkPadsMethodInfo+    ResolveTagDemuxMethod "unparent" o = Gst.Object.ObjectUnparentMethodInfo+    ResolveTagDemuxMethod "unref" o = Gst.Object.ObjectUnrefMethodInfo+    ResolveTagDemuxMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo+    ResolveTagDemuxMethod "getBaseTime" o = Gst.Element.ElementGetBaseTimeMethodInfo+    ResolveTagDemuxMethod "getBus" o = Gst.Element.ElementGetBusMethodInfo+    ResolveTagDemuxMethod "getClock" o = Gst.Element.ElementGetClockMethodInfo+    ResolveTagDemuxMethod "getCompatiblePad" o = Gst.Element.ElementGetCompatiblePadMethodInfo+    ResolveTagDemuxMethod "getCompatiblePadTemplate" o = Gst.Element.ElementGetCompatiblePadTemplateMethodInfo+    ResolveTagDemuxMethod "getContext" o = Gst.Element.ElementGetContextMethodInfo+    ResolveTagDemuxMethod "getContextUnlocked" o = Gst.Element.ElementGetContextUnlockedMethodInfo+    ResolveTagDemuxMethod "getContexts" o = Gst.Element.ElementGetContextsMethodInfo+    ResolveTagDemuxMethod "getControlBinding" o = Gst.Object.ObjectGetControlBindingMethodInfo+    ResolveTagDemuxMethod "getControlRate" o = Gst.Object.ObjectGetControlRateMethodInfo+    ResolveTagDemuxMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo+    ResolveTagDemuxMethod "getFactory" o = Gst.Element.ElementGetFactoryMethodInfo+    ResolveTagDemuxMethod "getGValueArray" o = Gst.Object.ObjectGetGValueArrayMethodInfo+    ResolveTagDemuxMethod "getMetadata" o = Gst.Element.ElementGetMetadataMethodInfo+    ResolveTagDemuxMethod "getName" o = Gst.Object.ObjectGetNameMethodInfo+    ResolveTagDemuxMethod "getPadTemplate" o = Gst.Element.ElementGetPadTemplateMethodInfo+    ResolveTagDemuxMethod "getPadTemplateList" o = Gst.Element.ElementGetPadTemplateListMethodInfo+    ResolveTagDemuxMethod "getParent" o = Gst.Object.ObjectGetParentMethodInfo+    ResolveTagDemuxMethod "getPathString" o = Gst.Object.ObjectGetPathStringMethodInfo+    ResolveTagDemuxMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo+    ResolveTagDemuxMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo+    ResolveTagDemuxMethod "getRequestPad" o = Gst.Element.ElementGetRequestPadMethodInfo+    ResolveTagDemuxMethod "getStartTime" o = Gst.Element.ElementGetStartTimeMethodInfo+    ResolveTagDemuxMethod "getState" o = Gst.Element.ElementGetStateMethodInfo+    ResolveTagDemuxMethod "getStaticPad" o = Gst.Element.ElementGetStaticPadMethodInfo+    ResolveTagDemuxMethod "getValue" o = Gst.Object.ObjectGetValueMethodInfo+    ResolveTagDemuxMethod "setBaseTime" o = Gst.Element.ElementSetBaseTimeMethodInfo+    ResolveTagDemuxMethod "setBus" o = Gst.Element.ElementSetBusMethodInfo+    ResolveTagDemuxMethod "setClock" o = Gst.Element.ElementSetClockMethodInfo+    ResolveTagDemuxMethod "setContext" o = Gst.Element.ElementSetContextMethodInfo+    ResolveTagDemuxMethod "setControlBindingDisabled" o = Gst.Object.ObjectSetControlBindingDisabledMethodInfo+    ResolveTagDemuxMethod "setControlBindingsDisabled" o = Gst.Object.ObjectSetControlBindingsDisabledMethodInfo+    ResolveTagDemuxMethod "setControlRate" o = Gst.Object.ObjectSetControlRateMethodInfo+    ResolveTagDemuxMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo+    ResolveTagDemuxMethod "setLockedState" o = Gst.Element.ElementSetLockedStateMethodInfo+    ResolveTagDemuxMethod "setName" o = Gst.Object.ObjectSetNameMethodInfo+    ResolveTagDemuxMethod "setParent" o = Gst.Object.ObjectSetParentMethodInfo+    ResolveTagDemuxMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo+    ResolveTagDemuxMethod "setStartTime" o = Gst.Element.ElementSetStartTimeMethodInfo+    ResolveTagDemuxMethod "setState" o = Gst.Element.ElementSetStateMethodInfo+    ResolveTagDemuxMethod l o = O.MethodResolutionFailed l o++instance (info ~ ResolveTagDemuxMethod t TagDemux, O.MethodInfo info TagDemux p) => OL.IsLabel t (TagDemux -> p) where+#if MIN_VERSION_base(4,10,0)+    fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)+#else+    fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)+#endif++#endif++#if ENABLE_OVERLOADING+instance O.HasAttributeList TagDemux+type instance O.AttributeList TagDemux = TagDemuxAttributeList+type TagDemuxAttributeList = ('[ '("name", Gst.Object.ObjectNamePropertyInfo), '("parent", Gst.Object.ObjectParentPropertyInfo)] :: [(Symbol, *)])+#endif++#if ENABLE_OVERLOADING+#endif++#if ENABLE_OVERLOADING+type instance O.SignalList TagDemux = TagDemuxSignalList+type TagDemuxSignalList = ('[ '("deepNotify", Gst.Object.ObjectDeepNotifySignalInfo), '("noMorePads", Gst.Element.ElementNoMorePadsSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo), '("padAdded", Gst.Element.ElementPadAddedSignalInfo), '("padRemoved", Gst.Element.ElementPadRemovedSignalInfo)] :: [(Symbol, *)])++#endif++

@@ -0,0 +1,29 @@+#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \+       && !defined(__HADDOCK_VERSION__))+module GI.GstTag.Objects.TagDemux 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.ManagedPtr as B.ManagedPtr+import qualified Data.GI.Base.GClosure as B.GClosure+import qualified Data.GI.Base.GError as B.GError+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.Text as T+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++newtype TagDemux = TagDemux (ManagedPtr TagDemux)+instance GObject TagDemux where+class (GObject o, O.IsDescendantOf TagDemux o) => IsTagDemux o+instance (GObject o, O.IsDescendantOf TagDemux o) => IsTagDemux o+instance O.HasParentTypes TagDemux

@@ -0,0 +1,228 @@+++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc)++Provides a base class for adding tags at the beginning or end of a+stream.++== Deriving from GstTagMux++Subclasses have to do the following things:++ * In their base init function, they must add pad templates for the sink+   pad and the source pad to the element class, describing the media type+   they accept and output in the caps of the pad template.+ * In their class init function, they must override the+   GST_TAG_MUX_CLASS(mux_klass)->render_start_tag and\/or+   GST_TAG_MUX_CLASS(mux_klass)->render_end_tag vfuncs and set up a render+   function.+-}++#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \+       && !defined(__HADDOCK_VERSION__))++module GI.GstTag.Objects.TagMux+    ( ++-- * Exported types+    TagMux(..)                              ,+    IsTagMux                                ,+    toTagMux                                ,+    noTagMux                                ,+++    ) 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.ManagedPtr as B.ManagedPtr+import qualified Data.GI.Base.GClosure as B.GClosure+import qualified Data.GI.Base.GError as B.GError+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.Text as T+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 GI.GObject.Objects.Object as GObject.Object+import qualified GI.Gst.Interfaces.TagSetter as Gst.TagSetter+import qualified GI.Gst.Objects.Element as Gst.Element+import qualified GI.Gst.Objects.Object as Gst.Object++-- | Memory-managed wrapper type.+newtype TagMux = TagMux (ManagedPtr TagMux)+foreign import ccall "gst_tag_mux_get_type"+    c_gst_tag_mux_get_type :: IO GType++instance GObject TagMux where+    gobjectType = c_gst_tag_mux_get_type+    ++-- | Type class for types which can be safely cast to `TagMux`, for instance with `toTagMux`.+class (GObject o, O.IsDescendantOf TagMux o) => IsTagMux o+instance (GObject o, O.IsDescendantOf TagMux o) => IsTagMux o++instance O.HasParentTypes TagMux+type instance O.ParentTypes TagMux = '[Gst.Element.Element, Gst.Object.Object, GObject.Object.Object, Gst.TagSetter.TagSetter]++-- | Cast to `TagMux`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`.+toTagMux :: (MonadIO m, IsTagMux o) => o -> m TagMux+toTagMux = liftIO . unsafeCastTo TagMux++-- | A convenience alias for `Nothing` :: `Maybe` `TagMux`.+noTagMux :: Maybe TagMux+noTagMux = Nothing++#if ENABLE_OVERLOADING+type family ResolveTagMuxMethod (t :: Symbol) (o :: *) :: * where+    ResolveTagMuxMethod "abortState" o = Gst.Element.ElementAbortStateMethodInfo+    ResolveTagMuxMethod "addControlBinding" o = Gst.Object.ObjectAddControlBindingMethodInfo+    ResolveTagMuxMethod "addPad" o = Gst.Element.ElementAddPadMethodInfo+    ResolveTagMuxMethod "addPropertyDeepNotifyWatch" o = Gst.Element.ElementAddPropertyDeepNotifyWatchMethodInfo+    ResolveTagMuxMethod "addPropertyNotifyWatch" o = Gst.Element.ElementAddPropertyNotifyWatchMethodInfo+    ResolveTagMuxMethod "addTagValue" o = Gst.TagSetter.TagSetterAddTagValueMethodInfo+    ResolveTagMuxMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo+    ResolveTagMuxMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo+    ResolveTagMuxMethod "callAsync" o = Gst.Element.ElementCallAsyncMethodInfo+    ResolveTagMuxMethod "changeState" o = Gst.Element.ElementChangeStateMethodInfo+    ResolveTagMuxMethod "continueState" o = Gst.Element.ElementContinueStateMethodInfo+    ResolveTagMuxMethod "createAllPads" o = Gst.Element.ElementCreateAllPadsMethodInfo+    ResolveTagMuxMethod "defaultError" o = Gst.Object.ObjectDefaultErrorMethodInfo+    ResolveTagMuxMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo+    ResolveTagMuxMethod "foreachPad" o = Gst.Element.ElementForeachPadMethodInfo+    ResolveTagMuxMethod "foreachSinkPad" o = Gst.Element.ElementForeachSinkPadMethodInfo+    ResolveTagMuxMethod "foreachSrcPad" o = Gst.Element.ElementForeachSrcPadMethodInfo+    ResolveTagMuxMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo+    ResolveTagMuxMethod "getv" o = GObject.Object.ObjectGetvMethodInfo+    ResolveTagMuxMethod "hasActiveControlBindings" o = Gst.Object.ObjectHasActiveControlBindingsMethodInfo+    ResolveTagMuxMethod "hasAncestor" o = Gst.Object.ObjectHasAncestorMethodInfo+    ResolveTagMuxMethod "hasAsAncestor" o = Gst.Object.ObjectHasAsAncestorMethodInfo+    ResolveTagMuxMethod "hasAsParent" o = Gst.Object.ObjectHasAsParentMethodInfo+    ResolveTagMuxMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo+    ResolveTagMuxMethod "isLockedState" o = Gst.Element.ElementIsLockedStateMethodInfo+    ResolveTagMuxMethod "iteratePads" o = Gst.Element.ElementIteratePadsMethodInfo+    ResolveTagMuxMethod "iterateSinkPads" o = Gst.Element.ElementIterateSinkPadsMethodInfo+    ResolveTagMuxMethod "iterateSrcPads" o = Gst.Element.ElementIterateSrcPadsMethodInfo+    ResolveTagMuxMethod "link" o = Gst.Element.ElementLinkMethodInfo+    ResolveTagMuxMethod "linkFiltered" o = Gst.Element.ElementLinkFilteredMethodInfo+    ResolveTagMuxMethod "linkPads" o = Gst.Element.ElementLinkPadsMethodInfo+    ResolveTagMuxMethod "linkPadsFiltered" o = Gst.Element.ElementLinkPadsFilteredMethodInfo+    ResolveTagMuxMethod "linkPadsFull" o = Gst.Element.ElementLinkPadsFullMethodInfo+    ResolveTagMuxMethod "lostState" o = Gst.Element.ElementLostStateMethodInfo+    ResolveTagMuxMethod "mergeTags" o = Gst.TagSetter.TagSetterMergeTagsMethodInfo+    ResolveTagMuxMethod "messageFull" o = Gst.Element.ElementMessageFullMethodInfo+    ResolveTagMuxMethod "messageFullWithDetails" o = Gst.Element.ElementMessageFullWithDetailsMethodInfo+    ResolveTagMuxMethod "noMorePads" o = Gst.Element.ElementNoMorePadsMethodInfo+    ResolveTagMuxMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo+    ResolveTagMuxMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo+    ResolveTagMuxMethod "postMessage" o = Gst.Element.ElementPostMessageMethodInfo+    ResolveTagMuxMethod "provideClock" o = Gst.Element.ElementProvideClockMethodInfo+    ResolveTagMuxMethod "query" o = Gst.Element.ElementQueryMethodInfo+    ResolveTagMuxMethod "queryConvert" o = Gst.Element.ElementQueryConvertMethodInfo+    ResolveTagMuxMethod "queryDuration" o = Gst.Element.ElementQueryDurationMethodInfo+    ResolveTagMuxMethod "queryPosition" o = Gst.Element.ElementQueryPositionMethodInfo+    ResolveTagMuxMethod "ref" o = Gst.Object.ObjectRefMethodInfo+    ResolveTagMuxMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo+    ResolveTagMuxMethod "releaseRequestPad" o = Gst.Element.ElementReleaseRequestPadMethodInfo+    ResolveTagMuxMethod "removeControlBinding" o = Gst.Object.ObjectRemoveControlBindingMethodInfo+    ResolveTagMuxMethod "removePad" o = Gst.Element.ElementRemovePadMethodInfo+    ResolveTagMuxMethod "removePropertyNotifyWatch" o = Gst.Element.ElementRemovePropertyNotifyWatchMethodInfo+    ResolveTagMuxMethod "requestPad" o = Gst.Element.ElementRequestPadMethodInfo+    ResolveTagMuxMethod "resetTags" o = Gst.TagSetter.TagSetterResetTagsMethodInfo+    ResolveTagMuxMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo+    ResolveTagMuxMethod "seek" o = Gst.Element.ElementSeekMethodInfo+    ResolveTagMuxMethod "seekSimple" o = Gst.Element.ElementSeekSimpleMethodInfo+    ResolveTagMuxMethod "sendEvent" o = Gst.Element.ElementSendEventMethodInfo+    ResolveTagMuxMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo+    ResolveTagMuxMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo+    ResolveTagMuxMethod "suggestNextSync" o = Gst.Object.ObjectSuggestNextSyncMethodInfo+    ResolveTagMuxMethod "syncStateWithParent" o = Gst.Element.ElementSyncStateWithParentMethodInfo+    ResolveTagMuxMethod "syncValues" o = Gst.Object.ObjectSyncValuesMethodInfo+    ResolveTagMuxMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo+    ResolveTagMuxMethod "unlink" o = Gst.Element.ElementUnlinkMethodInfo+    ResolveTagMuxMethod "unlinkPads" o = Gst.Element.ElementUnlinkPadsMethodInfo+    ResolveTagMuxMethod "unparent" o = Gst.Object.ObjectUnparentMethodInfo+    ResolveTagMuxMethod "unref" o = Gst.Object.ObjectUnrefMethodInfo+    ResolveTagMuxMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo+    ResolveTagMuxMethod "getBaseTime" o = Gst.Element.ElementGetBaseTimeMethodInfo+    ResolveTagMuxMethod "getBus" o = Gst.Element.ElementGetBusMethodInfo+    ResolveTagMuxMethod "getClock" o = Gst.Element.ElementGetClockMethodInfo+    ResolveTagMuxMethod "getCompatiblePad" o = Gst.Element.ElementGetCompatiblePadMethodInfo+    ResolveTagMuxMethod "getCompatiblePadTemplate" o = Gst.Element.ElementGetCompatiblePadTemplateMethodInfo+    ResolveTagMuxMethod "getContext" o = Gst.Element.ElementGetContextMethodInfo+    ResolveTagMuxMethod "getContextUnlocked" o = Gst.Element.ElementGetContextUnlockedMethodInfo+    ResolveTagMuxMethod "getContexts" o = Gst.Element.ElementGetContextsMethodInfo+    ResolveTagMuxMethod "getControlBinding" o = Gst.Object.ObjectGetControlBindingMethodInfo+    ResolveTagMuxMethod "getControlRate" o = Gst.Object.ObjectGetControlRateMethodInfo+    ResolveTagMuxMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo+    ResolveTagMuxMethod "getFactory" o = Gst.Element.ElementGetFactoryMethodInfo+    ResolveTagMuxMethod "getGValueArray" o = Gst.Object.ObjectGetGValueArrayMethodInfo+    ResolveTagMuxMethod "getMetadata" o = Gst.Element.ElementGetMetadataMethodInfo+    ResolveTagMuxMethod "getName" o = Gst.Object.ObjectGetNameMethodInfo+    ResolveTagMuxMethod "getPadTemplate" o = Gst.Element.ElementGetPadTemplateMethodInfo+    ResolveTagMuxMethod "getPadTemplateList" o = Gst.Element.ElementGetPadTemplateListMethodInfo+    ResolveTagMuxMethod "getParent" o = Gst.Object.ObjectGetParentMethodInfo+    ResolveTagMuxMethod "getPathString" o = Gst.Object.ObjectGetPathStringMethodInfo+    ResolveTagMuxMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo+    ResolveTagMuxMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo+    ResolveTagMuxMethod "getRequestPad" o = Gst.Element.ElementGetRequestPadMethodInfo+    ResolveTagMuxMethod "getStartTime" o = Gst.Element.ElementGetStartTimeMethodInfo+    ResolveTagMuxMethod "getState" o = Gst.Element.ElementGetStateMethodInfo+    ResolveTagMuxMethod "getStaticPad" o = Gst.Element.ElementGetStaticPadMethodInfo+    ResolveTagMuxMethod "getTagList" o = Gst.TagSetter.TagSetterGetTagListMethodInfo+    ResolveTagMuxMethod "getTagMergeMode" o = Gst.TagSetter.TagSetterGetTagMergeModeMethodInfo+    ResolveTagMuxMethod "getValue" o = Gst.Object.ObjectGetValueMethodInfo+    ResolveTagMuxMethod "setBaseTime" o = Gst.Element.ElementSetBaseTimeMethodInfo+    ResolveTagMuxMethod "setBus" o = Gst.Element.ElementSetBusMethodInfo+    ResolveTagMuxMethod "setClock" o = Gst.Element.ElementSetClockMethodInfo+    ResolveTagMuxMethod "setContext" o = Gst.Element.ElementSetContextMethodInfo+    ResolveTagMuxMethod "setControlBindingDisabled" o = Gst.Object.ObjectSetControlBindingDisabledMethodInfo+    ResolveTagMuxMethod "setControlBindingsDisabled" o = Gst.Object.ObjectSetControlBindingsDisabledMethodInfo+    ResolveTagMuxMethod "setControlRate" o = Gst.Object.ObjectSetControlRateMethodInfo+    ResolveTagMuxMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo+    ResolveTagMuxMethod "setLockedState" o = Gst.Element.ElementSetLockedStateMethodInfo+    ResolveTagMuxMethod "setName" o = Gst.Object.ObjectSetNameMethodInfo+    ResolveTagMuxMethod "setParent" o = Gst.Object.ObjectSetParentMethodInfo+    ResolveTagMuxMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo+    ResolveTagMuxMethod "setStartTime" o = Gst.Element.ElementSetStartTimeMethodInfo+    ResolveTagMuxMethod "setState" o = Gst.Element.ElementSetStateMethodInfo+    ResolveTagMuxMethod "setTagMergeMode" o = Gst.TagSetter.TagSetterSetTagMergeModeMethodInfo+    ResolveTagMuxMethod l o = O.MethodResolutionFailed l o++instance (info ~ ResolveTagMuxMethod t TagMux, O.MethodInfo info TagMux p) => OL.IsLabel t (TagMux -> p) where+#if MIN_VERSION_base(4,10,0)+    fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)+#else+    fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)+#endif++#endif++#if ENABLE_OVERLOADING+instance O.HasAttributeList TagMux+type instance O.AttributeList TagMux = TagMuxAttributeList+type TagMuxAttributeList = ('[ '("name", Gst.Object.ObjectNamePropertyInfo), '("parent", Gst.Object.ObjectParentPropertyInfo)] :: [(Symbol, *)])+#endif++#if ENABLE_OVERLOADING+#endif++#if ENABLE_OVERLOADING+type instance O.SignalList TagMux = TagMuxSignalList+type TagMuxSignalList = ('[ '("deepNotify", Gst.Object.ObjectDeepNotifySignalInfo), '("noMorePads", Gst.Element.ElementNoMorePadsSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo), '("padAdded", Gst.Element.ElementPadAddedSignalInfo), '("padRemoved", Gst.Element.ElementPadRemovedSignalInfo)] :: [(Symbol, *)])++#endif++

@@ -0,0 +1,29 @@+#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \+       && !defined(__HADDOCK_VERSION__))+module GI.GstTag.Objects.TagMux 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.ManagedPtr as B.ManagedPtr+import qualified Data.GI.Base.GClosure as B.GClosure+import qualified Data.GI.Base.GError as B.GError+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.Text as T+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++newtype TagMux = TagMux (ManagedPtr TagMux)+instance GObject TagMux where+class (GObject o, O.IsDescendantOf TagMux o) => IsTagMux o+instance (GObject o, O.IsDescendantOf TagMux o) => IsTagMux o+instance O.HasParentTypes TagMux

@@ -1,3 +1,17 @@+The gi-gsttag library and included works are provided under the terms of the+GNU Library General Public License (LGPL) version 2.1 with the following+exception:++Static linking of applications or any other source to the gi-gsttag library+does not constitute a modified or derivative work and does not require+the author(s) to provide source code for said work, to link against the+shared gi-gsttag libraries, or to link their applications against a+user-supplied version of gi-gsttag. If you link applications to a modified+version of gi-gsttag, then the changes to gi-gsttag must be provided under the+terms of the LGPL.++----------------------------------------------------------------------------+                   GNU LESSER GENERAL PUBLIC LICENSE                        Version 2.1, February 1999 

@@ -1,6 +1,6 @@ # Documentation Autogenerated documentation for this package can be found at -[https://hackage.haskell.org/package/gi-gsttag-1.0.15/docs/GI-GstTag.html](https://hackage.haskell.org/package/gi-gsttag-1.0.15/docs/GI-GstTag.html)+[https://hackage.haskell.org/package/gi-gsttag-1.0.17/docs/GI-GstTag.html](https://hackage.haskell.org/package/gi-gsttag-1.0.17/docs/GI-GstTag.html)  For general documentation on using [haskell-gi](https://github.com/haskell-gi/haskell-gi) based bindings, see [the project page](https://github.com/haskell-gi/haskell-gi) or [the Wiki](https://github.com/haskell-gi/haskell-gi/wiki).

@@ -1,33 +1,33 @@ name:                 gi-gsttag-version:              1.0.15+version:              1.0.17 synopsis:             GStreamer Tag bindings description:          Bindings for the GStreamer Tag library, autogenerated by haskell-gi. homepage:             https://github.com/haskell-gi/haskell-gi license:              LGPL-2.1 license-file:         LICENSE author:               Will Thompson, Iñaki García Etxebarria and Jonas Platte-maintainer:           Iñaki García Etxebarria (garetxe@gmail.com)+maintainer:           Iñaki García Etxebarria (inaki@blueleaf.cc) category:             Bindings build-type:           Custom-cabal-version:        >= 1.24+cabal-version:        1.24  extra-source-files: README.md ChangeLog.md stack.yaml GstTag.overrides  custom-setup-      setup-depends: base >= 4.7 && < 5,+      setup-depends: base >= 4.9 && < 5,                      Cabal >= 1.24,-                     haskell-gi == 0.21.*+                     haskell-gi >= 0.21.0 && < 0.23  library       default-language: Haskell2010-      default-extensions: NoImplicitPrelude, ScopedTypeVariables, CPP, OverloadedStrings, NegativeLiterals, ConstraintKinds, TypeFamilies, MultiParamTypeClasses, KindSignatures, FlexibleInstances, UndecidableInstances, DataKinds, FlexibleContexts+      default-extensions: NoImplicitPrelude, ScopedTypeVariables, CPP, OverloadedStrings, NegativeLiterals, ConstraintKinds, TypeFamilies, MultiParamTypeClasses, KindSignatures, FlexibleInstances, UndecidableInstances, DataKinds, FlexibleContexts, UndecidableSuperClasses       other-extensions: PatternSynonyms, ViewPatterns       ghc-options: -fno-warn-unused-imports -fno-warn-warnings-deprecations        pkgconfig-depends: gstreamer-tag-1.0       build-depends: base >= 4.8 && <5,-                     haskell-gi-base == 0.21.*,-                     haskell-gi == 0.21.*,+                     haskell-gi-base >= 0.21.0 && < 0.23,+                     haskell-gi >= 0.21.0 && < 0.23,                      haskell-gi-overloading < 1.1,                      gi-gstbase == 1.0.*,                      gi-gst == 1.0.*,@@ -42,3 +42,14 @@       -- see https://ghc.haskell.org/trac/ghc/ticket/14382       if impl(ghc == 8.2.*)               build-depends: haskell-gi-overloading == 0.0++      exposed-modules: GI.GstTag,+                       GI.GstTag.Constants,+                       GI.GstTag.Enums,+                       GI.GstTag.Flags,+                       GI.GstTag.Functions,+                       GI.GstTag.Interfaces,+                       GI.GstTag.Interfaces.TagXmpWriter,+                       GI.GstTag.Objects,+                       GI.GstTag.Objects.TagDemux,+                       GI.GstTag.Objects.TagMux

@@ -1,3 +1,3 @@ packages: - '.'-resolver: lts-9.21+resolver: lts-13.7