{- |
Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
License    : LGPL-2.1
Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)

This base class is for audio encoders turning raw audio samples into
encoded audio data.

GstAudioEncoder and subclass should cooperate as follows.
\<orderedlist>
\<listitem>
  \<itemizedlist>\<title>Configuration\<\/title>
  \<listitem>\<para>
    Initially, GstAudioEncoder calls /@start@/ when the encoder element
    is activated, which allows subclass to perform any global setup.
  \<\/para>\<\/listitem>
  \<listitem>\<para>
    GstAudioEncoder calls /@setFormat@/ to inform subclass of the format
    of input audio data that it is about to receive.  Subclass should
    setup for encoding and configure various base class parameters
    appropriately, notably those directing desired input data handling.
    While unlikely, it might be called more than once, if changing input
    parameters require reconfiguration.
  \<\/para>\<\/listitem>
  \<listitem>\<para>
    GstAudioEncoder calls /@stop@/ at end of all processing.
  \<\/para>\<\/listitem>
  \<\/itemizedlist>
\<\/listitem>
As of configuration stage, and throughout processing, GstAudioEncoder
maintains various parameters that provide required context,
e.g. describing the format of input audio data.
Conversely, subclass can and should configure these context parameters
to inform base class of its expectation w.r.t. buffer handling.
\<listitem>
  \<itemizedlist>
  \<title>Data processing\<\/title>
    \<listitem>\<para>
      Base class gathers input sample data (as directed by the context\'s
      frame_samples and frame_max) and provides this to subclass\' /@handleFrame@/.
    \<\/para>\<\/listitem>
    \<listitem>\<para>
      If codec processing results in encoded data, subclass should call
      'GI.GstAudio.Objects.AudioEncoder.audioEncoderFinishFrame' to have encoded data pushed
      downstream. Alternatively, it might also call
      'GI.GstAudio.Objects.AudioEncoder.audioEncoderFinishFrame' (with a NULL buffer and some number of
      dropped samples) to indicate dropped (non-encoded) samples.
    \<\/para>\<\/listitem>
    \<listitem>\<para>
      Just prior to actually pushing a buffer downstream,
      it is passed to /@prePush@/.
    \<\/para>\<\/listitem>
    \<listitem>\<para>
      During the parsing process GstAudioEncoderClass will handle both
      srcpad and sinkpad events. Sink events will be passed to subclass
      if /@event@/ callback has been provided.
    \<\/para>\<\/listitem>
  \<\/itemizedlist>
\<\/listitem>
\<listitem>
  \<itemizedlist>\<title>Shutdown phase\<\/title>
  \<listitem>\<para>
    GstAudioEncoder class calls /@stop@/ to inform the subclass that data
    parsing will be stopped.
  \<\/para>\<\/listitem>
  \<\/itemizedlist>
\<\/listitem>
\<\/orderedlist>

Subclass is responsible for providing pad template caps for
source and sink pads. The pads need to be named \"sink\" and \"src\". It also
needs to set the fixed caps on srcpad, when the format is ensured.  This
is typically when base class calls subclass\' /@setFormat@/ function, though
it might be delayed until calling /@gstAudioEncoderFinishFrame@/.

In summary, above process should have subclass concentrating on
codec data processing while leaving other matters to base class,
such as most notably timestamp handling.  While it may exert more control
in this area (see e.g. /@prePush@/), it is very much not recommended.

In particular, base class will either favor tracking upstream timestamps
(at the possible expense of jitter) or aim to arrange for a perfect stream of
output timestamps, depending on 'GI.GstAudio.Objects.AudioEncoder.AudioEncoder':@/perfect-timestamp/@.
However, in the latter case, the input may not be so perfect or ideal, which
is handled as follows.  An input timestamp is compared with the expected
timestamp as dictated by input sample stream and if the deviation is less
than 'GI.GstAudio.Objects.AudioEncoder.AudioEncoder':@/tolerance/@, the deviation is discarded.
Otherwise, it is considered a discontuinity and subsequent output timestamp
is resynced to the new position after performing configured discontinuity
processing.  In the non-perfect-timestamp case, an upstream variation
exceeding tolerance only leads to marking DISCONT on subsequent outgoing
(while timestamps are adjusted to upstream regardless of variation).
While DISCONT is also marked in the perfect-timestamp case, this one
optionally (see 'GI.GstAudio.Objects.AudioEncoder.AudioEncoder':@/hard-resync/@)
performs some additional steps, such as clipping of (early) input samples
or draining all currently remaining input data, depending on the direction
of the discontuinity.

If perfect timestamps are arranged, it is also possible to request baseclass
(usually set by subclass) to provide additional buffer metadata (in OFFSET
and OFFSET_END) fields according to granule defined semantics currently
needed by oggmux.  Specifically, OFFSET is set to granulepos (= sample count
including buffer) and OFFSET_END to corresponding timestamp (as determined
by same sample count and sample rate).

Things that subclass need to take care of:
\<itemizedlist>
  \<listitem>\<para>Provide pad templates\<\/para>\<\/listitem>
  \<listitem>\<para>
     Set source pad caps when appropriate
  \<\/para>\<\/listitem>
  \<listitem>\<para>
     Inform base class of buffer processing needs using context\'s
     frame_samples and frame_bytes.
  \<\/para>\<\/listitem>
  \<listitem>\<para>
     Set user-configurable properties to sane defaults for format and
     implementing codec at hand, e.g. those controlling timestamp behaviour
     and discontinuity processing.
  \<\/para>\<\/listitem>
  \<listitem>\<para>
     Accept data in /@handleFrame@/ and provide encoded results to
     'GI.GstAudio.Objects.AudioEncoder.audioEncoderFinishFrame'.
  \<\/para>\<\/listitem>
\<\/itemizedlist>
-}

module GI.GstAudio.Objects.AudioEncoder
    ( 

-- * Exported types
    AudioEncoder(..)                        ,
    IsAudioEncoder                          ,
    toAudioEncoder                          ,
    noAudioEncoder                          ,


 -- * Methods
-- ** allocateOutputBuffer #method:allocateOutputBuffer#
    AudioEncoderAllocateOutputBufferMethodInfo,
    audioEncoderAllocateOutputBuffer        ,


-- ** finishFrame #method:finishFrame#
    AudioEncoderFinishFrameMethodInfo       ,
    audioEncoderFinishFrame                 ,


-- ** getAllocator #method:getAllocator#
    AudioEncoderGetAllocatorMethodInfo      ,
    audioEncoderGetAllocator                ,


-- ** getAudioInfo #method:getAudioInfo#
    AudioEncoderGetAudioInfoMethodInfo      ,
    audioEncoderGetAudioInfo                ,


-- ** getDrainable #method:getDrainable#
    AudioEncoderGetDrainableMethodInfo      ,
    audioEncoderGetDrainable                ,


-- ** getFrameMax #method:getFrameMax#
    AudioEncoderGetFrameMaxMethodInfo       ,
    audioEncoderGetFrameMax                 ,


-- ** getFrameSamplesMax #method:getFrameSamplesMax#
    AudioEncoderGetFrameSamplesMaxMethodInfo,
    audioEncoderGetFrameSamplesMax          ,


-- ** getFrameSamplesMin #method:getFrameSamplesMin#
    AudioEncoderGetFrameSamplesMinMethodInfo,
    audioEncoderGetFrameSamplesMin          ,


-- ** getHardMin #method:getHardMin#
    AudioEncoderGetHardMinMethodInfo        ,
    audioEncoderGetHardMin                  ,


-- ** getHardResync #method:getHardResync#
    AudioEncoderGetHardResyncMethodInfo     ,
    audioEncoderGetHardResync               ,


-- ** getLatency #method:getLatency#
    AudioEncoderGetLatencyMethodInfo        ,
    audioEncoderGetLatency                  ,


-- ** getLookahead #method:getLookahead#
    AudioEncoderGetLookaheadMethodInfo      ,
    audioEncoderGetLookahead                ,


-- ** getMarkGranule #method:getMarkGranule#
    AudioEncoderGetMarkGranuleMethodInfo    ,
    audioEncoderGetMarkGranule              ,


-- ** getPerfectTimestamp #method:getPerfectTimestamp#
    AudioEncoderGetPerfectTimestampMethodInfo,
    audioEncoderGetPerfectTimestamp         ,


-- ** getTolerance #method:getTolerance#
    AudioEncoderGetToleranceMethodInfo      ,
    audioEncoderGetTolerance                ,


-- ** mergeTags #method:mergeTags#
    AudioEncoderMergeTagsMethodInfo         ,
    audioEncoderMergeTags                   ,


-- ** negotiate #method:negotiate#
    AudioEncoderNegotiateMethodInfo         ,
    audioEncoderNegotiate                   ,


-- ** proxyGetcaps #method:proxyGetcaps#
    AudioEncoderProxyGetcapsMethodInfo      ,
    audioEncoderProxyGetcaps                ,


-- ** setAllocationCaps #method:setAllocationCaps#
    AudioEncoderSetAllocationCapsMethodInfo ,
    audioEncoderSetAllocationCaps           ,


-- ** setDrainable #method:setDrainable#
    AudioEncoderSetDrainableMethodInfo      ,
    audioEncoderSetDrainable                ,


-- ** setFrameMax #method:setFrameMax#
    AudioEncoderSetFrameMaxMethodInfo       ,
    audioEncoderSetFrameMax                 ,


-- ** setFrameSamplesMax #method:setFrameSamplesMax#
    AudioEncoderSetFrameSamplesMaxMethodInfo,
    audioEncoderSetFrameSamplesMax          ,


-- ** setFrameSamplesMin #method:setFrameSamplesMin#
    AudioEncoderSetFrameSamplesMinMethodInfo,
    audioEncoderSetFrameSamplesMin          ,


-- ** setHardMin #method:setHardMin#
    AudioEncoderSetHardMinMethodInfo        ,
    audioEncoderSetHardMin                  ,


-- ** setHardResync #method:setHardResync#
    AudioEncoderSetHardResyncMethodInfo     ,
    audioEncoderSetHardResync               ,


-- ** setHeaders #method:setHeaders#
    AudioEncoderSetHeadersMethodInfo        ,
    audioEncoderSetHeaders                  ,


-- ** setLatency #method:setLatency#
    AudioEncoderSetLatencyMethodInfo        ,
    audioEncoderSetLatency                  ,


-- ** setLookahead #method:setLookahead#
    AudioEncoderSetLookaheadMethodInfo      ,
    audioEncoderSetLookahead                ,


-- ** setMarkGranule #method:setMarkGranule#
    AudioEncoderSetMarkGranuleMethodInfo    ,
    audioEncoderSetMarkGranule              ,


-- ** setOutputFormat #method:setOutputFormat#
    AudioEncoderSetOutputFormatMethodInfo   ,
    audioEncoderSetOutputFormat             ,


-- ** setPerfectTimestamp #method:setPerfectTimestamp#
    AudioEncoderSetPerfectTimestampMethodInfo,
    audioEncoderSetPerfectTimestamp         ,


-- ** setTolerance #method:setTolerance#
    AudioEncoderSetToleranceMethodInfo      ,
    audioEncoderSetTolerance                ,




 -- * Properties
-- ** hardResync #attr:hardResync#
    AudioEncoderHardResyncPropertyInfo      ,
    audioEncoderHardResync                  ,
    constructAudioEncoderHardResync         ,
    getAudioEncoderHardResync               ,
    setAudioEncoderHardResync               ,


-- ** markGranule #attr:markGranule#
    AudioEncoderMarkGranulePropertyInfo     ,
    audioEncoderMarkGranule                 ,
    getAudioEncoderMarkGranule              ,


-- ** perfectTimestamp #attr:perfectTimestamp#
    AudioEncoderPerfectTimestampPropertyInfo,
    audioEncoderPerfectTimestamp            ,
    constructAudioEncoderPerfectTimestamp   ,
    getAudioEncoderPerfectTimestamp         ,
    setAudioEncoderPerfectTimestamp         ,


-- ** tolerance #attr:tolerance#
    AudioEncoderTolerancePropertyInfo       ,
    audioEncoderTolerance                   ,
    constructAudioEncoderTolerance          ,
    getAudioEncoderTolerance                ,
    setAudioEncoderTolerance                ,




    ) 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.GError as B.GError
