diff --git a/ChangeLog.md b/ChangeLog.md --- a/ChangeLog.md +++ b/ChangeLog.md @@ -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). diff --git a/GI/GstTag.hs b/GI/GstTag.hs new file mode 100644 --- /dev/null +++ b/GI/GstTag.hs @@ -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 + diff --git a/GI/GstTag/Constants.hs b/GI/GstTag/Constants.hs new file mode 100644 --- /dev/null +++ b/GI/GstTag/Constants.hs @@ -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 + + diff --git a/GI/GstTag/Enums.hs b/GI/GstTag/Enums.hs new file mode 100644 --- /dev/null +++ b/GI/GstTag/Enums.hs @@ -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 + + diff --git a/GI/GstTag/Enums.hs-boot b/GI/GstTag/Enums.hs-boot new file mode 100644 --- /dev/null +++ b/GI/GstTag/Enums.hs-boot @@ -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 diff --git a/GI/GstTag/Flags.hs b/GI/GstTag/Flags.hs new file mode 100644 --- /dev/null +++ b/GI/GstTag/Flags.hs @@ -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 + + diff --git a/GI/GstTag/Flags.hs-boot b/GI/GstTag/Flags.hs-boot new file mode 100644 --- /dev/null +++ b/GI/GstTag/Flags.hs-boot @@ -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 diff --git a/GI/GstTag/Functions.hs b/GI/GstTag/Functions.hs new file mode 100644 --- /dev/null +++ b/GI/GstTag/Functions.hs @@ -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' + + + diff --git a/GI/GstTag/Interfaces.hs b/GI/GstTag/Interfaces.hs new file mode 100644 --- /dev/null +++ b/GI/GstTag/Interfaces.hs @@ -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 + + + diff --git a/GI/GstTag/Interfaces/TagXmpWriter.hs b/GI/GstTag/Interfaces/TagXmpWriter.hs new file mode 100644 --- /dev/null +++ b/GI/GstTag/Interfaces/TagXmpWriter.hs @@ -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 + + diff --git a/GI/GstTag/Interfaces/TagXmpWriter.hs-boot b/GI/GstTag/Interfaces/TagXmpWriter.hs-boot new file mode 100644 --- /dev/null +++ b/GI/GstTag/Interfaces/TagXmpWriter.hs-boot @@ -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 diff --git a/GI/GstTag/Objects.hs b/GI/GstTag/Objects.hs new file mode 100644 --- /dev/null +++ b/GI/GstTag/Objects.hs @@ -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 + + + diff --git a/GI/GstTag/Objects/TagDemux.hs b/GI/GstTag/Objects/TagDemux.hs new file mode 100644 --- /dev/null +++ b/GI/GstTag/Objects/TagDemux.hs @@ -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 + + diff --git a/GI/GstTag/Objects/TagDemux.hs-boot b/GI/GstTag/Objects/TagDemux.hs-boot new file mode 100644 --- /dev/null +++ b/GI/GstTag/Objects/TagDemux.hs-boot @@ -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 diff --git a/GI/GstTag/Objects/TagMux.hs b/GI/GstTag/Objects/TagMux.hs new file mode 100644 --- /dev/null +++ b/GI/GstTag/Objects/TagMux.hs @@ -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 + + diff --git a/GI/GstTag/Objects/TagMux.hs-boot b/GI/GstTag/Objects/TagMux.hs-boot new file mode 100644 --- /dev/null +++ b/GI/GstTag/Objects/TagMux.hs-boot @@ -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 diff --git a/LICENSE b/LICENSE --- a/LICENSE +++ b/LICENSE @@ -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 diff --git a/README.md b/README.md --- a/README.md +++ b/README.md @@ -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). diff --git a/gi-gsttag.cabal b/gi-gsttag.cabal --- a/gi-gsttag.cabal +++ b/gi-gsttag.cabal @@ -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 diff --git a/stack.yaml b/stack.yaml --- a/stack.yaml +++ b/stack.yaml @@ -1,3 +1,3 @@ packages: - '.' -resolver: lts-9.21 +resolver: lts-13.7