{- | Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte License : LGPL-2.1 Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) One registry holds the metadata of a set of plugins. \<emphasis role=\"bold\">Design:\<\/emphasis> The 'GI.Gst.Objects.Registry.Registry' object is a list of plugins and some functions for dealing with them. Each 'GI.Gst.Objects.Plugin.Plugin' is matched 1-1 with a file on disk, and may or may not be loaded at a given time. The primary source, at all times, of plugin information is each plugin file itself. Thus, if an application wants information about a particular plugin, or wants to search for a feature that satisfies given criteria, the primary means of doing so is to load every plugin and look at the resulting information that is gathered in the default registry. Clearly, this is a time consuming process, so we cache information in the registry file. The format and location of the cache file is internal to gstreamer. On startup, plugins are searched for in the plugin search path. The following locations are checked in this order: * location from --gst-plugin-path commandline option. * the GST_PLUGIN_PATH environment variable. * the GST_PLUGIN_SYSTEM_PATH environment variable. * default locations (if GST_PLUGIN_SYSTEM_PATH is not set). Those default locations are: @$XDG_DATA_HOME\/gstreamer-$GST_API_VERSION\/plugins\/@ and @$prefix\/libs\/gstreamer-$GST_API_VERSION\/@. <http://standards.freedesktop.org/basedir-spec/basedir-spec-latest.html $XDG_DATA_HOME> defaults to @$HOME\/.local\/share@. The registry cache file is loaded from @$XDG_CACHE_HOME\/gstreamer-$GST_API_VERSION\/registry-$ARCH.bin@ (where $XDG_CACHE_HOME defaults to @$HOME\/.cache@) or the file listed in the @GST_REGISTRY@ env var. One reason to change the registry location is for testing. For each plugin that is found in the plugin search path, there could be 3 possibilities for cached information: * the cache may not contain information about a given file. * the cache may have stale information. * the cache may have current information. In the first two cases, the plugin is loaded and the cache updated. In addition to these cases, the cache may have entries for plugins that are not relevant to the current process. These are marked as not available to the current process. If the cache is updated for whatever reason, it is marked dirty. A dirty cache is written out at the end of initialization. Each entry is checked to make sure the information is minimally valid. If not, the entry is simply dropped. == Implementation notes: The \"cache\" and \"registry\" are different concepts and can represent different sets of plugins. For various reasons, at init time, the cache is stored in the default registry, and plugins not relevant to the current process are marked with the 'GI.Gst.Flags.PluginFlagsCached' bit. These plugins are removed at the end of initialization. -} #define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ && !defined(__HADDOCK_VERSION__)) module GI.Gst.Objects.Registry ( -- * Exported types Registry(..) , IsRegistry , toRegistry , noRegistry , -- * Methods -- ** addFeature #method:addFeature# #if ENABLE_OVERLOADING RegistryAddFeatureMethodInfo , #endif registryAddFeature , -- ** addPlugin #method:addPlugin# #if ENABLE_OVERLOADING RegistryAddPluginMethodInfo , #endif registryAddPlugin , -- ** checkFeatureVersion #method:checkFeatureVersion# #if ENABLE_OVERLOADING RegistryCheckFeatureVersionMethodInfo , #endif registryCheckFeatureVersion , -- ** featureFilter #method:featureFilter# #if ENABLE_OVERLOADING RegistryFeatureFilterMethodInfo , #endif registryFeatureFilter , -- ** findFeature #method:findFeature# #if ENABLE_OVERLOADING RegistryFindFeatureMethodInfo , #endif registryFindFeature , -- ** findPlugin #method:findPlugin# #if ENABLE_OVERLOADING RegistryFindPluginMethodInfo , #endif registryFindPlugin , -- ** forkIsEnabled #method:forkIsEnabled# registryForkIsEnabled , -- ** forkSetEnabled #method:forkSetEnabled# registryForkSetEnabled , -- ** get #method:get# registryGet , -- ** getFeatureList #method:getFeatureList# #if ENABLE_OVERLOADING RegistryGetFeatureListMethodInfo , #endif registryGetFeatureList , -- ** getFeatureListByPlugin #method:getFeatureListByPlugin# #if ENABLE_OVERLOADING RegistryGetFeatureListByPluginMethodInfo, #endif registryGetFeatureListByPlugin , -- ** getFeatureListCookie #method:getFeatureListCookie# #if ENABLE_OVERLOADING RegistryGetFeatureListCookieMethodInfo , #endif registryGetFeatureListCookie , -- ** getPluginList #method:getPluginList# #if ENABLE_OVERLOADING RegistryGetPluginListMethodInfo , #endif registryGetPluginList , -- ** lookup #method:lookup# #if ENABLE_OVERLOADING RegistryLookupMethodInfo , #endif registryLookup , -- ** lookupFeature #method:lookupFeature# #if ENABLE_OVERLOADING RegistryLookupFeatureMethodInfo , #endif registryLookupFeature , -- ** pluginFilter #method:pluginFilter# #if ENABLE_OVERLOADING RegistryPluginFilterMethodInfo , #endif registryPluginFilter , -- ** removeFeature #method:removeFeature# #if ENABLE_OVERLOADING RegistryRemoveFeatureMethodInfo , #endif registryRemoveFeature , -- ** removePlugin #method:removePlugin# #if ENABLE_OVERLOADING RegistryRemovePluginMethodInfo , #endif registryRemovePlugin , -- ** scanPath #method:scanPath# #if ENABLE_OVERLOADING RegistryScanPathMethodInfo , #endif registryScanPath , -- * Signals -- ** featureAdded #signal:featureAdded# C_RegistryFeatureAddedCallback , RegistryFeatureAddedCallback , #if ENABLE_OVERLOADING RegistryFeatureAddedSignalInfo , #endif afterRegistryFeatureAdded , genClosure_RegistryFeatureAdded , mk_RegistryFeatureAddedCallback , noRegistryFeatureAddedCallback , onRegistryFeatureAdded , wrap_RegistryFeatureAddedCallback , -- ** pluginAdded #signal:pluginAdded# C_RegistryPluginAddedCallback , RegistryPluginAddedCallback , #if ENABLE_OVERLOADING RegistryPluginAddedSignalInfo , #endif afterRegistryPluginAdded , genClosure_RegistryPluginAdded , mk_RegistryPluginAddedCallback , noRegistryPluginAddedCallback , onRegistryPluginAdded , wrap_RegistryPluginAddedCallback , ) 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.Callbacks as Gst.Callbacks import {-# SOURCE #-} qualified GI.Gst.Objects.Object as Gst.Object import {-# SOURCE #-} qualified GI.Gst.Objects.Plugin as Gst.Plugin import {-# SOURCE #-} qualified GI.Gst.Objects.PluginFeature as Gst.PluginFeature -- | Memory-managed wrapper type. newtype Registry = Registry (ManagedPtr Registry) foreign import ccall "gst_registry_get_type" c_gst_registry_get_type :: IO GType instance GObject Registry where gobjectType = c_gst_registry_get_type -- | Type class for types which can be safely cast to `Registry`, for instance with `toRegistry`. class (GObject o, O.IsDescendantOf Registry o) => IsRegistry o instance (GObject o, O.IsDescendantOf Registry o) => IsRegistry o instance O.HasParentTypes Registry type instance O.ParentTypes Registry = '[Gst.Object.Object, GObject.Object.Object] -- | Cast to `Registry`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`. toRegistry :: (MonadIO m, IsRegistry o) => o -> m Registry toRegistry = liftIO . unsafeCastTo Registry -- | A convenience alias for `Nothing` :: `Maybe` `Registry`. noRegistry :: Maybe Registry noRegistry = Nothing #if ENABLE_OVERLOADING type family ResolveRegistryMethod (t :: Symbol) (o :: *) :: * where ResolveRegistryMethod "addControlBinding" o = Gst.Object.ObjectAddControlBindingMethodInfo ResolveRegistryMethod "addFeature" o = RegistryAddFeatureMethodInfo ResolveRegistryMethod "addPlugin" o = RegistryAddPluginMethodInfo ResolveRegistryMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo ResolveRegistryMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo ResolveRegistryMethod "checkFeatureVersion" o = RegistryCheckFeatureVersionMethodInfo ResolveRegistryMethod "defaultError" o = Gst.Object.ObjectDefaultErrorMethodInfo ResolveRegistryMethod "featureFilter" o = RegistryFeatureFilterMethodInfo ResolveRegistryMethod "findFeature" o = RegistryFindFeatureMethodInfo ResolveRegistryMethod "findPlugin" o = RegistryFindPluginMethodInfo ResolveRegistryMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo ResolveRegistryMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo ResolveRegistryMethod "getv" o = GObject.Object.ObjectGetvMethodInfo ResolveRegistryMethod "hasActiveControlBindings" o = Gst.Object.ObjectHasActiveControlBindingsMethodInfo ResolveRegistryMethod "hasAncestor" o = Gst.Object.ObjectHasAncestorMethodInfo ResolveRegistryMethod "hasAsAncestor" o = Gst.Object.ObjectHasAsAncestorMethodInfo ResolveRegistryMethod "hasAsParent" o = Gst.Object.ObjectHasAsParentMethodInfo ResolveRegistryMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo ResolveRegistryMethod "lookup" o = RegistryLookupMethodInfo ResolveRegistryMethod "lookupFeature" o = RegistryLookupFeatureMethodInfo ResolveRegistryMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo ResolveRegistryMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo ResolveRegistryMethod "pluginFilter" o = RegistryPluginFilterMethodInfo ResolveRegistryMethod "ref" o = Gst.Object.ObjectRefMethodInfo ResolveRegistryMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo ResolveRegistryMethod "removeControlBinding" o = Gst.Object.ObjectRemoveControlBindingMethodInfo ResolveRegistryMethod "removeFeature" o = RegistryRemoveFeatureMethodInfo ResolveRegistryMethod "removePlugin" o = RegistryRemovePluginMethodInfo ResolveRegistryMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo ResolveRegistryMethod "scanPath" o = RegistryScanPathMethodInfo ResolveRegistryMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo ResolveRegistryMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo ResolveRegistryMethod "suggestNextSync" o = Gst.Object.ObjectSuggestNextSyncMethodInfo ResolveRegistryMethod "syncValues" o = Gst.Object.ObjectSyncValuesMethodInfo ResolveRegistryMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo ResolveRegistryMethod "unparent" o = Gst.Object.ObjectUnparentMethodInfo ResolveRegistryMethod "unref" o = Gst.Object.ObjectUnrefMethodInfo ResolveRegistryMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo ResolveRegistryMethod "getControlBinding" o = Gst.Object.ObjectGetControlBindingMethodInfo ResolveRegistryMethod "getControlRate" o = Gst.Object.ObjectGetControlRateMethodInfo ResolveRegistryMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo ResolveRegistryMethod "getFeatureList" o = RegistryGetFeatureListMethodInfo ResolveRegistryMethod "getFeatureListByPlugin" o = RegistryGetFeatureListByPluginMethodInfo ResolveRegistryMethod "getFeatureListCookie" o = RegistryGetFeatureListCookieMethodInfo ResolveRegistryMethod "getGValueArray" o = Gst.Object.ObjectGetGValueArrayMethodInfo ResolveRegistryMethod "getName" o = Gst.Object.ObjectGetNameMethodInfo ResolveRegistryMethod "getParent" o = Gst.Object.ObjectGetParentMethodInfo ResolveRegistryMethod "getPathString" o = Gst.Object.ObjectGetPathStringMethodInfo ResolveRegistryMethod "getPluginList" o = RegistryGetPluginListMethodInfo ResolveRegistryMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo ResolveRegistryMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo ResolveRegistryMethod "getValue" o = Gst.Object.ObjectGetValueMethodInfo ResolveRegistryMethod "setControlBindingDisabled" o = Gst.Object.ObjectSetControlBindingDisabledMethodInfo ResolveRegistryMethod "setControlBindingsDisabled" o = Gst.Object.ObjectSetControlBindingsDisabledMethodInfo ResolveRegistryMethod "setControlRate" o = Gst.Object.ObjectSetControlRateMethodInfo ResolveRegistryMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo ResolveRegistryMethod "setName" o = Gst.Object.ObjectSetNameMethodInfo ResolveRegistryMethod "setParent" o = Gst.Object.ObjectSetParentMethodInfo ResolveRegistryMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo ResolveRegistryMethod l o = O.MethodResolutionFailed l o instance (info ~ ResolveRegistryMethod t Registry, O.MethodInfo info Registry p) => OL.IsLabel t (Registry -> 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 -- signal Registry::feature-added {- | Signals that a feature has been added to the registry (possibly replacing a previously-added one by the same name) -} type RegistryFeatureAddedCallback = Gst.PluginFeature.PluginFeature {- ^ /@feature@/: the feature that has been added -} -> IO () -- | A convenience synonym for @`Nothing` :: `Maybe` `RegistryFeatureAddedCallback`@. noRegistryFeatureAddedCallback :: Maybe RegistryFeatureAddedCallback noRegistryFeatureAddedCallback = Nothing -- | Type for the callback on the (unwrapped) C side. type C_RegistryFeatureAddedCallback = Ptr () -> -- object Ptr Gst.PluginFeature.PluginFeature -> Ptr () -> -- user_data IO () -- | Generate a function pointer callable from C code, from a `C_RegistryFeatureAddedCallback`. foreign import ccall "wrapper" mk_RegistryFeatureAddedCallback :: C_RegistryFeatureAddedCallback -> IO (FunPtr C_RegistryFeatureAddedCallback) -- | Wrap the callback into a `GClosure`. genClosure_RegistryFeatureAdded :: MonadIO m => RegistryFeatureAddedCallback -> m (GClosure C_RegistryFeatureAddedCallback) genClosure_RegistryFeatureAdded cb = liftIO $ do let cb' = wrap_RegistryFeatureAddedCallback cb mk_RegistryFeatureAddedCallback cb' >>= B.GClosure.newGClosure -- | Wrap a `RegistryFeatureAddedCallback` into a `C_RegistryFeatureAddedCallback`. wrap_RegistryFeatureAddedCallback :: RegistryFeatureAddedCallback -> C_RegistryFeatureAddedCallback wrap_RegistryFeatureAddedCallback _cb _ feature _ = do feature' <- (newObject Gst.PluginFeature.PluginFeature) feature _cb feature' {- | Connect a signal handler for the “@feature-added@” signal, to be run before the default handler. When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to @ 'Data.GI.Base.Signals.on' registry #featureAdded callback @ -} onRegistryFeatureAdded :: (IsRegistry a, MonadIO m) => a -> RegistryFeatureAddedCallback -> m SignalHandlerId onRegistryFeatureAdded obj cb = liftIO $ do let cb' = wrap_RegistryFeatureAddedCallback cb cb'' <- mk_RegistryFeatureAddedCallback cb' connectSignalFunPtr obj "feature-added" cb'' SignalConnectBefore {- | Connect a signal handler for the “@feature-added@” signal, to be run after the default handler. When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to @ 'Data.GI.Base.Signals.after' registry #featureAdded callback @ -} afterRegistryFeatureAdded :: (IsRegistry a, MonadIO m) => a -> RegistryFeatureAddedCallback -> m SignalHandlerId afterRegistryFeatureAdded obj cb = liftIO $ do let cb' = wrap_RegistryFeatureAddedCallback cb cb'' <- mk_RegistryFeatureAddedCallback cb' connectSignalFunPtr obj "feature-added" cb'' SignalConnectAfter -- signal Registry::plugin-added {- | Signals that a plugin has been added to the registry (possibly replacing a previously-added one by the same name) -} type RegistryPluginAddedCallback = Gst.Plugin.Plugin {- ^ /@plugin@/: the plugin that has been added -} -> IO () -- | A convenience synonym for @`Nothing` :: `Maybe` `RegistryPluginAddedCallback`@. noRegistryPluginAddedCallback :: Maybe RegistryPluginAddedCallback noRegistryPluginAddedCallback = Nothing -- | Type for the callback on the (unwrapped) C side. type C_RegistryPluginAddedCallback = Ptr () -> -- object Ptr Gst.Plugin.Plugin -> Ptr () -> -- user_data IO () -- | Generate a function pointer callable from C code, from a `C_RegistryPluginAddedCallback`. foreign import ccall "wrapper" mk_RegistryPluginAddedCallback :: C_RegistryPluginAddedCallback -> IO (FunPtr C_RegistryPluginAddedCallback) -- | Wrap the callback into a `GClosure`. genClosure_RegistryPluginAdded :: MonadIO m => RegistryPluginAddedCallback -> m (GClosure C_RegistryPluginAddedCallback) genClosure_RegistryPluginAdded cb = liftIO $ do let cb' = wrap_RegistryPluginAddedCallback cb mk_RegistryPluginAddedCallback cb' >>= B.GClosure.newGClosure -- | Wrap a `RegistryPluginAddedCallback` into a `C_RegistryPluginAddedCallback`. wrap_RegistryPluginAddedCallback :: RegistryPluginAddedCallback -> C_RegistryPluginAddedCallback wrap_RegistryPluginAddedCallback _cb _ plugin _ = do plugin' <- (newObject Gst.Plugin.Plugin) plugin _cb plugin' {- | Connect a signal handler for the “@plugin-added@” signal, to be run before the default handler. When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to @ 'Data.GI.Base.Signals.on' registry #pluginAdded callback @ -} onRegistryPluginAdded :: (IsRegistry a, MonadIO m) => a -> RegistryPluginAddedCallback -> m SignalHandlerId onRegistryPluginAdded obj cb = liftIO $ do let cb' = wrap_RegistryPluginAddedCallback cb cb'' <- mk_RegistryPluginAddedCallback cb' connectSignalFunPtr obj "plugin-added" cb'' SignalConnectBefore {- | Connect a signal handler for the “@plugin-added@” signal, to be run after the default handler. When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to @ 'Data.GI.Base.Signals.after' registry #pluginAdded callback @ -} afterRegistryPluginAdded :: (IsRegistry a, MonadIO m) => a -> RegistryPluginAddedCallback -> m SignalHandlerId afterRegistryPluginAdded obj cb = liftIO $ do let cb' = wrap_RegistryPluginAddedCallback cb cb'' <- mk_RegistryPluginAddedCallback cb' connectSignalFunPtr obj "plugin-added" cb'' SignalConnectAfter #if ENABLE_OVERLOADING instance O.HasAttributeList Registry type instance O.AttributeList Registry = RegistryAttributeList type RegistryAttributeList = ('[ '("name", Gst.Object.ObjectNamePropertyInfo), '("parent", Gst.Object.ObjectParentPropertyInfo)] :: [(Symbol, *)]) #endif #if ENABLE_OVERLOADING #endif #if ENABLE_OVERLOADING data RegistryFeatureAddedSignalInfo instance SignalInfo RegistryFeatureAddedSignalInfo where type HaskellCallbackType RegistryFeatureAddedSignalInfo = RegistryFeatureAddedCallback connectSignal _ obj cb connectMode = do let cb' = wrap_RegistryFeatureAddedCallback cb cb'' <- mk_RegistryFeatureAddedCallback cb' connectSignalFunPtr obj "feature-added" cb'' connectMode data RegistryPluginAddedSignalInfo instance SignalInfo RegistryPluginAddedSignalInfo where type HaskellCallbackType RegistryPluginAddedSignalInfo = RegistryPluginAddedCallback connectSignal _ obj cb connectMode = do let cb' = wrap_RegistryPluginAddedCallback cb cb'' <- mk_RegistryPluginAddedCallback cb' connectSignalFunPtr obj "plugin-added" cb'' connectMode type instance O.SignalList Registry = RegistrySignalList type RegistrySignalList = ('[ '("deepNotify", Gst.Object.ObjectDeepNotifySignalInfo), '("featureAdded", RegistryFeatureAddedSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo), '("pluginAdded", RegistryPluginAddedSignalInfo)] :: [(Symbol, *)]) #endif -- method Registry::add_feature -- method type : OrdinaryMethod -- Args : [Arg {argCName = "registry", argType = TInterface (Name {namespace = "Gst", name = "Registry"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the registry to add the plugin to", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "feature", argType = TInterface (Name {namespace = "Gst", name = "PluginFeature"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the feature to add", 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_registry_add_feature" gst_registry_add_feature :: Ptr Registry -> -- registry : TInterface (Name {namespace = "Gst", name = "Registry"}) Ptr Gst.PluginFeature.PluginFeature -> -- feature : TInterface (Name {namespace = "Gst", name = "PluginFeature"}) IO CInt {- | Add the feature to the registry. The feature-added signal will be emitted. /@feature@/\'s reference count will be incremented, and any floating reference will be removed (see @/gst_object_ref_sink()/@) -} registryAddFeature :: (B.CallStack.HasCallStack, MonadIO m, IsRegistry a, Gst.PluginFeature.IsPluginFeature b) => a {- ^ /@registry@/: the registry to add the plugin to -} -> b {- ^ /@feature@/: the feature to add -} -> m Bool {- ^ __Returns:__ 'True' on success. MT safe. -} registryAddFeature registry feature = liftIO $ do registry' <- unsafeManagedPtrCastPtr registry feature' <- unsafeManagedPtrCastPtr feature result <- gst_registry_add_feature registry' feature' let result' = (/= 0) result touchManagedPtr registry touchManagedPtr feature return result' #if ENABLE_OVERLOADING data RegistryAddFeatureMethodInfo instance (signature ~ (b -> m Bool), MonadIO m, IsRegistry a, Gst.PluginFeature.IsPluginFeature b) => O.MethodInfo RegistryAddFeatureMethodInfo a signature where overloadedMethod _ = registryAddFeature #endif -- method Registry::add_plugin -- method type : OrdinaryMethod -- Args : [Arg {argCName = "registry", argType = TInterface (Name {namespace = "Gst", name = "Registry"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the registry to add the plugin to", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "plugin", argType = TInterface (Name {namespace = "Gst", name = "Plugin"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the plugin to add", 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_registry_add_plugin" gst_registry_add_plugin :: Ptr Registry -> -- registry : TInterface (Name {namespace = "Gst", name = "Registry"}) Ptr Gst.Plugin.Plugin -> -- plugin : TInterface (Name {namespace = "Gst", name = "Plugin"}) IO CInt {- | Add the plugin to the registry. The plugin-added signal will be emitted. /@plugin@/\'s reference count will be incremented, and any floating reference will be removed (see @/gst_object_ref_sink()/@) -} registryAddPlugin :: (B.CallStack.HasCallStack, MonadIO m, IsRegistry a, Gst.Plugin.IsPlugin b) => a {- ^ /@registry@/: the registry to add the plugin to -} -> b {- ^ /@plugin@/: the plugin to add -} -> m Bool {- ^ __Returns:__ 'True' on success. MT safe. -} registryAddPlugin registry plugin = liftIO $ do registry' <- unsafeManagedPtrCastPtr registry plugin' <- unsafeManagedPtrCastPtr plugin result <- gst_registry_add_plugin registry' plugin' let result' = (/= 0) result touchManagedPtr registry touchManagedPtr plugin return result' #if ENABLE_OVERLOADING data RegistryAddPluginMethodInfo instance (signature ~ (b -> m Bool), MonadIO m, IsRegistry a, Gst.Plugin.IsPlugin b) => O.MethodInfo RegistryAddPluginMethodInfo a signature where overloadedMethod _ = registryAddPlugin #endif -- method Registry::check_feature_version -- method type : OrdinaryMethod -- Args : [Arg {argCName = "registry", argType = TInterface (Name {namespace = "Gst", name = "Registry"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstRegistry", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "feature_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the name of the feature (e.g. \"oggdemux\")", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "min_major", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the minimum major version number", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "min_minor", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the minimum minor version number", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "min_micro", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the minimum micro version number", 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_registry_check_feature_version" gst_registry_check_feature_version :: Ptr Registry -> -- registry : TInterface (Name {namespace = "Gst", name = "Registry"}) CString -> -- feature_name : TBasicType TUTF8 Word32 -> -- min_major : TBasicType TUInt Word32 -> -- min_minor : TBasicType TUInt Word32 -> -- min_micro : TBasicType TUInt IO CInt {- | Checks whether a plugin feature by the given name exists in /@registry@/ and whether its version is at least the version required. -} registryCheckFeatureVersion :: (B.CallStack.HasCallStack, MonadIO m, IsRegistry a) => a {- ^ /@registry@/: a 'GI.Gst.Objects.Registry.Registry' -} -> T.Text {- ^ /@featureName@/: the name of the feature (e.g. \"oggdemux\") -} -> Word32 {- ^ /@minMajor@/: the minimum major version number -} -> Word32 {- ^ /@minMinor@/: the minimum minor version number -} -> Word32 {- ^ /@minMicro@/: the minimum micro version number -} -> m Bool {- ^ __Returns:__ 'True' if the feature could be found and the version is the same as the required version or newer, and 'False' otherwise. -} registryCheckFeatureVersion registry featureName minMajor minMinor minMicro = liftIO $ do registry' <- unsafeManagedPtrCastPtr registry featureName' <- textToCString featureName result <- gst_registry_check_feature_version registry' featureName' minMajor minMinor minMicro let result' = (/= 0) result touchManagedPtr registry freeMem featureName' return result' #if ENABLE_OVERLOADING data RegistryCheckFeatureVersionMethodInfo instance (signature ~ (T.Text -> Word32 -> Word32 -> Word32 -> m Bool), MonadIO m, IsRegistry a) => O.MethodInfo RegistryCheckFeatureVersionMethodInfo a signature where overloadedMethod _ = registryCheckFeatureVersion #endif -- method Registry::feature_filter -- method type : OrdinaryMethod -- Args : [Arg {argCName = "registry", argType = TInterface (Name {namespace = "Gst", name = "Registry"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "registry to query", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "filter", argType = TInterface (Name {namespace = "Gst", name = "PluginFeatureFilter"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the filter to use", sinceVersion = Nothing}, argScope = ScopeTypeCall, argClosure = 3, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "first", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "only return first match", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "user data passed to the filter function", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TGList (TInterface (Name {namespace = "Gst", name = "PluginFeature"}))) -- throws : False -- Skip return : False foreign import ccall "gst_registry_feature_filter" gst_registry_feature_filter :: Ptr Registry -> -- registry : TInterface (Name {namespace = "Gst", name = "Registry"}) FunPtr Gst.Callbacks.C_PluginFeatureFilter -> -- filter : TInterface (Name {namespace = "Gst", name = "PluginFeatureFilter"}) CInt -> -- first : TBasicType TBoolean Ptr () -> -- user_data : TBasicType TPtr IO (Ptr (GList (Ptr Gst.PluginFeature.PluginFeature))) {- | Runs a filter against all features of the plugins in the registry and returns a GList with the results. If the first flag is set, only the first match is returned (as a list with a single object). -} registryFeatureFilter :: (B.CallStack.HasCallStack, MonadIO m, IsRegistry a) => a {- ^ /@registry@/: registry to query -} -> Gst.Callbacks.PluginFeatureFilter {- ^ /@filter@/: the filter to use -} -> Bool {- ^ /@first@/: only return first match -} -> m [Gst.PluginFeature.PluginFeature] {- ^ __Returns:__ a 'GI.GLib.Structs.List.List' of 'GI.Gst.Objects.PluginFeature.PluginFeature'. Use 'GI.Gst.Objects.PluginFeature.pluginFeatureListFree' after usage. MT safe. -} registryFeatureFilter registry filter first = liftIO $ do registry' <- unsafeManagedPtrCastPtr registry filter' <- Gst.Callbacks.mk_PluginFeatureFilter (Gst.Callbacks.wrap_PluginFeatureFilter Nothing (Gst.Callbacks.drop_closures_PluginFeatureFilter filter)) let first' = (fromIntegral . fromEnum) first let userData = nullPtr result <- gst_registry_feature_filter registry' filter' first' userData result' <- unpackGList result result'' <- mapM (wrapObject Gst.PluginFeature.PluginFeature) result' g_list_free result safeFreeFunPtr $ castFunPtrToPtr filter' touchManagedPtr registry return result'' #if ENABLE_OVERLOADING data RegistryFeatureFilterMethodInfo instance (signature ~ (Gst.Callbacks.PluginFeatureFilter -> Bool -> m [Gst.PluginFeature.PluginFeature]), MonadIO m, IsRegistry a) => O.MethodInfo RegistryFeatureFilterMethodInfo a signature where overloadedMethod _ = registryFeatureFilter #endif -- method Registry::find_feature -- method type : OrdinaryMethod -- Args : [Arg {argCName = "registry", argType = TInterface (Name {namespace = "Gst", name = "Registry"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the registry to search", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the pluginfeature name to find", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "type", argType = TBasicType TGType, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the pluginfeature type to find", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TInterface (Name {namespace = "Gst", name = "PluginFeature"})) -- throws : False -- Skip return : False foreign import ccall "gst_registry_find_feature" gst_registry_find_feature :: Ptr Registry -> -- registry : TInterface (Name {namespace = "Gst", name = "Registry"}) CString -> -- name : TBasicType TUTF8 CGType -> -- type : TBasicType TGType IO (Ptr Gst.PluginFeature.PluginFeature) {- | Find the pluginfeature with the given name and type in the registry. -} registryFindFeature :: (B.CallStack.HasCallStack, MonadIO m, IsRegistry a) => a {- ^ /@registry@/: the registry to search -} -> T.Text {- ^ /@name@/: the pluginfeature name to find -} -> GType {- ^ /@type@/: the pluginfeature type to find -} -> m (Maybe Gst.PluginFeature.PluginFeature) {- ^ __Returns:__ the pluginfeature with the given name and type or 'Nothing' if the plugin was not found. 'GI.Gst.Objects.Object.objectUnref' after usage. MT safe. -} registryFindFeature registry name type_ = liftIO $ do registry' <- unsafeManagedPtrCastPtr registry name' <- textToCString name let type_' = gtypeToCGType type_ result <- gst_registry_find_feature registry' name' type_' maybeResult <- convertIfNonNull result $ \result' -> do result'' <- (wrapObject Gst.PluginFeature.PluginFeature) result' return result'' touchManagedPtr registry freeMem name' return maybeResult #if ENABLE_OVERLOADING data RegistryFindFeatureMethodInfo instance (signature ~ (T.Text -> GType -> m (Maybe Gst.PluginFeature.PluginFeature)), MonadIO m, IsRegistry a) => O.MethodInfo RegistryFindFeatureMethodInfo a signature where overloadedMethod _ = registryFindFeature #endif -- method Registry::find_plugin -- method type : OrdinaryMethod -- Args : [Arg {argCName = "registry", argType = TInterface (Name {namespace = "Gst", name = "Registry"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the registry to search", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the plugin name to find", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TInterface (Name {namespace = "Gst", name = "Plugin"})) -- throws : False -- Skip return : False foreign import ccall "gst_registry_find_plugin" gst_registry_find_plugin :: Ptr Registry -> -- registry : TInterface (Name {namespace = "Gst", name = "Registry"}) CString -> -- name : TBasicType TUTF8 IO (Ptr Gst.Plugin.Plugin) {- | Find the plugin with the given name in the registry. The plugin will be reffed; caller is responsible for unreffing. -} registryFindPlugin :: (B.CallStack.HasCallStack, MonadIO m, IsRegistry a) => a {- ^ /@registry@/: the registry to search -} -> T.Text {- ^ /@name@/: the plugin name to find -} -> m (Maybe Gst.Plugin.Plugin) {- ^ __Returns:__ the plugin with the given name or 'Nothing' if the plugin was not found. 'GI.Gst.Objects.Object.objectUnref' after usage. MT safe. -} registryFindPlugin registry name = liftIO $ do registry' <- unsafeManagedPtrCastPtr registry name' <- textToCString name result <- gst_registry_find_plugin registry' name' maybeResult <- convertIfNonNull result $ \result' -> do result'' <- (wrapObject Gst.Plugin.Plugin) result' return result'' touchManagedPtr registry freeMem name' return maybeResult #if ENABLE_OVERLOADING data RegistryFindPluginMethodInfo instance (signature ~ (T.Text -> m (Maybe Gst.Plugin.Plugin)), MonadIO m, IsRegistry a) => O.MethodInfo RegistryFindPluginMethodInfo a signature where overloadedMethod _ = registryFindPlugin #endif -- method Registry::get_feature_list -- method type : OrdinaryMethod -- Args : [Arg {argCName = "registry", argType = TInterface (Name {namespace = "Gst", name = "Registry"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstRegistry", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "type", argType = TBasicType TGType, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GType.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TGList (TInterface (Name {namespace = "Gst", name = "PluginFeature"}))) -- throws : False -- Skip return : False foreign import ccall "gst_registry_get_feature_list" gst_registry_get_feature_list :: Ptr Registry -> -- registry : TInterface (Name {namespace = "Gst", name = "Registry"}) CGType -> -- type : TBasicType TGType IO (Ptr (GList (Ptr Gst.PluginFeature.PluginFeature))) {- | Retrieves a 'GI.GLib.Structs.List.List' of 'GI.Gst.Objects.PluginFeature.PluginFeature' of /@type@/. -} registryGetFeatureList :: (B.CallStack.HasCallStack, MonadIO m, IsRegistry a) => a {- ^ /@registry@/: a 'GI.Gst.Objects.Registry.Registry' -} -> GType {- ^ /@type@/: a 'GType'. -} -> m [Gst.PluginFeature.PluginFeature] {- ^ __Returns:__ a 'GI.GLib.Structs.List.List' of 'GI.Gst.Objects.PluginFeature.PluginFeature' of /@type@/. Use 'GI.Gst.Objects.PluginFeature.pluginFeatureListFree' after use MT safe. -} registryGetFeatureList registry type_ = liftIO $ do registry' <- unsafeManagedPtrCastPtr registry let type_' = gtypeToCGType type_ result <- gst_registry_get_feature_list registry' type_' result' <- unpackGList result result'' <- mapM (wrapObject Gst.PluginFeature.PluginFeature) result' g_list_free result touchManagedPtr registry return result'' #if ENABLE_OVERLOADING data RegistryGetFeatureListMethodInfo instance (signature ~ (GType -> m [Gst.PluginFeature.PluginFeature]), MonadIO m, IsRegistry a) => O.MethodInfo RegistryGetFeatureListMethodInfo a signature where overloadedMethod _ = registryGetFeatureList #endif -- method Registry::get_feature_list_by_plugin -- method type : OrdinaryMethod -- Args : [Arg {argCName = "registry", argType = TInterface (Name {namespace = "Gst", name = "Registry"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstRegistry.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a plugin name.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TGList (TInterface (Name {namespace = "Gst", name = "PluginFeature"}))) -- throws : False -- Skip return : False foreign import ccall "gst_registry_get_feature_list_by_plugin" gst_registry_get_feature_list_by_plugin :: Ptr Registry -> -- registry : TInterface (Name {namespace = "Gst", name = "Registry"}) CString -> -- name : TBasicType TUTF8 IO (Ptr (GList (Ptr Gst.PluginFeature.PluginFeature))) {- | Retrieves a 'GI.GLib.Structs.List.List' of features of the plugin with name /@name@/. -} registryGetFeatureListByPlugin :: (B.CallStack.HasCallStack, MonadIO m, IsRegistry a) => a {- ^ /@registry@/: a 'GI.Gst.Objects.Registry.Registry'. -} -> T.Text {- ^ /@name@/: a plugin name. -} -> m [Gst.PluginFeature.PluginFeature] {- ^ __Returns:__ a 'GI.GLib.Structs.List.List' of 'GI.Gst.Objects.PluginFeature.PluginFeature'. Use 'GI.Gst.Objects.PluginFeature.pluginFeatureListFree' after usage. -} registryGetFeatureListByPlugin registry name = liftIO $ do registry' <- unsafeManagedPtrCastPtr registry name' <- textToCString name result <- gst_registry_get_feature_list_by_plugin registry' name' result' <- unpackGList result result'' <- mapM (wrapObject Gst.PluginFeature.PluginFeature) result' g_list_free result touchManagedPtr registry freeMem name' return result'' #if ENABLE_OVERLOADING data RegistryGetFeatureListByPluginMethodInfo instance (signature ~ (T.Text -> m [Gst.PluginFeature.PluginFeature]), MonadIO m, IsRegistry a) => O.MethodInfo RegistryGetFeatureListByPluginMethodInfo a signature where overloadedMethod _ = registryGetFeatureListByPlugin #endif -- method Registry::get_feature_list_cookie -- method type : OrdinaryMethod -- Args : [Arg {argCName = "registry", argType = TInterface (Name {namespace = "Gst", name = "Registry"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the registry", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TBasicType TUInt32) -- throws : False -- Skip return : False foreign import ccall "gst_registry_get_feature_list_cookie" gst_registry_get_feature_list_cookie :: Ptr Registry -> -- registry : TInterface (Name {namespace = "Gst", name = "Registry"}) IO Word32 {- | Returns the registry\'s feature list cookie. This changes every time a feature is added or removed from the registry. -} registryGetFeatureListCookie :: (B.CallStack.HasCallStack, MonadIO m, IsRegistry a) => a {- ^ /@registry@/: the registry -} -> m Word32 {- ^ __Returns:__ the feature list cookie. -} registryGetFeatureListCookie registry = liftIO $ do registry' <- unsafeManagedPtrCastPtr registry result <- gst_registry_get_feature_list_cookie registry' touchManagedPtr registry return result #if ENABLE_OVERLOADING data RegistryGetFeatureListCookieMethodInfo instance (signature ~ (m Word32), MonadIO m, IsRegistry a) => O.MethodInfo RegistryGetFeatureListCookieMethodInfo a signature where overloadedMethod _ = registryGetFeatureListCookie #endif -- method Registry::get_plugin_list -- method type : OrdinaryMethod -- Args : [Arg {argCName = "registry", argType = TInterface (Name {namespace = "Gst", name = "Registry"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the registry to search", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TGList (TInterface (Name {namespace = "Gst", name = "Plugin"}))) -- throws : False -- Skip return : False foreign import ccall "gst_registry_get_plugin_list" gst_registry_get_plugin_list :: Ptr Registry -> -- registry : TInterface (Name {namespace = "Gst", name = "Registry"}) IO (Ptr (GList (Ptr Gst.Plugin.Plugin))) {- | Get a copy of all plugins registered in the given registry. The refcount of each element in the list in incremented. -} registryGetPluginList :: (B.CallStack.HasCallStack, MonadIO m, IsRegistry a) => a {- ^ /@registry@/: the registry to search -} -> m [Gst.Plugin.Plugin] {- ^ __Returns:__ a 'GI.GLib.Structs.List.List' of 'GI.Gst.Objects.Plugin.Plugin'. Use 'GI.Gst.Objects.Plugin.pluginListFree' after usage. MT safe. -} registryGetPluginList registry = liftIO $ do registry' <- unsafeManagedPtrCastPtr registry result <- gst_registry_get_plugin_list registry' result' <- unpackGList result result'' <- mapM (wrapObject Gst.Plugin.Plugin) result' g_list_free result touchManagedPtr registry return result'' #if ENABLE_OVERLOADING data RegistryGetPluginListMethodInfo instance (signature ~ (m [Gst.Plugin.Plugin]), MonadIO m, IsRegistry a) => O.MethodInfo RegistryGetPluginListMethodInfo a signature where overloadedMethod _ = registryGetPluginList #endif -- method Registry::lookup -- method type : OrdinaryMethod -- Args : [Arg {argCName = "registry", argType = TInterface (Name {namespace = "Gst", name = "Registry"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the registry to look up in", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "filename", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the name of the file to look up", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TInterface (Name {namespace = "Gst", name = "Plugin"})) -- throws : False -- Skip return : False foreign import ccall "gst_registry_lookup" gst_registry_lookup :: Ptr Registry -> -- registry : TInterface (Name {namespace = "Gst", name = "Registry"}) CString -> -- filename : TBasicType TUTF8 IO (Ptr Gst.Plugin.Plugin) {- | Look up a plugin in the given registry with the given filename. If found, plugin is reffed. -} registryLookup :: (B.CallStack.HasCallStack, MonadIO m, IsRegistry a) => a {- ^ /@registry@/: the registry to look up in -} -> T.Text {- ^ /@filename@/: the name of the file to look up -} -> m (Maybe Gst.Plugin.Plugin) {- ^ __Returns:__ the 'GI.Gst.Objects.Plugin.Plugin' if found, or 'Nothing' if not. 'GI.Gst.Objects.Object.objectUnref' after usage. -} registryLookup registry filename = liftIO $ do registry' <- unsafeManagedPtrCastPtr registry filename' <- textToCString filename result <- gst_registry_lookup registry' filename' maybeResult <- convertIfNonNull result $ \result' -> do result'' <- (wrapObject Gst.Plugin.Plugin) result' return result'' touchManagedPtr registry freeMem filename' return maybeResult #if ENABLE_OVERLOADING data RegistryLookupMethodInfo instance (signature ~ (T.Text -> m (Maybe Gst.Plugin.Plugin)), MonadIO m, IsRegistry a) => O.MethodInfo RegistryLookupMethodInfo a signature where overloadedMethod _ = registryLookup #endif -- method Registry::lookup_feature -- method type : OrdinaryMethod -- Args : [Arg {argCName = "registry", argType = TInterface (Name {namespace = "Gst", name = "Registry"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstRegistry", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstPluginFeature name", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TInterface (Name {namespace = "Gst", name = "PluginFeature"})) -- throws : False -- Skip return : False foreign import ccall "gst_registry_lookup_feature" gst_registry_lookup_feature :: Ptr Registry -> -- registry : TInterface (Name {namespace = "Gst", name = "Registry"}) CString -> -- name : TBasicType TUTF8 IO (Ptr Gst.PluginFeature.PluginFeature) {- | Find a 'GI.Gst.Objects.PluginFeature.PluginFeature' with /@name@/ in /@registry@/. -} registryLookupFeature :: (B.CallStack.HasCallStack, MonadIO m, IsRegistry a) => a {- ^ /@registry@/: a 'GI.Gst.Objects.Registry.Registry' -} -> T.Text {- ^ /@name@/: a 'GI.Gst.Objects.PluginFeature.PluginFeature' name -} -> m Gst.PluginFeature.PluginFeature {- ^ __Returns:__ a 'GI.Gst.Objects.PluginFeature.PluginFeature' with its refcount incremented, use 'GI.Gst.Objects.Object.objectUnref' after usage. MT safe. -} registryLookupFeature registry name = liftIO $ do registry' <- unsafeManagedPtrCastPtr registry name' <- textToCString name result <- gst_registry_lookup_feature registry' name' checkUnexpectedReturnNULL "registryLookupFeature" result result' <- (wrapObject Gst.PluginFeature.PluginFeature) result touchManagedPtr registry freeMem name' return result' #if ENABLE_OVERLOADING data RegistryLookupFeatureMethodInfo instance (signature ~ (T.Text -> m Gst.PluginFeature.PluginFeature), MonadIO m, IsRegistry a) => O.MethodInfo RegistryLookupFeatureMethodInfo a signature where overloadedMethod _ = registryLookupFeature #endif -- method Registry::plugin_filter -- method type : OrdinaryMethod -- Args : [Arg {argCName = "registry", argType = TInterface (Name {namespace = "Gst", name = "Registry"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "registry to query", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "filter", argType = TInterface (Name {namespace = "Gst", name = "PluginFilter"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the filter to use", sinceVersion = Nothing}, argScope = ScopeTypeCall, argClosure = 3, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "first", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "only return first match", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "user data passed to the filter function", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TGList (TInterface (Name {namespace = "Gst", name = "Plugin"}))) -- throws : False -- Skip return : False foreign import ccall "gst_registry_plugin_filter" gst_registry_plugin_filter :: Ptr Registry -> -- registry : TInterface (Name {namespace = "Gst", name = "Registry"}) FunPtr Gst.Callbacks.C_PluginFilter -> -- filter : TInterface (Name {namespace = "Gst", name = "PluginFilter"}) CInt -> -- first : TBasicType TBoolean Ptr () -> -- user_data : TBasicType TPtr IO (Ptr (GList (Ptr Gst.Plugin.Plugin))) {- | Runs a filter against all plugins in the registry and returns a 'GI.GLib.Structs.List.List' with the results. If the first flag is set, only the first match is returned (as a list with a single object). Every plugin is reffed; use 'GI.Gst.Objects.Plugin.pluginListFree' after use, which will unref again. -} registryPluginFilter :: (B.CallStack.HasCallStack, MonadIO m, IsRegistry a) => a {- ^ /@registry@/: registry to query -} -> Gst.Callbacks.PluginFilter {- ^ /@filter@/: the filter to use -} -> Bool {- ^ /@first@/: only return first match -} -> m [Gst.Plugin.Plugin] {- ^ __Returns:__ a 'GI.GLib.Structs.List.List' of 'GI.Gst.Objects.Plugin.Plugin'. Use 'GI.Gst.Objects.Plugin.pluginListFree' after usage. MT safe. -} registryPluginFilter registry filter first = liftIO $ do registry' <- unsafeManagedPtrCastPtr registry filter' <- Gst.Callbacks.mk_PluginFilter (Gst.Callbacks.wrap_PluginFilter Nothing (Gst.Callbacks.drop_closures_PluginFilter filter)) let first' = (fromIntegral . fromEnum) first let userData = nullPtr result <- gst_registry_plugin_filter registry' filter' first' userData result' <- unpackGList result result'' <- mapM (wrapObject Gst.Plugin.Plugin) result' g_list_free result safeFreeFunPtr $ castFunPtrToPtr filter' touchManagedPtr registry return result'' #if ENABLE_OVERLOADING data RegistryPluginFilterMethodInfo instance (signature ~ (Gst.Callbacks.PluginFilter -> Bool -> m [Gst.Plugin.Plugin]), MonadIO m, IsRegistry a) => O.MethodInfo RegistryPluginFilterMethodInfo a signature where overloadedMethod _ = registryPluginFilter #endif -- method Registry::remove_feature -- method type : OrdinaryMethod -- Args : [Arg {argCName = "registry", argType = TInterface (Name {namespace = "Gst", name = "Registry"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the registry to remove the feature from", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "feature", argType = TInterface (Name {namespace = "Gst", name = "PluginFeature"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the feature 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_registry_remove_feature" gst_registry_remove_feature :: Ptr Registry -> -- registry : TInterface (Name {namespace = "Gst", name = "Registry"}) Ptr Gst.PluginFeature.PluginFeature -> -- feature : TInterface (Name {namespace = "Gst", name = "PluginFeature"}) IO () {- | Remove the feature from the registry. MT safe. -} registryRemoveFeature :: (B.CallStack.HasCallStack, MonadIO m, IsRegistry a, Gst.PluginFeature.IsPluginFeature b) => a {- ^ /@registry@/: the registry to remove the feature from -} -> b {- ^ /@feature@/: the feature to remove -} -> m () registryRemoveFeature registry feature = liftIO $ do registry' <- unsafeManagedPtrCastPtr registry feature' <- unsafeManagedPtrCastPtr feature gst_registry_remove_feature registry' feature' touchManagedPtr registry touchManagedPtr feature return () #if ENABLE_OVERLOADING data RegistryRemoveFeatureMethodInfo instance (signature ~ (b -> m ()), MonadIO m, IsRegistry a, Gst.PluginFeature.IsPluginFeature b) => O.MethodInfo RegistryRemoveFeatureMethodInfo a signature where overloadedMethod _ = registryRemoveFeature #endif -- method Registry::remove_plugin -- method type : OrdinaryMethod -- Args : [Arg {argCName = "registry", argType = TInterface (Name {namespace = "Gst", name = "Registry"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the registry to remove the plugin from", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "plugin", argType = TInterface (Name {namespace = "Gst", name = "Plugin"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the plugin 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_registry_remove_plugin" gst_registry_remove_plugin :: Ptr Registry -> -- registry : TInterface (Name {namespace = "Gst", name = "Registry"}) Ptr Gst.Plugin.Plugin -> -- plugin : TInterface (Name {namespace = "Gst", name = "Plugin"}) IO () {- | Remove the plugin from the registry. MT safe. -} registryRemovePlugin :: (B.CallStack.HasCallStack, MonadIO m, IsRegistry a, Gst.Plugin.IsPlugin b) => a {- ^ /@registry@/: the registry to remove the plugin from -} -> b {- ^ /@plugin@/: the plugin to remove -} -> m () registryRemovePlugin registry plugin = liftIO $ do registry' <- unsafeManagedPtrCastPtr registry plugin' <- unsafeManagedPtrCastPtr plugin gst_registry_remove_plugin registry' plugin' touchManagedPtr registry touchManagedPtr plugin return () #if ENABLE_OVERLOADING data RegistryRemovePluginMethodInfo instance (signature ~ (b -> m ()), MonadIO m, IsRegistry a, Gst.Plugin.IsPlugin b) => O.MethodInfo RegistryRemovePluginMethodInfo a signature where overloadedMethod _ = registryRemovePlugin #endif -- method Registry::scan_path -- method type : OrdinaryMethod -- Args : [Arg {argCName = "registry", argType = TInterface (Name {namespace = "Gst", name = "Registry"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the registry to add found plugins to", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "path", argType = TBasicType TFileName, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the path to scan", 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_registry_scan_path" gst_registry_scan_path :: Ptr Registry -> -- registry : TInterface (Name {namespace = "Gst", name = "Registry"}) CString -> -- path : TBasicType TFileName IO CInt {- | Scan the given path for plugins to add to the registry. The syntax of the path is specific to the registry. -} registryScanPath :: (B.CallStack.HasCallStack, MonadIO m, IsRegistry a) => a {- ^ /@registry@/: the registry to add found plugins to -} -> [Char] {- ^ /@path@/: the path to scan -} -> m Bool {- ^ __Returns:__ 'True' if registry changed -} registryScanPath registry path = liftIO $ do registry' <- unsafeManagedPtrCastPtr registry path' <- stringToCString path result <- gst_registry_scan_path registry' path' let result' = (/= 0) result touchManagedPtr registry freeMem path' return result' #if ENABLE_OVERLOADING data RegistryScanPathMethodInfo instance (signature ~ ([Char] -> m Bool), MonadIO m, IsRegistry a) => O.MethodInfo RegistryScanPathMethodInfo a signature where overloadedMethod _ = registryScanPath #endif -- method Registry::fork_is_enabled -- method type : MemberFunction -- Args : [] -- Lengths : [] -- returnType : Just (TBasicType TBoolean) -- throws : False -- Skip return : False foreign import ccall "gst_registry_fork_is_enabled" gst_registry_fork_is_enabled :: IO CInt {- | By default GStreamer will perform scanning and rebuilding of the registry file using a helper child process. Applications might want to disable this behaviour with the 'GI.Gst.Objects.Registry.registryForkSetEnabled' function, in which case new plugins are scanned (and loaded) into the application process. -} registryForkIsEnabled :: (B.CallStack.HasCallStack, MonadIO m) => m Bool {- ^ __Returns:__ 'True' if GStreamer will use the child helper process when rebuilding the registry. -} registryForkIsEnabled = liftIO $ do result <- gst_registry_fork_is_enabled let result' = (/= 0) result return result' #if ENABLE_OVERLOADING #endif -- method Registry::fork_set_enabled -- method type : MemberFunction -- Args : [Arg {argCName = "enabled", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "whether rebuilding the registry can use a temporary child helper process.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Nothing -- throws : False -- Skip return : False foreign import ccall "gst_registry_fork_set_enabled" gst_registry_fork_set_enabled :: CInt -> -- enabled : TBasicType TBoolean IO () {- | Applications might want to disable\/enable spawning of a child helper process when rebuilding the registry. See 'GI.Gst.Objects.Registry.registryForkIsEnabled' for more information. -} registryForkSetEnabled :: (B.CallStack.HasCallStack, MonadIO m) => Bool {- ^ /@enabled@/: whether rebuilding the registry can use a temporary child helper process. -} -> m () registryForkSetEnabled enabled = liftIO $ do let enabled' = (fromIntegral . fromEnum) enabled gst_registry_fork_set_enabled enabled' return () #if ENABLE_OVERLOADING #endif -- method Registry::get -- method type : MemberFunction -- Args : [] -- Lengths : [] -- returnType : Just (TInterface (Name {namespace = "Gst", name = "Registry"})) -- throws : False -- Skip return : False foreign import ccall "gst_registry_get" gst_registry_get :: IO (Ptr Registry) {- | Retrieves the singleton plugin registry. The caller does not own a reference on the registry, as it is alive as long as GStreamer is initialized. -} registryGet :: (B.CallStack.HasCallStack, MonadIO m) => m Registry {- ^ __Returns:__ the 'GI.Gst.Objects.Registry.Registry'. -} registryGet = liftIO $ do result <- gst_registry_get checkUnexpectedReturnNULL "registryGet" result result' <- (newObject Registry) result return result' #if ENABLE_OVERLOADING #endif