import qualified Data.GI.Base.GVariant as B.GVariant
import qualified Data.GI.Base.GParamSpec as B.GParamSpec
import qualified Data.GI.Base.CallStack as B.CallStack
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 GI.GObject.Objects.Object as GObject.Object
import qualified GI.Gst.Enums as Gst.Enums
import qualified GI.Gst.Interfaces.Preset as Gst.Preset
import qualified GI.Gst.Objects.Allocator as Gst.Allocator
import qualified GI.Gst.Objects.Element as Gst.Element
import qualified GI.Gst.Objects.Object as Gst.Object
import qualified GI.Gst.Structs.AllocationParams as Gst.AllocationParams
import qualified GI.Gst.Structs.Buffer as Gst.Buffer
import qualified GI.Gst.Structs.Caps as Gst.Caps
import qualified GI.Gst.Structs.TagList as Gst.TagList
import {-# SOURCE #-} qualified GI.GstAudio.Structs.AudioInfo as GstAudio.AudioInfo

newtype AudioEncoder = AudioEncoder (ManagedPtr AudioEncoder)
foreign import ccall "gst_audio_encoder_get_type"
    c_gst_audio_encoder_get_type :: IO GType

instance GObject AudioEncoder where
    gobjectType _ = c_gst_audio_encoder_get_type
    

class GObject o => IsAudioEncoder o
#if MIN_VERSION_base(4,9,0)
instance {-# OVERLAPPABLE #-} (GObject a, O.UnknownAncestorError AudioEncoder a) =>
    IsAudioEncoder a
#endif
instance IsAudioEncoder AudioEncoder
instance Gst.Element.IsElement AudioEncoder
instance Gst.Object.IsObject AudioEncoder
instance GObject.Object.IsObject AudioEncoder
instance Gst.Preset.IsPreset AudioEncoder

toAudioEncoder :: IsAudioEncoder o => o -> IO AudioEncoder
toAudioEncoder = unsafeCastTo AudioEncoder

noAudioEncoder :: Maybe AudioEncoder
noAudioEncoder = Nothing

type family ResolveAudioEncoderMethod (t :: Symbol) (o :: *) :: * where
    ResolveAudioEncoderMethod "abortState" o = Gst.Element.ElementAbortStateMethodInfo
    ResolveAudioEncoderMethod "addControlBinding" o = Gst.Object.ObjectAddControlBindingMethodInfo
    ResolveAudioEncoderMethod "addPad" o = Gst.Element.ElementAddPadMethodInfo
    ResolveAudioEncoderMethod "addPropertyDeepNotifyWatch" o = Gst.Element.ElementAddPropertyDeepNotifyWatchMethodInfo
    ResolveAudioEncoderMethod "addPropertyNotifyWatch" o = Gst.Element.ElementAddPropertyNotifyWatchMethodInfo
    ResolveAudioEncoderMethod "allocateOutputBuffer" o = AudioEncoderAllocateOutputBufferMethodInfo
    ResolveAudioEncoderMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
    ResolveAudioEncoderMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
    ResolveAudioEncoderMethod "callAsync" o = Gst.Element.ElementCallAsyncMethodInfo
    ResolveAudioEncoderMethod "changeState" o = Gst.Element.ElementChangeStateMethodInfo
    ResolveAudioEncoderMethod "continueState" o = Gst.Element.ElementContinueStateMethodInfo
    ResolveAudioEncoderMethod "createAllPads" o = Gst.Element.ElementCreateAllPadsMethodInfo
    ResolveAudioEncoderMethod "defaultError" o = Gst.Object.ObjectDefaultErrorMethodInfo
    ResolveAudioEncoderMethod "deletePreset" o = Gst.Preset.PresetDeletePresetMethodInfo
    ResolveAudioEncoderMethod "finishFrame" o = AudioEncoderFinishFrameMethodInfo
    ResolveAudioEncoderMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
    ResolveAudioEncoderMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
    ResolveAudioEncoderMethod "hasActiveControlBindings" o = Gst.Object.ObjectHasActiveControlBindingsMethodInfo
    ResolveAudioEncoderMethod "hasAncestor" o = Gst.Object.ObjectHasAncestorMethodInfo
    ResolveAudioEncoderMethod "hasAsAncestor" o = Gst.Object.ObjectHasAsAncestorMethodInfo
    ResolveAudioEncoderMethod "hasAsParent" o = Gst.Object.ObjectHasAsParentMethodInfo
    ResolveAudioEncoderMethod "isEditable" o = Gst.Preset.PresetIsEditableMethodInfo
    ResolveAudioEncoderMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
    ResolveAudioEncoderMethod "isLockedState" o = Gst.Element.ElementIsLockedStateMethodInfo
    ResolveAudioEncoderMethod "iteratePads" o = Gst.Element.ElementIteratePadsMethodInfo
    ResolveAudioEncoderMethod "iterateSinkPads" o = Gst.Element.ElementIterateSinkPadsMethodInfo
    ResolveAudioEncoderMethod "iterateSrcPads" o = Gst.Element.ElementIterateSrcPadsMethodInfo
    ResolveAudioEncoderMethod "link" o = Gst.Element.ElementLinkMethodInfo
    ResolveAudioEncoderMethod "linkFiltered" o = Gst.Element.ElementLinkFilteredMethodInfo
    ResolveAudioEncoderMethod "linkPads" o = Gst.Element.ElementLinkPadsMethodInfo
    ResolveAudioEncoderMethod "linkPadsFiltered" o = Gst.Element.ElementLinkPadsFilteredMethodInfo
    ResolveAudioEncoderMethod "linkPadsFull" o = Gst.Element.ElementLinkPadsFullMethodInfo
    ResolveAudioEncoderMethod "loadPreset" o = Gst.Preset.PresetLoadPresetMethodInfo
    ResolveAudioEncoderMethod "lostState" o = Gst.Element.ElementLostStateMethodInfo
    ResolveAudioEncoderMethod "mergeTags" o = AudioEncoderMergeTagsMethodInfo
    ResolveAudioEncoderMethod "messageFull" o = Gst.Element.ElementMessageFullMethodInfo
    ResolveAudioEncoderMethod "messageFullWithDetails" o = Gst.Element.ElementMessageFullWithDetailsMethodInfo
    ResolveAudioEncoderMethod "negotiate" o = AudioEncoderNegotiateMethodInfo
    ResolveAudioEncoderMethod "noMorePads" o = Gst.Element.ElementNoMorePadsMethodInfo
    ResolveAudioEncoderMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
    ResolveAudioEncoderMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
    ResolveAudioEncoderMethod "postMessage" o = Gst.Element.ElementPostMessageMethodInfo
    ResolveAudioEncoderMethod "provideClock" o = Gst.Element.ElementProvideClockMethodInfo
    ResolveAudioEncoderMethod "proxyGetcaps" o = AudioEncoderProxyGetcapsMethodInfo
    ResolveAudioEncoderMethod "query" o = Gst.Element.ElementQueryMethodInfo
    ResolveAudioEncoderMethod "queryConvert" o = Gst.Element.ElementQueryConvertMethodInfo
    ResolveAudioEncoderMethod "queryDuration" o = Gst.Element.ElementQueryDurationMethodInfo
    ResolveAudioEncoderMethod "queryPosition" o = Gst.Element.ElementQueryPositionMethodInfo
    ResolveAudioEncoderMethod "ref" o = Gst.Object.ObjectRefMethodInfo
    ResolveAudioEncoderMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
    ResolveAudioEncoderMethod "releaseRequestPad" o = Gst.Element.ElementReleaseRequestPadMethodInfo
    ResolveAudioEncoderMethod "removeControlBinding" o = Gst.Object.ObjectRemoveControlBindingMethodInfo
    ResolveAudioEncoderMethod "removePad" o = Gst.Element.ElementRemovePadMethodInfo
    ResolveAudioEncoderMethod "removePropertyNotifyWatch" o = Gst.Element.ElementRemovePropertyNotifyWatchMethodInfo
    ResolveAudioEncoderMethod "renamePreset" o = Gst.Preset.PresetRenamePresetMethodInfo
    ResolveAudioEncoderMethod "replaceData" o = GObject.Object.ObjectReplaceDataMethodInfo
    ResolveAudioEncoderMethod "replaceQdata" o = GObject.Object.ObjectReplaceQdataMethodInfo
    ResolveAudioEncoderMethod "requestPad" o = Gst.Element.ElementRequestPadMethodInfo
    ResolveAudioEncoderMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
    ResolveAudioEncoderMethod "savePreset" o = Gst.Preset.PresetSavePresetMethodInfo
    ResolveAudioEncoderMethod "seek" o = Gst.Element.ElementSeekMethodInfo
    ResolveAudioEncoderMethod "seekSimple" o = Gst.Element.ElementSeekSimpleMethodInfo
    ResolveAudioEncoderMethod "sendEvent" o = Gst.Element.ElementSendEventMethodInfo
    ResolveAudioEncoderMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
    ResolveAudioEncoderMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
    ResolveAudioEncoderMethod "suggestNextSync" o = Gst.Object.ObjectSuggestNextSyncMethodInfo
    ResolveAudioEncoderMethod "syncStateWithParent" o = Gst.Element.ElementSyncStateWithParentMethodInfo
    ResolveAudioEncoderMethod "syncValues" o = Gst.Object.ObjectSyncValuesMethodInfo
    ResolveAudioEncoderMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
    ResolveAudioEncoderMethod "unlink" o = Gst.Element.ElementUnlinkMethodInfo
    ResolveAudioEncoderMethod "unlinkPads" o = Gst.Element.ElementUnlinkPadsMethodInfo
    ResolveAudioEncoderMethod "unparent" o = Gst.Object.ObjectUnparentMethodInfo
    ResolveAudioEncoderMethod "unref" o = Gst.Object.ObjectUnrefMethodInfo
    ResolveAudioEncoderMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
    ResolveAudioEncoderMethod "getAllocator" o = AudioEncoderGetAllocatorMethodInfo
    ResolveAudioEncoderMethod "getAudioInfo" o = AudioEncoderGetAudioInfoMethodInfo
    ResolveAudioEncoderMethod "getBaseTime" o = Gst.Element.ElementGetBaseTimeMethodInfo
    ResolveAudioEncoderMethod "getBus" o = Gst.Element.ElementGetBusMethodInfo
    ResolveAudioEncoderMethod "getClock" o = Gst.Element.ElementGetClockMethodInfo
    ResolveAudioEncoderMethod "getCompatiblePad" o = Gst.Element.ElementGetCompatiblePadMethodInfo
    ResolveAudioEncoderMethod "getCompatiblePadTemplate" o = Gst.Element.ElementGetCompatiblePadTemplateMethodInfo
    ResolveAudioEncoderMethod "getContext" o = Gst.Element.ElementGetContextMethodInfo
    ResolveAudioEncoderMethod "getContextUnlocked" o = Gst.Element.ElementGetContextUnlockedMethodInfo
    ResolveAudioEncoderMethod "getContexts" o = Gst.Element.ElementGetContextsMethodInfo
    ResolveAudioEncoderMethod "getControlBinding" o = Gst.Object.ObjectGetControlBindingMethodInfo
    ResolveAudioEncoderMethod "getControlRate" o = Gst.Object.ObjectGetControlRateMethodInfo
    ResolveAudioEncoderMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
    ResolveAudioEncoderMethod "getDrainable" o = AudioEncoderGetDrainableMethodInfo
    ResolveAudioEncoderMethod "getFactory" o = Gst.Element.ElementGetFactoryMethodInfo
    ResolveAudioEncoderMethod "getFrameMax" o = AudioEncoderGetFrameMaxMethodInfo
    ResolveAudioEncoderMethod "getFrameSamplesMax" o = AudioEncoderGetFrameSamplesMaxMethodInfo
    ResolveAudioEncoderMethod "getFrameSamplesMin" o = AudioEncoderGetFrameSamplesMinMethodInfo
    ResolveAudioEncoderMethod "getGValueArray" o = Gst.Object.ObjectGetGValueArrayMethodInfo
    ResolveAudioEncoderMethod "getHardMin" o = AudioEncoderGetHardMinMethodInfo
    ResolveAudioEncoderMethod "getHardResync" o = AudioEncoderGetHardResyncMethodInfo
    ResolveAudioEncoderMethod "getLatency" o = AudioEncoderGetLatencyMethodInfo
    ResolveAudioEncoderMethod "getLookahead" o = AudioEncoderGetLookaheadMethodInfo
    ResolveAudioEncoderMethod "getMarkGranule" o = AudioEncoderGetMarkGranuleMethodInfo
    ResolveAudioEncoderMethod "getMeta" o = Gst.Preset.PresetGetMetaMethodInfo
    ResolveAudioEncoderMethod "getName" o = Gst.Object.ObjectGetNameMethodInfo
    ResolveAudioEncoderMethod "getParent" o = Gst.Object.ObjectGetParentMethodInfo
    ResolveAudioEncoderMethod "getPathString" o = Gst.Object.ObjectGetPathStringMethodInfo
    ResolveAudioEncoderMethod "getPerfectTimestamp" o = AudioEncoderGetPerfectTimestampMethodInfo
    ResolveAudioEncoderMethod "getPresetNames" o = Gst.Preset.PresetGetPresetNamesMethodInfo
    ResolveAudioEncoderMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
    ResolveAudioEncoderMethod "getPropertyNames" o = Gst.Preset.PresetGetPropertyNamesMethodInfo
    ResolveAudioEncoderMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
    ResolveAudioEncoderMethod "getRequestPad" o = Gst.Element.ElementGetRequestPadMethodInfo
    ResolveAudioEncoderMethod "getStartTime" o = Gst.Element.ElementGetStartTimeMethodInfo
    ResolveAudioEncoderMethod "getState" o = Gst.Element.ElementGetStateMethodInfo
    ResolveAudioEncoderMethod "getStaticPad" o = Gst.Element.ElementGetStaticPadMethodInfo
    ResolveAudioEncoderMethod "getTolerance" o = AudioEncoderGetToleranceMethodInfo
    ResolveAudioEncoderMethod "getValue" o = Gst.Object.ObjectGetValueMethodInfo
    ResolveAudioEncoderMethod "getValueArray" o = Gst.Object.ObjectGetValueArrayMethodInfo
    ResolveAudioEncoderMethod "setAllocationCaps" o = AudioEncoderSetAllocationCapsMethodInfo
    ResolveAudioEncoderMethod "setBaseTime" o = Gst.Element.ElementSetBaseTimeMethodInfo
    ResolveAudioEncoderMethod "setBus" o = Gst.Element.ElementSetBusMethodInfo
    ResolveAudioEncoderMethod "setClock" o = Gst.Element.ElementSetClockMethodInfo
    ResolveAudioEncoderMethod "setContext" o = Gst.Element.ElementSetContextMethodInfo
    ResolveAudioEncoderMethod "setControlBindingDisabled" o = Gst.Object.ObjectSetControlBindingDisabledMethodInfo
    ResolveAudioEncoderMethod "setControlBindingsDisabled" o = Gst.Object.ObjectSetControlBindingsDisabledMethodInfo
    ResolveAudioEncoderMethod "setControlRate" o = Gst.Object.ObjectSetControlRateMethodInfo
    ResolveAudioEncoderMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
    ResolveAudioEncoderMethod "setDrainable" o = AudioEncoderSetDrainableMethodInfo
    ResolveAudioEncoderMethod "setFrameMax" o = AudioEncoderSetFrameMaxMethodInfo
    ResolveAudioEncoderMethod "setFrameSamplesMax" o = AudioEncoderSetFrameSamplesMaxMethodInfo
    ResolveAudioEncoderMethod "setFrameSamplesMin" o = AudioEncoderSetFrameSamplesMinMethodInfo
    ResolveAudioEncoderMethod "setHardMin" o = AudioEncoderSetHardMinMethodInfo
    ResolveAudioEncoderMethod "setHardResync" o = AudioEncoderSetHardResyncMethodInfo
    ResolveAudioEncoderMethod "setHeaders" o = AudioEncoderSetHeadersMethodInfo
    ResolveAudioEncoderMethod "setLatency" o = AudioEncoderSetLatencyMethodInfo
    ResolveAudioEncoderMethod "setLockedState" o = Gst.Element.ElementSetLockedStateMethodInfo
    ResolveAudioEncoderMethod "setLookahead" o = AudioEncoderSetLookaheadMethodInfo
    ResolveAudioEncoderMethod "setMarkGranule" o = AudioEncoderSetMarkGranuleMethodInfo
    ResolveAudioEncoderMethod "setMeta" o = Gst.Preset.PresetSetMetaMethodInfo
    ResolveAudioEncoderMethod "setName" o = Gst.Object.ObjectSetNameMethodInfo
    ResolveAudioEncoderMethod "setOutputFormat" o = AudioEncoderSetOutputFormatMethodInfo
    ResolveAudioEncoderMethod "setParent" o = Gst.Object.ObjectSetParentMethodInfo
    ResolveAudioEncoderMethod "setPerfectTimestamp" o = AudioEncoderSetPerfectTimestampMethodInfo
    ResolveAudioEncoderMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
    ResolveAudioEncoderMethod "setStartTime" o = Gst.Element.ElementSetStartTimeMethodInfo
    ResolveAudioEncoderMethod "setState" o = Gst.Element.ElementSetStateMethodInfo
    ResolveAudioEncoderMethod "setTolerance" o = AudioEncoderSetToleranceMethodInfo
    ResolveAudioEncoderMethod l o = O.MethodResolutionFailed l o

instance (info ~ ResolveAudioEncoderMethod t AudioEncoder, O.MethodInfo info AudioEncoder p) => O.IsLabelProxy t (AudioEncoder -> p) where
    fromLabelProxy _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)

#if MIN_VERSION_base(4,9,0)
instance (info ~ ResolveAudioEncoderMethod t AudioEncoder, O.MethodInfo info AudioEncoder p) => O.IsLabel t (AudioEncoder -> p) where
    fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)
