Package apple.phase

Class PHASEDucker

  • All Implemented Interfaces:
    NSObject
    public class PHASEDucker
extends NSObject
    [@interface] PHASEDucker A PHASEDucker is used to describe ducking behavior across different groups. API-Since: 15.0

    • Constructor Detail

      • PHASEDucker

        protected PHASEDucker​(org.moe.natj.general.Pointer peer)

    • Method Detail

      • accessInstanceVariablesDirectly

        public static boolean accessInstanceVariablesDirectly()

      • activate

        public void activate()
        activate Activates the ducker

      • allocWithZone

        public static PHASEDucker allocWithZone​(org.moe.natj.general.ptr.VoidPtr zone)

      • attackCurve

        public long attackCurve()
        [@property] attackCurve The type of curve function to use during the attack phase of gain reduction.

      • attackTime

        public double attackTime()
        [@property] attackTime The time for the attenuation gain to ramp into effect. [@note] The attack time is scaled by unitsPerSecond internally, so can be provided at the client's native time scale.

      • automaticallyNotifiesObserversForKey

        public static boolean automaticallyNotifiesObserversForKey​(@NotNull
                                                           @NotNull java.lang.String key)

      • cancelPreviousPerformRequestsWithTarget

        public static void cancelPreviousPerformRequestsWithTarget​(@NotNull
                                                           @NotNull java.lang.Object aTarget)

      • cancelPreviousPerformRequestsWithTargetSelectorObject

        public static void cancelPreviousPerformRequestsWithTargetSelectorObject​(@NotNull
                                                                         @NotNull java.lang.Object aTarget,
                                                                         @NotNull
                                                                         @NotNull org.moe.natj.objc.SEL aSelector,
                                                                         @Nullable
                                                                         @Nullable java.lang.Object anArgument)

      • classFallbacksForKeyedArchiver

        @NotNull
public static @NotNull NSArray<java.lang.String> classFallbacksForKeyedArchiver()

      • classForKeyedUnarchiver

        @NotNull
public static @NotNull org.moe.natj.objc.Class classForKeyedUnarchiver()

      • deactivate

        public void deactivate()
        deactivate Deactivates the ducker

      • debugDescription_static

        public static java.lang.String debugDescription_static()

      • description_static

        public static java.lang.String description_static()

      • gain

        public double gain()
        [@property] gain Linear gain scalar. [@note] Values are clamped to the range [0, 1]. Default value is 1.

      • hash_static

        public static long hash_static()

      • identifier

        @NotNull
public @NotNull java.lang.String identifier()
        [@property] identifier The identifier that uniquely represents this ducker.

      • initWithEngineSourceGroupsTargetGroupsGainAttackTimeReleaseTimeAttackCurveReleaseCurve

        public PHASEDucker initWithEngineSourceGroupsTargetGroupsGainAttackTimeReleaseTimeAttackCurveReleaseCurve​(@NotNull
                                                                                                          @NotNull PHASEEngine engine,
                                                                                                          @NotNull
                                                                                                          @NotNull NSSet<? extends PHASEGroup> sourceGroups,
                                                                                                          @NotNull
                                                                                                          @NotNull NSSet<? extends PHASEGroup> targetGroups,
                                                                                                          double gain,
                                                                                                          double attackTime,
                                                                                                          double releaseTime,
                                                                                                          long attackCurve,
                                                                                                          long releaseCurve)
        initWithSourceGroups:targetGroups:attenuation:attackTime:releaseTime: Whenever a generator node from any source group plays, all the generator nodes in the target groups will be ducked by the given gain using the given attack and release times. [@note] The ducker is initialially inactive. The client must call activate() to make it active. Once a ducker is active, it will listen for generator nodes to start playback in source groups. Once triggered, it will duck its target groups. Deactivating a ducker will make it stop listening. Furthermore, it will enter the release phase if it has been previously triggered. Dealloc'ing a ducker will force the ducker into its release phase if it is actively ducking and remove it from the system when it finishes.
        Parameters:
        engine - The engine to register this ducker with.
        sourceGroups - The source groups that will trigger the ducker when a sound in one of the source groups starts playback.
        targetGroups - The target groups that will be ducked when a sound in one of the source groups triggers the ducker.
        gain - The linear gain scalar to apply when the ducker is engaged. 0 means full attenuation. 1 is no attenuation. Values are clamped to the range [0, 1].
        attackTime - The time for the attenuation gain to ramp into effect. This value is scaled by unitsPerSecond internally, so can be provided at the client's native time scale.
        releaseTime - The time for the ducked sounds to ramp back to their original level. This value is scaled by unitsPerSecond internally, so can be provided at the client's native time scale.
        attackCurve - The type of curve function to use during the attack phase of gain reduction.
        releaseCurve - The type of curve function to use during the release phase of gain reduction.

      • instanceMethodSignatureForSelector

        public static NSMethodSignature instanceMethodSignatureForSelector​(org.moe.natj.objc.SEL aSelector)

      • instancesRespondToSelector

        public static boolean instancesRespondToSelector​(org.moe.natj.objc.SEL aSelector)

      • isActive

        public boolean isActive()
        [@property] active YES if the ducker is active; otherwise, NO.

      • isSubclassOfClass

        public static boolean isSubclassOfClass​(org.moe.natj.objc.Class aClass)

      • keyPathsForValuesAffectingValueForKey

        @NotNull
public static @NotNull NSSet<java.lang.String> keyPathsForValuesAffectingValueForKey​(@NotNull
                                                                                     @NotNull java.lang.String key)

      • releaseCurve

        public long releaseCurve()
        [@property] releaseCurve The type of curve function to use during the release phase of gain reduction.

      • releaseTime

        public double releaseTime()
        [@property] releaseTime The time for the ducked sounds to ramp back to their original level. [@note] The release time is scaled by unitsPerSecond internally, so can be provided at the client's native time scale.

      • resolveClassMethod

        public static boolean resolveClassMethod​(org.moe.natj.objc.SEL sel)

      • resolveInstanceMethod

        public static boolean resolveInstanceMethod​(org.moe.natj.objc.SEL sel)

      • setVersion_static

        public static void setVersion_static​(long aVersion)

      • sourceGroups

        @NotNull
public @NotNull NSSet<? extends PHASEGroup> sourceGroups()
        [@property] sourceGroups The source groups that will trigger the ducker when a sound in one of the source groups starts playback.

      • superclass_static

        public static org.moe.natj.objc.Class superclass_static()

      • targetGroups

        @NotNull
public @NotNull NSSet<? extends PHASEGroup> targetGroups()
        [@property] targetGroups The target groups that will be ducked when a sound in one of the source groups triggers the ducker.

      • version_static

        public static long version_static()

      • useStoredAccessor

        @Deprecated
public static boolean useStoredAccessor()
        Deprecated.