#endif

-- VVV Prop "hard-resync"
   -- Type: TBasicType TBoolean
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Just False)

getAudioEncoderHardResync :: (MonadIO m, IsAudioEncoder o) => o -> m Bool
getAudioEncoderHardResync obj = liftIO $ getObjectPropertyBool obj "hard-resync"

setAudioEncoderHardResync :: (MonadIO m, IsAudioEncoder o) => o -> Bool -> m ()
setAudioEncoderHardResync obj val = liftIO $ setObjectPropertyBool obj "hard-resync" val

constructAudioEncoderHardResync :: (IsAudioEncoder o) => Bool -> IO (GValueConstruct o)
constructAudioEncoderHardResync val = constructObjectPropertyBool "hard-resync" val

data AudioEncoderHardResyncPropertyInfo
instance AttrInfo AudioEncoderHardResyncPropertyInfo where
    type AttrAllowedOps AudioEncoderHardResyncPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint AudioEncoderHardResyncPropertyInfo = (~) Bool
    type AttrBaseTypeConstraint AudioEncoderHardResyncPropertyInfo = IsAudioEncoder
    type AttrGetType AudioEncoderHardResyncPropertyInfo = Bool
    type AttrLabel AudioEncoderHardResyncPropertyInfo = "hard-resync"
    type AttrOrigin AudioEncoderHardResyncPropertyInfo = AudioEncoder
    attrGet _ = getAudioEncoderHardResync
    attrSet _ = setAudioEncoderHardResync
    attrConstruct _ = constructAudioEncoderHardResync
    attrClear _ = undefined

-- VVV Prop "mark-granule"
   -- Type: TBasicType TBoolean
   -- Flags: [PropertyReadable]
   -- Nullable: (Just False,Just False)

getAudioEncoderMarkGranule :: (MonadIO m, IsAudioEncoder o) => o -> m Bool
getAudioEncoderMarkGranule obj = liftIO $ getObjectPropertyBool obj "mark-granule"

data AudioEncoderMarkGranulePropertyInfo
instance AttrInfo AudioEncoderMarkGranulePropertyInfo where
    type AttrAllowedOps AudioEncoderMarkGranulePropertyInfo = '[ 'AttrGet]
    type AttrSetTypeConstraint AudioEncoderMarkGranulePropertyInfo = (~) ()
    type AttrBaseTypeConstraint AudioEncoderMarkGranulePropertyInfo = IsAudioEncoder
    type AttrGetType AudioEncoderMarkGranulePropertyInfo = Bool
    type AttrLabel AudioEncoderMarkGranulePropertyInfo = "mark-granule"
    type AttrOrigin AudioEncoderMarkGranulePropertyInfo = AudioEncoder
    attrGet _ = getAudioEncoderMarkGranule
    attrSet _ = undefined
    attrConstruct _ = undefined
    attrClear _ = undefined

-- VVV Prop "perfect-timestamp"
   -- Type: TBasicType TBoolean
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Just False)

getAudioEncoderPerfectTimestamp :: (MonadIO m, IsAudioEncoder o) => o -> m Bool
getAudioEncoderPerfectTimestamp obj = liftIO $ getObjectPropertyBool obj "perfect-timestamp"

setAudioEncoderPerfectTimestamp :: (MonadIO m, IsAudioEncoder o) => o -> Bool -> m ()
setAudioEncoderPerfectTimestamp obj val = liftIO $ setObjectPropertyBool obj "perfect-timestamp" val

constructAudioEncoderPerfectTimestamp :: (IsAudioEncoder o) => Bool -> IO (GValueConstruct o)
constructAudioEncoderPerfectTimestamp val = constructObjectPropertyBool "perfect-timestamp" val

data AudioEncoderPerfectTimestampPropertyInfo
instance AttrInfo AudioEncoderPerfectTimestampPropertyInfo where
    type AttrAllowedOps AudioEncoderPerfectTimestampPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint AudioEncoderPerfectTimestampPropertyInfo = (~) Bool
    type AttrBaseTypeConstraint AudioEncoderPerfectTimestampPropertyInfo = IsAudioEncoder
    type AttrGetType AudioEncoderPerfectTimestampPropertyInfo = Bool
    type AttrLabel AudioEncoderPerfectTimestampPropertyInfo = "perfect-timestamp"
    type AttrOrigin AudioEncoderPerfectTimestampPropertyInfo = AudioEncoder
    attrGet _ = getAudioEncoderPerfectTimestamp
    attrSet _ = setAudioEncoderPerfectTimestamp
    attrConstruct _ = constructAudioEncoderPerfectTimestamp
    attrClear _ = undefined

-- VVV Prop "tolerance"
   -- Type: TBasicType TInt64
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Nothing,Nothing)

getAudioEncoderTolerance :: (MonadIO m, IsAudioEncoder o) => o -> m Int64
getAudioEncoderTolerance obj = liftIO $ getObjectPropertyInt64 obj "tolerance"

setAudioEncoderTolerance :: (MonadIO m, IsAudioEncoder o) => o -> Int64 -> m ()
setAudioEncoderTolerance obj val = liftIO $ setObjectPropertyInt64 obj "tolerance" val

constructAudioEncoderTolerance :: (IsAudioEncoder o) => Int64 -> IO (GValueConstruct o)
constructAudioEncoderTolerance val = constructObjectPropertyInt64 "tolerance" val

data AudioEncoderTolerancePropertyInfo
instance AttrInfo AudioEncoderTolerancePropertyInfo where
    type AttrAllowedOps AudioEncoderTolerancePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint AudioEncoderTolerancePropertyInfo = (~) Int64
    type AttrBaseTypeConstraint AudioEncoderTolerancePropertyInfo = IsAudioEncoder
    type AttrGetType AudioEncoderTolerancePropertyInfo = Int64
    type AttrLabel AudioEncoderTolerancePropertyInfo = "tolerance"
    type AttrOrigin AudioEncoderTolerancePropertyInfo = AudioEncoder
    attrGet _ = getAudioEncoderTolerance
    attrSet _ = setAudioEncoderTolerance
    attrConstruct _ = constructAudioEncoderTolerance
    attrClear _ = undefined

instance O.HasAttributeList AudioEncoder
type instance O.AttributeList AudioEncoder = AudioEncoderAttributeList
type AudioEncoderAttributeList = ('[ '("hardResync", AudioEncoderHardResyncPropertyInfo), '("markGranule", AudioEncoderMarkGranulePropertyInfo), '("name", Gst.Object.ObjectNamePropertyInfo), '("parent", Gst.Object.ObjectParentPropertyInfo), '("perfectTimestamp", AudioEncoderPerfectTimestampPropertyInfo), '("tolerance", AudioEncoderTolerancePropertyInfo)] :: [(Symbol, *)])

audioEncoderHardResync :: AttrLabelProxy "hardResync"
audioEncoderHardResync = AttrLabelProxy

audioEncoderMarkGranule :: AttrLabelProxy "markGranule"
audioEncoderMarkGranule = AttrLabelProxy

audioEncoderPerfectTimestamp :: AttrLabelProxy "perfectTimestamp"
audioEncoderPerfectTimestamp = AttrLabelProxy

audioEncoderTolerance :: AttrLabelProxy "tolerance"
audioEncoderTolerance = AttrLabelProxy

type instance O.SignalList AudioEncoder = AudioEncoderSignalList
type AudioEncoderSignalList = ('[ '("deepNotify", Gst.Object.ObjectDeepNotifySignalInfo), '("noMorePads", Gst.Element.ElementNoMorePadsSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo), '("padAdded", Gst.Element.ElementPadAddedSignalInfo), '("padRemoved", Gst.Element.ElementPadRemovedSignalInfo)] :: [(Symbol, *)])

-- method AudioEncoder::allocate_output_buffer
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "enc", argType = TInterface (Name {namespace = "GstAudio", name = "AudioEncoder"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstAudioEncoder", 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 the buffer", 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_audio_encoder_allocate_output_buffer" gst_audio_encoder_allocate_output_buffer :: 
    Ptr AudioEncoder ->                     -- enc : TInterface (Name {namespace = "GstAudio", name = "AudioEncoder"})
    Word64 ->                               -- size : TBasicType TUInt64
    IO (Ptr Gst.Buffer.Buffer)

{- |
Helper function that allocates a buffer to hold an encoded audio frame
for /@enc@/\'s current output format.
-}
audioEncoderAllocateOutputBuffer ::
    (B.CallStack.HasCallStack, MonadIO m, IsAudioEncoder a) =>
    a
    {- ^ /@enc@/: a 'GI.GstAudio.Objects.AudioEncoder.AudioEncoder' -}
    -> Word64
    {- ^ /@size@/: size of the buffer -}
    -> m Gst.Buffer.Buffer
    {- ^ __Returns:__ allocated buffer -}
audioEncoderAllocateOutputBuffer enc size = liftIO $ do
    enc' <- unsafeManagedPtrCastPtr enc
    result <- gst_audio_encoder_allocate_output_buffer enc' size
    checkUnexpectedReturnNULL "audioEncoderAllocateOutputBuffer" result
    result' <- (wrapBoxed Gst.Buffer.Buffer) result
    touchManagedPtr enc
    return result'

data AudioEncoderAllocateOutputBufferMethodInfo
instance (signature ~ (Word64 -> m Gst.Buffer.Buffer), MonadIO m, IsAudioEncoder a) => O.MethodInfo AudioEncoderAllocateOutputBufferMethodInfo a signature where
    overloadedMethod _ = audioEncoderAllocateOutputBuffer

-- method AudioEncoder::finish_frame
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "enc", argType = TInterface (Name {namespace = "GstAudio", name = "AudioEncoder"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstAudioEncoder", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "buffer", argType = TInterface (Name {namespace = "Gst", name = "Buffer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "encoded data", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "samples", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "number of samples (per channel) represented by encoded data", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "Gst", name = "FlowReturn"}))
-- throws : False
-- Skip return : False

foreign import ccall "gst_audio_encoder_finish_frame" gst_audio_encoder_finish_frame :: 
    Ptr AudioEncoder ->                     -- enc : TInterface (Name {namespace = "GstAudio", name = "AudioEncoder"})
    Ptr Gst.Buffer.Buffer ->                -- buffer : TInterface (Name {namespace = "Gst", name = "Buffer"})
    Int32 ->                                -- samples : TBasicType TInt
    IO CUInt

{- |
Collects encoded data and pushes encoded data downstream.
Source pad caps must be set when this is called.

If /@samples@/ \< 0, then best estimate is all samples provided to encoder
(subclass) so far.  /@buf@/ may be NULL, in which case next number of /@samples@/
are considered discarded, e.g. as a result of discontinuous transmission,
and a discontinuity is marked.

Note that samples received in @/gst_audio_encoder_handle_frame()/@
may be invalidated by a call to this function.
-}
audioEncoderFinishFrame ::
    (B.CallStack.HasCallStack, MonadIO m, IsAudioEncoder a) =>
    a
    {- ^ /@enc@/: a 'GI.GstAudio.Objects.AudioEncoder.AudioEncoder' -}
    -> Gst.Buffer.Buffer
    {- ^ /@buffer@/: encoded data -}
    -> Int32
    {- ^ /@samples@/: number of samples (per channel) represented by encoded data -}
    -> m Gst.Enums.FlowReturn
    {- ^ __Returns:__ a 'GI.Gst.Enums.FlowReturn' that should be escalated to caller (of caller) -}
audioEncoderFinishFrame enc buffer samples = liftIO $ do
    enc' <- unsafeManagedPtrCastPtr enc
    buffer' <- unsafeManagedPtrGetPtr buffer
    result <- gst_audio_encoder_finish_frame enc' buffer' samples
    let result' = (toEnum . fromIntegral) result
    touchManagedPtr enc
    touchManagedPtr buffer
    return result'

data AudioEncoderFinishFrameMethodInfo
instance (signature ~ (Gst.Buffer.Buffer -> Int32 -> m Gst.Enums.FlowReturn), MonadIO m, IsAudioEncoder a) => O.MethodInfo AudioEncoderFinishFrameMethodInfo a signature where
    overloadedMethod _ = audioEncoderFinishFrame

-- method AudioEncoder::get_allocator
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "enc", argType = TInterface (Name {namespace = "GstAudio", name = "AudioEncoder"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstAudioEncoder", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "allocator", argType = TInterface (Name {namespace = "Gst", name = "Allocator"}), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #GstAllocator\nused", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "params", argType = TInterface (Name {namespace = "Gst", name = "AllocationParams"}), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the\n#GstAllocatorParams of @allocator", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = True, transfer = TransferEverything}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gst_audio_encoder_get_allocator" gst_audio_encoder_get_allocator :: 
    Ptr AudioEncoder ->                     -- enc : TInterface (Name {namespace = "GstAudio", name = "AudioEncoder"})
    Ptr (Ptr Gst.Allocator.Allocator) ->    -- allocator : TInterface (Name {namespace = "Gst", name = "Allocator"})
    Ptr Gst.AllocationParams.AllocationParams -> -- params : TInterface (Name {namespace = "Gst", name = "AllocationParams"})
    IO ()

{- |
Lets 'GI.GstAudio.Objects.AudioEncoder.AudioEncoder' sub-classes to know the memory /@allocator@/
used by the base class and its /@params@/.

Unref the /@allocator@/ after use it.
-}
audioEncoderGetAllocator ::
    (B.CallStack.HasCallStack, MonadIO m, IsAudioEncoder a) =>
    a
    {- ^ /@enc@/: a 'GI.GstAudio.Objects.AudioEncoder.AudioEncoder' -}
    -> m (Gst.Allocator.Allocator,Gst.AllocationParams.AllocationParams)
audioEncoderGetAllocator enc = liftIO $ do
    enc' <- unsafeManagedPtrCastPtr enc
    allocator <- allocMem :: IO (Ptr (Ptr Gst.Allocator.Allocator))
    params <- callocBoxedBytes 64 :: IO (Ptr Gst.AllocationParams.AllocationParams)
    gst_audio_encoder_get_allocator enc' allocator params
    allocator' <- peek allocator
    allocator'' <- (wrapObject Gst.Allocator.Allocator) allocator'
    params' <- (wrapBoxed Gst.AllocationParams.AllocationParams) params
    touchManagedPtr enc
    freeMem allocator
    return (allocator'', params')

data AudioEncoderGetAllocatorMethodInfo
instance (signature ~ (m (Gst.Allocator.Allocator,Gst.AllocationParams.AllocationParams)), MonadIO m, IsAudioEncoder a) => O.MethodInfo AudioEncoderGetAllocatorMethodInfo a signature where
    overloadedMethod _ = audioEncoderGetAllocator

-- method AudioEncoder::get_audio_info
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "enc", argType = TInterface (Name {namespace = "GstAudio", name = "AudioEncoder"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstAudioEncoder", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "GstAudio", name = "AudioInfo"}))
-- throws : False
-- Skip return : False

foreign import ccall "gst_audio_encoder_get_audio_info" gst_audio_encoder_get_audio_info :: 
    Ptr AudioEncoder ->                     -- enc : TInterface (Name {namespace = "GstAudio", name = "AudioEncoder"})
    IO (Ptr GstAudio.AudioInfo.AudioInfo)

{- |
/No description available in the introspection data./
-}
audioEncoderGetAudioInfo ::
    (B.CallStack.HasCallStack, MonadIO m, IsAudioEncoder a) =>
    a
    {- ^ /@enc@/: a 'GI.GstAudio.Objects.AudioEncoder.AudioEncoder' -}
    -> m GstAudio.AudioInfo.AudioInfo
    {- ^ __Returns:__ a 'GI.GstAudio.Structs.AudioInfo.AudioInfo' describing the input audio format -}
audioEncoderGetAudioInfo enc = liftIO $ do
    enc' <- unsafeManagedPtrCastPtr enc
    result <- gst_audio_encoder_get_audio_info enc'
    checkUnexpectedReturnNULL "audioEncoderGetAudioInfo" result
    result' <- (wrapBoxed GstAudio.AudioInfo.AudioInfo) result
    touchManagedPtr enc
    return result'

data AudioEncoderGetAudioInfoMethodInfo
instance (signature ~ (m GstAudio.AudioInfo.AudioInfo), MonadIO m, IsAudioEncoder a) => O.MethodInfo AudioEncoderGetAudioInfoMethodInfo a signature where
    overloadedMethod _ = audioEncoderGetAudioInfo

-- method AudioEncoder::get_drainable
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "enc", argType = TInterface (Name {namespace = "GstAudio", name = "AudioEncoder"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstAudioEncoder", 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_audio_encoder_get_drainable" gst_audio_encoder_get_drainable :: 
    Ptr AudioEncoder ->                     -- enc : TInterface (Name {namespace = "GstAudio", name = "AudioEncoder"})
    IO CInt

{- |
Queries encoder drain handling.
-}
audioEncoderGetDrainable ::
    (B.CallStack.HasCallStack, MonadIO m, IsAudioEncoder a) =>
    a
    {- ^ /@enc@/: a 'GI.GstAudio.Objects.AudioEncoder.AudioEncoder' -}
    -> m Bool
    {- ^ __Returns:__ TRUE if drainable handling is enabled.

MT safe. -}
audioEncoderGetDrainable enc = liftIO $ do
    enc' <- unsafeManagedPtrCastPtr enc
    result <- gst_audio_encoder_get_drainable enc'
    let result' = (/= 0) result
    touchManagedPtr enc
    return result'

data AudioEncoderGetDrainableMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsAudioEncoder a) => O.MethodInfo AudioEncoderGetDrainableMethodInfo a signature where
    overloadedMethod _ = audioEncoderGetDrainable

-- method AudioEncoder::get_frame_max
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "enc", argType = TInterface (Name {namespace = "GstAudio", name = "AudioEncoder"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstAudioEncoder", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TInt)
-- throws : False
-- Skip return : False

foreign import ccall "gst_audio_encoder_get_frame_max" gst_audio_encoder_get_frame_max :: 
    Ptr AudioEncoder ->                     -- enc : TInterface (Name {namespace = "GstAudio", name = "AudioEncoder"})
    IO Int32

{- |
/No description available in the introspection data./
-}
audioEncoderGetFrameMax ::
    (B.CallStack.HasCallStack, MonadIO m, IsAudioEncoder a) =>
    a
    {- ^ /@enc@/: a 'GI.GstAudio.Objects.AudioEncoder.AudioEncoder' -}
    -> m Int32
    {- ^ __Returns:__ currently configured maximum handled frames -}
audioEncoderGetFrameMax enc = liftIO $ do
    enc' <- unsafeManagedPtrCastPtr enc
    result <- gst_audio_encoder_get_frame_max enc'
    touchManagedPtr enc
    return result

data AudioEncoderGetFrameMaxMethodInfo
instance (signature ~ (m Int32), MonadIO m, IsAudioEncoder a) => O.MethodInfo AudioEncoderGetFrameMaxMethodInfo a signature where
    overloadedMethod _ = audioEncoderGetFrameMax

-- method AudioEncoder::get_frame_samples_max
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "enc", argType = TInterface (Name {namespace = "GstAudio", name = "AudioEncoder"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstAudioEncoder", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TInt)
-- throws : False
-- Skip return : False

foreign import ccall "gst_audio_encoder_get_frame_samples_max" gst_audio_encoder_get_frame_samples_max :: 
    Ptr AudioEncoder ->                     -- enc : TInterface (Name {namespace = "GstAudio", name = "AudioEncoder"})
    IO Int32

{- |
/No description available in the introspection data./
-}
audioEncoderGetFrameSamplesMax ::
    (B.CallStack.HasCallStack, MonadIO m, IsAudioEncoder a) =>
    a
    {- ^ /@enc@/: a 'GI.GstAudio.Objects.AudioEncoder.AudioEncoder' -}
    -> m Int32
    {- ^ __Returns:__ currently maximum requested samples per frame -}
audioEncoderGetFrameSamplesMax enc = liftIO $ do
    enc' <- unsafeManagedPtrCastPtr enc
    result <- gst_audio_encoder_get_frame_samples_max enc'
    touchManagedPtr enc
    return result

data AudioEncoderGetFrameSamplesMaxMethodInfo
instance (signature ~ (m Int32), MonadIO m, IsAudioEncoder a) => O.MethodInfo AudioEncoderGetFrameSamplesMaxMethodInfo a signature where
    overloadedMethod _ = audioEncoderGetFrameSamplesMax

-- method AudioEncoder::get_frame_samples_min
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "enc", argType = TInterface (Name {namespace = "GstAudio", name = "AudioEncoder"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstAudioEncoder", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TInt)
-- throws : False
-- Skip return : False

foreign import ccall "gst_audio_encoder_get_frame_samples_min" gst_audio_encoder_get_frame_samples_min :: 
    Ptr AudioEncoder ->                     -- enc : TInterface (Name {namespace = "GstAudio", name = "AudioEncoder"})
    IO Int32

{- |
/No description available in the introspection data./
-}
audioEncoderGetFrameSamplesMin ::
    (B.CallStack.HasCallStack, MonadIO m, IsAudioEncoder a) =>
    a
    {- ^ /@enc@/: a 'GI.GstAudio.Objects.AudioEncoder.AudioEncoder' -}
    -> m Int32
    {- ^ __Returns:__ currently minimum requested samples per frame -}
audioEncoderGetFrameSamplesMin enc = liftIO $ do
    enc' <- unsafeManagedPtrCastPtr enc
    result <- gst_audio_encoder_get_frame_samples_min enc'
    touchManagedPtr enc
    return result

data AudioEncoderGetFrameSamplesMinMethodInfo
instance (signature ~ (m Int32), MonadIO m, IsAudioEncoder a) => O.MethodInfo AudioEncoderGetFrameSamplesMinMethodInfo a signature where
    overloadedMethod _ = audioEncoderGetFrameSamplesMin

-- method AudioEncoder::get_hard_min
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "enc", argType = TInterface (Name {namespace = "GstAudio", name = "AudioEncoder"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstAudioEncoder", 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_audio_encoder_get_hard_min" gst_audio_encoder_get_hard_min :: 
    Ptr AudioEncoder ->                     -- enc : TInterface (Name {namespace = "GstAudio", name = "AudioEncoder"})
    IO CInt

{- |
Queries encoder hard minimum handling.
-}
audioEncoderGetHardMin ::
    (B.CallStack.HasCallStack, MonadIO m, IsAudioEncoder a) =>
    a
    {- ^ /@enc@/: a 'GI.GstAudio.Objects.AudioEncoder.AudioEncoder' -}
    -> m Bool
    {- ^ __Returns:__ TRUE if hard minimum handling is enabled.

MT safe. -}
audioEncoderGetHardMin enc = liftIO $ do
    enc' <- unsafeManagedPtrCastPtr enc
    result <- gst_audio_encoder_get_hard_min enc'
    let result' = (/= 0) result
    touchManagedPtr enc
    return result'

data AudioEncoderGetHardMinMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsAudioEncoder a) => O.MethodInfo AudioEncoderGetHardMinMethodInfo a signature where
    overloadedMethod _ = audioEncoderGetHardMin

-- method AudioEncoder::get_hard_resync
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "enc", argType = TInterface (Name {namespace = "GstAudio", name = "AudioEncoder"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, 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_audio_encoder_get_hard_resync" gst_audio_encoder_get_hard_resync :: 
    Ptr AudioEncoder ->                     -- enc : TInterface (Name {namespace = "GstAudio", name = "AudioEncoder"})
    IO CInt

{- |
/No description available in the introspection data./
-}
audioEncoderGetHardResync ::
    (B.CallStack.HasCallStack, MonadIO m, IsAudioEncoder a) =>
    a
    -> m Bool
audioEncoderGetHardResync enc = liftIO $ do
    enc' <- unsafeManagedPtrCastPtr enc
    result <- gst_audio_encoder_get_hard_resync enc'
    let result' = (/= 0) result
    touchManagedPtr enc
    return result'

data AudioEncoderGetHardResyncMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsAudioEncoder a) => O.MethodInfo AudioEncoderGetHardResyncMethodInfo a signature where
    overloadedMethod _ = audioEncoderGetHardResync

-- method AudioEncoder::get_latency
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "enc", argType = TInterface (Name {namespace = "GstAudio", name = "AudioEncoder"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstAudioEncoder", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "min", argType = TBasicType TUInt64, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a pointer to storage to hold minimum latency", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "max", argType = TBasicType TUInt64, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a pointer to storage to hold maximum latency", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gst_audio_encoder_get_latency" gst_audio_encoder_get_latency :: 
    Ptr AudioEncoder ->                     -- enc : TInterface (Name {namespace = "GstAudio", name = "AudioEncoder"})
    Ptr Word64 ->                           -- min : TBasicType TUInt64
    Ptr Word64 ->                           -- max : TBasicType TUInt64
    IO ()

{- |
Sets the variables pointed to by /@min@/ and /@max@/ to the currently configured
latency.
-}
audioEncoderGetLatency ::
    (B.CallStack.HasCallStack, MonadIO m, IsAudioEncoder a) =>
    a
    {- ^ /@enc@/: a 'GI.GstAudio.Objects.AudioEncoder.AudioEncoder' -}
    -> m (Word64,Word64)
audioEncoderGetLatency enc = liftIO $ do
    enc' <- unsafeManagedPtrCastPtr enc
    min <- allocMem :: IO (Ptr Word64)
    max <- allocMem :: IO (Ptr Word64)
    gst_audio_encoder_get_latency enc' min max
    min' <- peek min
    max' <- peek max
    touchManagedPtr enc
    freeMem min
    freeMem max
    return (min', max')

data AudioEncoderGetLatencyMethodInfo
instance (signature ~ (m (Word64,Word64)), MonadIO m, IsAudioEncoder a) => O.MethodInfo AudioEncoderGetLatencyMethodInfo a signature where
    overloadedMethod _ = audioEncoderGetLatency

-- method AudioEncoder::get_lookahead
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "enc", argType = TInterface (Name {namespace = "GstAudio", name = "AudioEncoder"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstAudioEncoder", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TInt)
-- throws : False
-- Skip return : False

foreign import ccall "gst_audio_encoder_get_lookahead" gst_audio_encoder_get_lookahead :: 
    Ptr AudioEncoder ->                     -- enc : TInterface (Name {namespace = "GstAudio", name = "AudioEncoder"})
    IO Int32

{- |
/No description available in the introspection data./
-}
audioEncoderGetLookahead ::
    (B.CallStack.HasCallStack, MonadIO m, IsAudioEncoder a) =>
    a
    {- ^ /@enc@/: a 'GI.GstAudio.Objects.AudioEncoder.AudioEncoder' -}
    -> m Int32
    {- ^ __Returns:__ currently configured encoder lookahead -}
audioEncoderGetLookahead enc = liftIO $ do
    enc' <- unsafeManagedPtrCastPtr enc
    result <- gst_audio_encoder_get_lookahead enc'
    touchManagedPtr enc
    return result

data AudioEncoderGetLookaheadMethodInfo
instance (signature ~ (m Int32), MonadIO m, IsAudioEncoder a) => O.MethodInfo AudioEncoderGetLookaheadMethodInfo a signature where
    overloadedMethod _ = audioEncoderGetLookahead

-- method AudioEncoder::get_mark_granule
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "enc", argType = TInterface (Name {namespace = "GstAudio", name = "AudioEncoder"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstAudioEncoder", 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_audio_encoder_get_mark_granule" gst_audio_encoder_get_mark_granule :: 
    Ptr AudioEncoder ->                     -- enc : TInterface (Name {namespace = "GstAudio", name = "AudioEncoder"})
    IO CInt

{- |
Queries if the encoder will handle granule marking.
-}
audioEncoderGetMarkGranule ::
    (B.CallStack.HasCallStack, MonadIO m, IsAudioEncoder a) =>
    a
    {- ^ /@enc@/: a 'GI.GstAudio.Objects.AudioEncoder.AudioEncoder' -}
    -> m Bool
    {- ^ __Returns:__ TRUE if granule marking is enabled.

MT safe. -}
audioEncoderGetMarkGranule enc = liftIO $ do
    enc' <- unsafeManagedPtrCastPtr enc
    result <- gst_audio_encoder_get_mark_granule enc'
    let result' = (/= 0) result
    touchManagedPtr enc
    return result'

data AudioEncoderGetMarkGranuleMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsAudioEncoder a) => O.MethodInfo AudioEncoderGetMarkGranuleMethodInfo a signature where
    overloadedMethod _ = audioEncoderGetMarkGranule

-- method AudioEncoder::get_perfect_timestamp
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "enc", argType = TInterface (Name {namespace = "GstAudio", name = "AudioEncoder"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstAudioEncoder", 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_audio_encoder_get_perfect_timestamp" gst_audio_encoder_get_perfect_timestamp :: 
    Ptr AudioEncoder ->                     -- enc : TInterface (Name {namespace = "GstAudio", name = "AudioEncoder"})
    IO CInt

{- |
Queries encoder perfect timestamp behaviour.
-}
audioEncoderGetPerfectTimestamp ::
    (B.CallStack.HasCallStack, MonadIO m, IsAudioEncoder a) =>
    a
    {- ^ /@enc@/: a 'GI.GstAudio.Objects.AudioEncoder.AudioEncoder' -}
    -> m Bool
    {- ^ __Returns:__ TRUE if perfect timestamp setting enabled.

MT safe. -}
audioEncoderGetPerfectTimestamp enc = liftIO $ do
    enc' <- unsafeManagedPtrCastPtr enc
    result <- gst_audio_encoder_get_perfect_timestamp enc'
    let result' = (/= 0) result
    touchManagedPtr enc
    return result'

data AudioEncoderGetPerfectTimestampMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsAudioEncoder a) => O.MethodInfo AudioEncoderGetPerfectTimestampMethodInfo a signature where
    overloadedMethod _ = audioEncoderGetPerfectTimestamp

-- method AudioEncoder::get_tolerance
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "enc", argType = TInterface (Name {namespace = "GstAudio", name = "AudioEncoder"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstAudioEncoder", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TUInt64)
-- throws : False
-- Skip return : False

foreign import ccall "gst_audio_encoder_get_tolerance" gst_audio_encoder_get_tolerance :: 
    Ptr AudioEncoder ->                     -- enc : TInterface (Name {namespace = "GstAudio", name = "AudioEncoder"})
    IO Word64

{- |
Queries current audio jitter tolerance threshold.
-}
audioEncoderGetTolerance ::
    (B.CallStack.HasCallStack, MonadIO m, IsAudioEncoder a) =>
    a
    {- ^ /@enc@/: a 'GI.GstAudio.Objects.AudioEncoder.AudioEncoder' -}
    -> m Word64
    {- ^ __Returns:__ encoder audio jitter tolerance threshold.

MT safe. -}
audioEncoderGetTolerance enc = liftIO $ do
    enc' <- unsafeManagedPtrCastPtr enc
    result <- gst_audio_encoder_get_tolerance enc'
    touchManagedPtr enc
    return result

data AudioEncoderGetToleranceMethodInfo
instance (signature ~ (m Word64), MonadIO m, IsAudioEncoder a) => O.MethodInfo AudioEncoderGetToleranceMethodInfo a signature where
    overloadedMethod _ = audioEncoderGetTolerance

-- method AudioEncoder::merge_tags
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "enc", argType = TInterface (Name {namespace = "GstAudio", name = "AudioEncoder"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstAudioEncoder", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "tags", argType = TInterface (Name {namespace = "Gst", name = "TagList"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a #GstTagList to merge, or NULL to unset\n    previously-set tags", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "mode", argType = TInterface (Name {namespace = "Gst", name = "TagMergeMode"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #GstTagMergeMode to use, usually #GST_TAG_MERGE_REPLACE", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gst_audio_encoder_merge_tags" gst_audio_encoder_merge_tags :: 
    Ptr AudioEncoder ->                     -- enc : TInterface (Name {namespace = "GstAudio", name = "AudioEncoder"})
    Ptr Gst.TagList.TagList ->              -- tags : TInterface (Name {namespace = "Gst", name = "TagList"})
    CUInt ->                                -- mode : TInterface (Name {namespace = "Gst", name = "TagMergeMode"})
    IO ()

{- |
Sets the audio encoder tags and how they should be merged with any
upstream stream tags. This will override any tags previously-set
with 'GI.GstAudio.Objects.AudioEncoder.audioEncoderMergeTags'.

Note that this is provided for convenience, and the subclass is
not required to use this and can still do tag handling on its own.

MT safe.
-}
audioEncoderMergeTags ::
    (B.CallStack.HasCallStack, MonadIO m, IsAudioEncoder a) =>
    a
    {- ^ /@enc@/: a 'GI.GstAudio.Objects.AudioEncoder.AudioEncoder' -}
    -> Maybe (Gst.TagList.TagList)
    {- ^ /@tags@/: a 'GI.Gst.Structs.TagList.TagList' to merge, or NULL to unset
    previously-set tags -}
    -> Gst.Enums.TagMergeMode
    {- ^ /@mode@/: the 'GI.Gst.Enums.TagMergeMode' to use, usually @/GST_TAG_MERGE_REPLACE/@ -}
    -> m ()
audioEncoderMergeTags enc tags mode = liftIO $ do
    enc' <- unsafeManagedPtrCastPtr enc
    maybeTags <- case tags of
        Nothing -> return nullPtr
        Just jTags -> do
            jTags' <- unsafeManagedPtrGetPtr jTags
            return jTags'
    let mode' = (fromIntegral . fromEnum) mode
    gst_audio_encoder_merge_tags enc' maybeTags mode'
    touchManagedPtr enc
    whenJust tags touchManagedPtr
    return ()

data AudioEncoderMergeTagsMethodInfo
instance (signature ~ (Maybe (Gst.TagList.TagList) -> Gst.Enums.TagMergeMode -> m ()), MonadIO m, IsAudioEncoder a) => O.MethodInfo AudioEncoderMergeTagsMethodInfo a signature where
    overloadedMethod _ = audioEncoderMergeTags

-- method AudioEncoder::negotiate
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "enc", argType = TInterface (Name {namespace = "GstAudio", name = "AudioEncoder"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstAudioEncoder", 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_audio_encoder_negotiate" gst_audio_encoder_negotiate :: 
    Ptr AudioEncoder ->                     -- enc : TInterface (Name {namespace = "GstAudio", name = "AudioEncoder"})
    IO CInt

{- |
Negotiate with downstream elements to currently configured 'GI.Gst.Structs.Caps.Caps'.
Unmark GST_PAD_FLAG_NEED_RECONFIGURE in any case. But mark it again if
negotiate fails.
-}
audioEncoderNegotiate ::
    (B.CallStack.HasCallStack, MonadIO m, IsAudioEncoder a) =>
    a
    {- ^ /@enc@/: a 'GI.GstAudio.Objects.AudioEncoder.AudioEncoder' -}
    -> m Bool
    {- ^ __Returns:__ @/TRUE/@ if the negotiation succeeded, else @/FALSE/@. -}
audioEncoderNegotiate enc = liftIO $ do
    enc' <- unsafeManagedPtrCastPtr enc
    result <- gst_audio_encoder_negotiate enc'
    let result' = (/= 0) result
    touchManagedPtr enc
    return result'

data AudioEncoderNegotiateMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsAudioEncoder a) => O.MethodInfo AudioEncoderNegotiateMethodInfo a signature where
    overloadedMethod _ = audioEncoderNegotiate

-- method AudioEncoder::proxy_getcaps
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "enc", argType = TInterface (Name {namespace = "GstAudio", name = "AudioEncoder"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstAudioEncoder", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "caps", argType = TInterface (Name {namespace = "Gst", name = "Caps"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "initial caps", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "filter", argType = TInterface (Name {namespace = "Gst", name = "Caps"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "filter caps", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "Gst", name = "Caps"}))
-- throws : False
-- Skip return : False

foreign import ccall "gst_audio_encoder_proxy_getcaps" gst_audio_encoder_proxy_getcaps :: 
    Ptr AudioEncoder ->                     -- enc : TInterface (Name {namespace = "GstAudio", name = "AudioEncoder"})
    Ptr Gst.Caps.Caps ->                    -- caps : TInterface (Name {namespace = "Gst", name = "Caps"})
    Ptr Gst.Caps.Caps ->                    -- filter : TInterface (Name {namespace = "Gst", name = "Caps"})
    IO (Ptr Gst.Caps.Caps)

{- |
Returns caps that express /@caps@/ (or sink template caps if /@caps@/ == NULL)
restricted to channel\/rate combinations supported by downstream elements
(e.g. muxers).
-}
audioEncoderProxyGetcaps ::
    (B.CallStack.HasCallStack, MonadIO m, IsAudioEncoder a) =>
    a
    {- ^ /@enc@/: a 'GI.GstAudio.Objects.AudioEncoder.AudioEncoder' -}
    -> Maybe (Gst.Caps.Caps)
    {- ^ /@caps@/: initial caps -}
    -> Maybe (Gst.Caps.Caps)
    {- ^ /@filter@/: filter caps -}
    -> m Gst.Caps.Caps
    {- ^ __Returns:__ a 'GI.Gst.Structs.Caps.Caps' owned by caller -}
audioEncoderProxyGetcaps enc caps filter = liftIO $ do
    enc' <- unsafeManagedPtrCastPtr enc
    maybeCaps <- case caps of
        Nothing -> return nullPtr
        Just jCaps -> do
            jCaps' <- unsafeManagedPtrGetPtr jCaps
            return jCaps'
    maybeFilter <- case filter of
        Nothing -> return nullPtr
        Just jFilter -> do
            jFilter' <- unsafeManagedPtrGetPtr jFilter
            return jFilter'
    result <- gst_audio_encoder_proxy_getcaps enc' maybeCaps maybeFilter
    checkUnexpectedReturnNULL "audioEncoderProxyGetcaps" result
    result' <- (wrapBoxed Gst.Caps.Caps) result
    touchManagedPtr enc
    whenJust caps touchManagedPtr
    whenJust filter touchManagedPtr
    return result'

data AudioEncoderProxyGetcapsMethodInfo
instance (signature ~ (Maybe (Gst.Caps.Caps) -> Maybe (Gst.Caps.Caps) -> m Gst.Caps.Caps), MonadIO m, IsAudioEncoder a) => O.MethodInfo AudioEncoderProxyGetcapsMethodInfo a signature where
    overloadedMethod _ = audioEncoderProxyGetcaps

-- method AudioEncoder::set_allocation_caps
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "enc", argType = TInterface (Name {namespace = "GstAudio", name = "AudioEncoder"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstAudioEncoder", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "allocation_caps", argType = TInterface (Name {namespace = "Gst", name = "Caps"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a #GstCaps or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gst_audio_encoder_set_allocation_caps" gst_audio_encoder_set_allocation_caps :: 
    Ptr AudioEncoder ->                     -- enc : TInterface (Name {namespace = "GstAudio", name = "AudioEncoder"})
    Ptr Gst.Caps.Caps ->                    -- allocation_caps : TInterface (Name {namespace = "Gst", name = "Caps"})
    IO ()

{- |
Sets a caps in allocation query which are different from the set
pad\'s caps. Use this function before calling
'GI.GstAudio.Objects.AudioEncoder.audioEncoderNegotiate'. Setting to 'Nothing' the allocation
query will use the caps from the pad.

@since 1.10
-}
audioEncoderSetAllocationCaps ::
    (B.CallStack.HasCallStack, MonadIO m, IsAudioEncoder a) =>
    a
    {- ^ /@enc@/: a 'GI.GstAudio.Objects.AudioEncoder.AudioEncoder' -}
    -> Maybe (Gst.Caps.Caps)
    {- ^ /@allocationCaps@/: a 'GI.Gst.Structs.Caps.Caps' or 'Nothing' -}
    -> m ()
audioEncoderSetAllocationCaps enc allocationCaps = liftIO $ do
    enc' <- unsafeManagedPtrCastPtr enc
    maybeAllocationCaps <- case allocationCaps of
        Nothing -> return nullPtr
        Just jAllocationCaps -> do
            jAllocationCaps' <- unsafeManagedPtrGetPtr jAllocationCaps
            return jAllocationCaps'
    gst_audio_encoder_set_allocation_caps enc' maybeAllocationCaps
    touchManagedPtr enc
    whenJust allocationCaps touchManagedPtr
    return ()

data AudioEncoderSetAllocationCapsMethodInfo
instance (signature ~ (Maybe (Gst.Caps.Caps) -> m ()), MonadIO m, IsAudioEncoder a) => O.MethodInfo AudioEncoderSetAllocationCapsMethodInfo a signature where
    overloadedMethod _ = audioEncoderSetAllocationCaps

-- method AudioEncoder::set_drainable
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "enc", argType = TInterface (Name {namespace = "GstAudio", name = "AudioEncoder"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstAudioEncoder", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "enabled", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "new state", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gst_audio_encoder_set_drainable" gst_audio_encoder_set_drainable :: 
    Ptr AudioEncoder ->                     -- enc : TInterface (Name {namespace = "GstAudio", name = "AudioEncoder"})
    CInt ->                                 -- enabled : TBasicType TBoolean
    IO ()

{- |
Configures encoder drain handling.  If drainable, subclass might
be handed a NULL buffer to have it return any leftover encoded data.
Otherwise, it is not considered so capable and will only ever be passed
real data.

MT safe.
-}
audioEncoderSetDrainable ::
    (B.CallStack.HasCallStack, MonadIO m, IsAudioEncoder a) =>
    a
    {- ^ /@enc@/: a 'GI.GstAudio.Objects.AudioEncoder.AudioEncoder' -}
    -> Bool
    {- ^ /@enabled@/: new state -}
    -> m ()
audioEncoderSetDrainable enc enabled = liftIO $ do
    enc' <- unsafeManagedPtrCastPtr enc
    let enabled' = (fromIntegral . fromEnum) enabled
    gst_audio_encoder_set_drainable enc' enabled'
    touchManagedPtr enc
    return ()

data AudioEncoderSetDrainableMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsAudioEncoder a) => O.MethodInfo AudioEncoderSetDrainableMethodInfo a signature where
    overloadedMethod _ = audioEncoderSetDrainable

-- method AudioEncoder::set_frame_max
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "enc", argType = TInterface (Name {namespace = "GstAudio", name = "AudioEncoder"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstAudioEncoder", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "num", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "number of frames", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gst_audio_encoder_set_frame_max" gst_audio_encoder_set_frame_max :: 
    Ptr AudioEncoder ->                     -- enc : TInterface (Name {namespace = "GstAudio", name = "AudioEncoder"})
    Int32 ->                                -- num : TBasicType TInt
    IO ()

{- |
Sets max number of frames accepted at once (assumed minimally 1).
Requires /@frameSamplesMin@/ and /@frameSamplesMax@/ to be the equal.

Note: This value will be reset to 0 every time before
GstAudioEncoder::@/set_format()/@ is called.
-}
audioEncoderSetFrameMax ::
    (B.CallStack.HasCallStack, MonadIO m, IsAudioEncoder a) =>
    a
    {- ^ /@enc@/: a 'GI.GstAudio.Objects.AudioEncoder.AudioEncoder' -}
    -> Int32
    {- ^ /@num@/: number of frames -}
    -> m ()
audioEncoderSetFrameMax enc num = liftIO $ do
    enc' <- unsafeManagedPtrCastPtr enc
    gst_audio_encoder_set_frame_max enc' num
    touchManagedPtr enc
    return ()

data AudioEncoderSetFrameMaxMethodInfo
instance (signature ~ (Int32 -> m ()), MonadIO m, IsAudioEncoder a) => O.MethodInfo AudioEncoderSetFrameMaxMethodInfo a signature where
    overloadedMethod _ = audioEncoderSetFrameMax

-- method AudioEncoder::set_frame_samples_max
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "enc", argType = TInterface (Name {namespace = "GstAudio", name = "AudioEncoder"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstAudioEncoder", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "num", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "number of samples per frame", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gst_audio_encoder_set_frame_samples_max" gst_audio_encoder_set_frame_samples_max :: 
    Ptr AudioEncoder ->                     -- enc : TInterface (Name {namespace = "GstAudio", name = "AudioEncoder"})
    Int32 ->                                -- num : TBasicType TInt
    IO ()

{- |
Sets number of samples (per channel) subclass needs to be handed,
at most or will be handed all available if 0.

If an exact number of samples is required, 'GI.GstAudio.Objects.AudioEncoder.audioEncoderSetFrameSamplesMin'
must be called with the same number.

Note: This value will be reset to 0 every time before
GstAudioEncoder::@/set_format()/@ is called.
-}
audioEncoderSetFrameSamplesMax ::
    (B.CallStack.HasCallStack, MonadIO m, IsAudioEncoder a) =>
    a
    {- ^ /@enc@/: a 'GI.GstAudio.Objects.AudioEncoder.AudioEncoder' -}
    -> Int32
    {- ^ /@num@/: number of samples per frame -}
    -> m ()
audioEncoderSetFrameSamplesMax enc num = liftIO $ do
    enc' <- unsafeManagedPtrCastPtr enc
    gst_audio_encoder_set_frame_samples_max enc' num
    touchManagedPtr enc
    return ()

data AudioEncoderSetFrameSamplesMaxMethodInfo
instance (signature ~ (Int32 -> m ()), MonadIO m, IsAudioEncoder a) => O.MethodInfo AudioEncoderSetFrameSamplesMaxMethodInfo a signature where
    overloadedMethod _ = audioEncoderSetFrameSamplesMax

-- method AudioEncoder::set_frame_samples_min
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "enc", argType = TInterface (Name {namespace = "GstAudio", name = "AudioEncoder"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstAudioEncoder", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "num", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "number of samples per frame", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gst_audio_encoder_set_frame_samples_min" gst_audio_encoder_set_frame_samples_min :: 
    Ptr AudioEncoder ->                     -- enc : TInterface (Name {namespace = "GstAudio", name = "AudioEncoder"})
    Int32 ->                                -- num : TBasicType TInt
    IO ()

{- |
Sets number of samples (per channel) subclass needs to be handed,
at least or will be handed all available if 0.

If an exact number of samples is required, 'GI.GstAudio.Objects.AudioEncoder.audioEncoderSetFrameSamplesMax'
must be called with the same number.

Note: This value will be reset to 0 every time before
GstAudioEncoder::@/set_format()/@ is called.
-}
audioEncoderSetFrameSamplesMin ::
    (B.CallStack.HasCallStack, MonadIO m, IsAudioEncoder a) =>
    a
    {- ^ /@enc@/: a 'GI.GstAudio.Objects.AudioEncoder.AudioEncoder' -}
    -> Int32
    {- ^ /@num@/: number of samples per frame -}
    -> m ()
audioEncoderSetFrameSamplesMin enc num = liftIO $ do
    enc' <- unsafeManagedPtrCastPtr enc
    gst_audio_encoder_set_frame_samples_min enc' num
    touchManagedPtr enc
    return ()

data AudioEncoderSetFrameSamplesMinMethodInfo
instance (signature ~ (Int32 -> m ()), MonadIO m, IsAudioEncoder a) => O.MethodInfo AudioEncoderSetFrameSamplesMinMethodInfo a signature where
    overloadedMethod _ = audioEncoderSetFrameSamplesMin

-- method AudioEncoder::set_hard_min
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "enc", argType = TInterface (Name {namespace = "GstAudio", name = "AudioEncoder"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstAudioEncoder", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "enabled", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "new state", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gst_audio_encoder_set_hard_min" gst_audio_encoder_set_hard_min :: 
    Ptr AudioEncoder ->                     -- enc : TInterface (Name {namespace = "GstAudio", name = "AudioEncoder"})
    CInt ->                                 -- enabled : TBasicType TBoolean
    IO ()

{- |
Configures encoder hard minimum handling.  If enabled, subclass
will never be handed less samples than it configured, which otherwise
might occur near end-of-data handling.  Instead, the leftover samples
will simply be discarded.

MT safe.
-}
audioEncoderSetHardMin ::
    (B.CallStack.HasCallStack, MonadIO m, IsAudioEncoder a) =>
    a
    {- ^ /@enc@/: a 'GI.GstAudio.Objects.AudioEncoder.AudioEncoder' -}
    -> Bool
    {- ^ /@enabled@/: new state -}
    -> m ()
audioEncoderSetHardMin enc enabled = liftIO $ do
    enc' <- unsafeManagedPtrCastPtr enc
    let enabled' = (fromIntegral . fromEnum) enabled
    gst_audio_encoder_set_hard_min enc' enabled'
    touchManagedPtr enc
    return ()

data AudioEncoderSetHardMinMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsAudioEncoder a) => O.MethodInfo AudioEncoderSetHardMinMethodInfo a signature where
    overloadedMethod _ = audioEncoderSetHardMin

-- method AudioEncoder::set_hard_resync
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "enc", argType = TInterface (Name {namespace = "GstAudio", name = "AudioEncoder"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "enabled", 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 : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gst_audio_encoder_set_hard_resync" gst_audio_encoder_set_hard_resync :: 
    Ptr AudioEncoder ->                     -- enc : TInterface (Name {namespace = "GstAudio", name = "AudioEncoder"})
    CInt ->                                 -- enabled : TBasicType TBoolean
    IO ()

{- |
/No description available in the introspection data./
-}
audioEncoderSetHardResync ::
    (B.CallStack.HasCallStack, MonadIO m, IsAudioEncoder a) =>
    a
    -> Bool
    -> m ()
audioEncoderSetHardResync enc enabled = liftIO $ do
    enc' <- unsafeManagedPtrCastPtr enc
    let enabled' = (fromIntegral . fromEnum) enabled
    gst_audio_encoder_set_hard_resync enc' enabled'
    touchManagedPtr enc
    return ()

data AudioEncoderSetHardResyncMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsAudioEncoder a) => O.MethodInfo AudioEncoderSetHardResyncMethodInfo a signature where
    overloadedMethod _ = audioEncoderSetHardResync

-- method AudioEncoder::set_headers
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "enc", argType = TInterface (Name {namespace = "GstAudio", name = "AudioEncoder"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstAudioEncoder", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "headers", argType = TGList (TInterface (Name {namespace = "Gst", name = "Buffer"})), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a list of\n  #GstBuffer containing the codec header", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gst_audio_encoder_set_headers" gst_audio_encoder_set_headers :: 
    Ptr AudioEncoder ->                     -- enc : TInterface (Name {namespace = "GstAudio", name = "AudioEncoder"})
    Ptr (GList (Ptr Gst.Buffer.Buffer)) ->  -- headers : TGList (TInterface (Name {namespace = "Gst", name = "Buffer"}))
    IO ()

{- |
Set the codec headers to be sent downstream whenever requested.
-}
audioEncoderSetHeaders ::
    (B.CallStack.HasCallStack, MonadIO m, IsAudioEncoder a) =>
    a
    {- ^ /@enc@/: a 'GI.GstAudio.Objects.AudioEncoder.AudioEncoder' -}
    -> [Gst.Buffer.Buffer]
    {- ^ /@headers@/: a list of
  'GI.Gst.Structs.Buffer.Buffer' containing the codec header -}
    -> m ()
audioEncoderSetHeaders enc headers = liftIO $ do
    enc' <- unsafeManagedPtrCastPtr enc
    headers' <- mapM B.ManagedPtr.disownBoxed headers
    headers'' <- packGList headers'
    gst_audio_encoder_set_headers enc' headers''
    touchManagedPtr enc
    mapM_ touchManagedPtr headers
    return ()

data AudioEncoderSetHeadersMethodInfo
instance (signature ~ ([Gst.Buffer.Buffer] -> m ()), MonadIO m, IsAudioEncoder a) => O.MethodInfo AudioEncoderSetHeadersMethodInfo a signature where
    overloadedMethod _ = audioEncoderSetHeaders

-- method AudioEncoder::set_latency
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "enc", argType = TInterface (Name {namespace = "GstAudio", name = "AudioEncoder"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstAudioEncoder", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "min", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "minimum latency", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "max", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "maximum latency", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gst_audio_encoder_set_latency" gst_audio_encoder_set_latency :: 
    Ptr AudioEncoder ->                     -- enc : TInterface (Name {namespace = "GstAudio", name = "AudioEncoder"})
    Word64 ->                               -- min : TBasicType TUInt64
    Word64 ->                               -- max : TBasicType TUInt64
    IO ()

{- |
Sets encoder latency.
-}
audioEncoderSetLatency ::
    (B.CallStack.HasCallStack, MonadIO m, IsAudioEncoder a) =>
    a
    {- ^ /@enc@/: a 'GI.GstAudio.Objects.AudioEncoder.AudioEncoder' -}
    -> Word64
    {- ^ /@min@/: minimum latency -}
    -> Word64
    {- ^ /@max@/: maximum latency -}
    -> m ()
audioEncoderSetLatency enc min max = liftIO $ do
    enc' <- unsafeManagedPtrCastPtr enc
    gst_audio_encoder_set_latency enc' min max
    touchManagedPtr enc
    return ()

data AudioEncoderSetLatencyMethodInfo
instance (signature ~ (Word64 -> Word64 -> m ()), MonadIO m, IsAudioEncoder a) => O.MethodInfo AudioEncoderSetLatencyMethodInfo a signature where
    overloadedMethod _ = audioEncoderSetLatency

-- method AudioEncoder::set_lookahead
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "enc", argType = TInterface (Name {namespace = "GstAudio", name = "AudioEncoder"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstAudioEncoder", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "num", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "lookahead", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gst_audio_encoder_set_lookahead" gst_audio_encoder_set_lookahead :: 
    Ptr AudioEncoder ->                     -- enc : TInterface (Name {namespace = "GstAudio", name = "AudioEncoder"})
    Int32 ->                                -- num : TBasicType TInt
    IO ()

{- |
Sets encoder lookahead (in units of input rate samples)

Note: This value will be reset to 0 every time before
GstAudioEncoder::@/set_format()/@ is called.
-}
audioEncoderSetLookahead ::
    (B.CallStack.HasCallStack, MonadIO m, IsAudioEncoder a) =>
    a
    {- ^ /@enc@/: a 'GI.GstAudio.Objects.AudioEncoder.AudioEncoder' -}
    -> Int32
    {- ^ /@num@/: lookahead -}
    -> m ()
audioEncoderSetLookahead enc num = liftIO $ do
    enc' <- unsafeManagedPtrCastPtr enc
    gst_audio_encoder_set_lookahead enc' num
    touchManagedPtr enc
    return ()

data AudioEncoderSetLookaheadMethodInfo
instance (signature ~ (Int32 -> m ()), MonadIO m, IsAudioEncoder a) => O.MethodInfo AudioEncoderSetLookaheadMethodInfo a signature where
    overloadedMethod _ = audioEncoderSetLookahead

-- method AudioEncoder::set_mark_granule
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "enc", argType = TInterface (Name {namespace = "GstAudio", name = "AudioEncoder"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstAudioEncoder", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "enabled", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "new state", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gst_audio_encoder_set_mark_granule" gst_audio_encoder_set_mark_granule :: 
    Ptr AudioEncoder ->                     -- enc : TInterface (Name {namespace = "GstAudio", name = "AudioEncoder"})
    CInt ->                                 -- enabled : TBasicType TBoolean
    IO ()

{- |
Enable or disable encoder granule handling.

MT safe.
-}
audioEncoderSetMarkGranule ::
    (B.CallStack.HasCallStack, MonadIO m, IsAudioEncoder a) =>
    a
    {- ^ /@enc@/: a 'GI.GstAudio.Objects.AudioEncoder.AudioEncoder' -}
    -> Bool
    {- ^ /@enabled@/: new state -}
    -> m ()
audioEncoderSetMarkGranule enc enabled = liftIO $ do
    enc' <- unsafeManagedPtrCastPtr enc
    let enabled' = (fromIntegral . fromEnum) enabled
    gst_audio_encoder_set_mark_granule enc' enabled'
    touchManagedPtr enc
    return ()

data AudioEncoderSetMarkGranuleMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsAudioEncoder a) => O.MethodInfo AudioEncoderSetMarkGranuleMethodInfo a signature where
    overloadedMethod _ = audioEncoderSetMarkGranule

-- method AudioEncoder::set_output_format
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "enc", argType = TInterface (Name {namespace = "GstAudio", name = "AudioEncoder"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstAudioEncoder", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "caps", argType = TInterface (Name {namespace = "Gst", name = "Caps"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "#GstCaps", 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_audio_encoder_set_output_format" gst_audio_encoder_set_output_format :: 
    Ptr AudioEncoder ->                     -- enc : TInterface (Name {namespace = "GstAudio", name = "AudioEncoder"})
    Ptr Gst.Caps.Caps ->                    -- caps : TInterface (Name {namespace = "Gst", name = "Caps"})
    IO CInt

{- |
Configure output caps on the srcpad of /@enc@/.
-}
audioEncoderSetOutputFormat ::
    (B.CallStack.HasCallStack, MonadIO m, IsAudioEncoder a) =>
    a
    {- ^ /@enc@/: a 'GI.GstAudio.Objects.AudioEncoder.AudioEncoder' -}
    -> Gst.Caps.Caps
    {- ^ /@caps@/: 'GI.Gst.Structs.Caps.Caps' -}
    -> m Bool
    {- ^ __Returns:__ 'True' on success. -}
audioEncoderSetOutputFormat enc caps = liftIO $ do
    enc' <- unsafeManagedPtrCastPtr enc
    caps' <- unsafeManagedPtrGetPtr caps
    result <- gst_audio_encoder_set_output_format enc' caps'
    let result' = (/= 0) result
    touchManagedPtr enc
    touchManagedPtr caps
    return result'

data AudioEncoderSetOutputFormatMethodInfo
instance (signature ~ (Gst.Caps.Caps -> m Bool), MonadIO m, IsAudioEncoder a) => O.MethodInfo AudioEncoderSetOutputFormatMethodInfo a signature where
    overloadedMethod _ = audioEncoderSetOutputFormat

-- method AudioEncoder::set_perfect_timestamp
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "enc", argType = TInterface (Name {namespace = "GstAudio", name = "AudioEncoder"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstAudioEncoder", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "enabled", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "new state", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gst_audio_encoder_set_perfect_timestamp" gst_audio_encoder_set_perfect_timestamp :: 
    Ptr AudioEncoder ->                     -- enc : TInterface (Name {namespace = "GstAudio", name = "AudioEncoder"})
    CInt ->                                 -- enabled : TBasicType TBoolean
    IO ()

{- |
Enable or disable encoder perfect output timestamp preference.

MT safe.
-}
audioEncoderSetPerfectTimestamp ::
    (B.CallStack.HasCallStack, MonadIO m, IsAudioEncoder a) =>
    a
    {- ^ /@enc@/: a 'GI.GstAudio.Objects.AudioEncoder.AudioEncoder' -}
    -> Bool
    {- ^ /@enabled@/: new state -}
    -> m ()
audioEncoderSetPerfectTimestamp enc enabled = liftIO $ do
    enc' <- unsafeManagedPtrCastPtr enc
    let enabled' = (fromIntegral . fromEnum) enabled
    gst_audio_encoder_set_perfect_timestamp enc' enabled'
    touchManagedPtr enc
    return ()

data AudioEncoderSetPerfectTimestampMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsAudioEncoder a) => O.MethodInfo AudioEncoderSetPerfectTimestampMethodInfo a signature where
    overloadedMethod _ = audioEncoderSetPerfectTimestamp

-- method AudioEncoder::set_tolerance
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "enc", argType = TInterface (Name {namespace = "GstAudio", name = "AudioEncoder"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstAudioEncoder", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "tolerance", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "new tolerance", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gst_audio_encoder_set_tolerance" gst_audio_encoder_set_tolerance :: 
    Ptr AudioEncoder ->                     -- enc : TInterface (Name {namespace = "GstAudio", name = "AudioEncoder"})
    Word64 ->                               -- tolerance : TBasicType TUInt64
    IO ()

{- |
Configures encoder audio jitter tolerance threshold.

MT safe.
-}
audioEncoderSetTolerance ::
    (B.CallStack.HasCallStack, MonadIO m, IsAudioEncoder a) =>
    a
    {- ^ /@enc@/: a 'GI.GstAudio.Objects.AudioEncoder.AudioEncoder' -}
    -> Word64
    {- ^ /@tolerance@/: new tolerance -}
    -> m ()
audioEncoderSetTolerance enc tolerance = liftIO $ do
    enc' <- unsafeManagedPtrCastPtr enc
    gst_audio_encoder_set_tolerance enc' tolerance
    touchManagedPtr enc
    return ()

data AudioEncoderSetToleranceMethodInfo
instance (signature ~ (Word64 -> m ()), MonadIO m, IsAudioEncoder a) => O.MethodInfo AudioEncoderSetToleranceMethodInfo a signature where
    overloadedMethod _ = audioEncoderSetTolerance