Class ALC10

  • Direct Known Subclasses:
    ALC11

    public class ALC10
    extends java.lang.Object
    Native bindings to ALC 1.0 functionality.
    • Method Detail

      • nalcOpenDevice

        public static long nalcOpenDevice​(long deviceSpecifier)
        Unsafe version of: OpenDevice
      • alcOpenDevice

        public static long alcOpenDevice​(@Nullable
                                         java.nio.ByteBuffer deviceSpecifier)
        
        public static long alcOpenDevice​(@Nullable
                                         java.lang.CharSequence deviceSpecifier)
        
        Allows the application to connect to a device.

        If the function returns NULL, then no sound driver/device has been found. The argument is a null terminated string that requests a certain device or device configuration. If NULL is specified, the implementation will provide an implementation specific default.

        Parameters:
        deviceSpecifier - the requested device or device configuration
      • alcCloseDevice

        public static boolean alcCloseDevice​(long deviceHandle)
        Allows the application to disconnect from a device.

        The return code will be ALC_TRUE or ALC_FALSE, indicating success or failure. Failure will occur if all the device's contexts and buffers have not been destroyed. Once closed, the deviceHandle is invalid.

        Parameters:
        deviceHandle - the device to close
      • nalcCreateContext

        public static long nalcCreateContext​(long deviceHandle,
                                             long attrList)
        Unsafe version of: CreateContext
      • alcCreateContext

        public static long alcCreateContext​(long deviceHandle,
                                            @Nullable
                                            java.nio.IntBuffer attrList)
        Creates an AL context.
        Parameters:
        deviceHandle - a valid device
        attrList - null or a zero terminated list of integer pairs composed of valid ALC attribute tokens and requested values. One of:
        FREQUENCYREFRESHSYNCMONO_SOURCESSTEREO_SOURCES
      • alcMakeContextCurrent

        public static boolean alcMakeContextCurrent​(long context)
        Makes a context current with respect to OpenAL operation.

        The context parameter can be NULL or a valid context pointer. Using NULL results in no context being current, which is useful when shutting OpenAL down. The operation will apply to the device that the context was created for.

        For each OS process (usually this means for each application), only one context can be current at any given time. All AL commands apply to the current context. Commands that affect objects shared among contexts (e.g. buffers) have side effects on other contexts.

        Parameters:
        context - the context to make current
      • alcProcessContext

        public static void alcProcessContext​(long context)
        The current context is the only context accessible to state changes by AL commands (aside from state changes affecting shared objects). However, multiple contexts can be processed at the same time. To indicate that a context should be processed (i.e. that internal execution state such as the offset increments are to be performed), the application uses alcProcessContext.

        Repeated calls to alcProcessContext are legal, and do not affect a context that is already marked as processing. The default state of a context created by alcCreateContext is that it is processing.

        Parameters:
        context - the context to mark for processing
      • alcSuspendContext

        public static void alcSuspendContext​(long context)
        The application can suspend any context from processing (including the current one). To indicate that a context should be suspended from processing (i.e. that internal execution state such as offset increments are not to be changed), the application uses alcSuspendContext.

        Repeated calls to alcSuspendContext are legal, and do not affect a context that is already marked as suspended.

        Parameters:
        context - the context to mark as suspended
      • alcDestroyContext

        public static void alcDestroyContext​(long context)
        Destroys a context.

        The correct way to destroy a context is to first release it using alcMakeCurrent with a NULL context. Applications should not attempt to destroy a current context – doing so will not work and will result in an ALC_INVALID_OPERATION error. All sources within a context will automatically be deleted during context destruction.

        Parameters:
        context - the context to destroy
      • alcGetCurrentContext

        public static long alcGetCurrentContext()
        Queries for, and obtains a handle to, the current context for the application. If there is no current context, NULL is returned.
      • alcGetContextsDevice

        public static long alcGetContextsDevice​(long context)
        Queries for, and obtains a handle to, the device of a given context.
        Parameters:
        context - the context to query
      • nalcIsExtensionPresent

        public static boolean nalcIsExtensionPresent​(long deviceHandle,
                                                     long extName)
        Unsafe version of: IsExtensionPresent
      • alcIsExtensionPresent

        public static boolean alcIsExtensionPresent​(long deviceHandle,
                                                    java.nio.ByteBuffer extName)
        
        public static boolean alcIsExtensionPresent​(long deviceHandle,
                                                    java.lang.CharSequence extName)
        
        Verifies that a given extension is available for the current context and the device it is associated with.

        Invalid and unsupported string tokens return ALC_FALSE. A NULL deviceHandle is acceptable. extName is not case sensitive – the implementation will convert the name to all upper-case internally (and will express extension names in upper-case).

        Parameters:
        deviceHandle - the device to query
        extName - the extension name
      • nalcGetProcAddress

        public static long nalcGetProcAddress​(long deviceHandle,
                                              long funcName)
        Unsafe version of: GetProcAddress
      • alcGetProcAddress

        public static long alcGetProcAddress​(long deviceHandle,
                                             java.nio.ByteBuffer funcName)
        
        public static long alcGetProcAddress​(long deviceHandle,
                                             java.lang.CharSequence funcName)
        
        Retrieves extension entry points.

        The application is expected to verify the applicability of an extension or core function entry point before requesting it by name, by use of IsExtensionPresent.

        Entry points can be device specific, but are not context specific. Using a NULL device handle does not guarantee that the entry point is returned, even if available for one of the available devices.

        Parameters:
        deviceHandle - the device to query
        funcName - the function name
      • nalcGetEnumValue

        public static int nalcGetEnumValue​(long deviceHandle,
                                           long enumName)
        Unsafe version of: GetEnumValue
      • alcGetEnumValue

        public static int alcGetEnumValue​(long deviceHandle,
                                          java.nio.ByteBuffer enumName)
        
        public static int alcGetEnumValue​(long deviceHandle,
                                          java.lang.CharSequence enumName)
        
        Returns extension enum values.

        Enumeration/token values are device independent, but tokens defined for extensions might not be present for a given device. Using a NULL handle is legal, but only the tokens defined by the AL core are guaranteed. Availability of extension tokens depends on the ALC extension.

        Parameters:
        deviceHandle - the device to query
        enumName - the enum name
      • alcGetError

        public static int alcGetError​(long deviceHandle)
        Queries ALC errors.

        ALC uses the same conventions and mechanisms as AL for error handling. In particular, ALC does not use conventions derived from X11 (GLX) or Windows (WGL).

        Error conditions are specific to the device, and (like AL) a call to alcGetError resets the error state.

        Parameters:
        deviceHandle - the device to query
      • nalcGetString

        public static long nalcGetString​(long deviceHandle,
                                         int token)
        Unsafe version of: GetString
      • nalcGetIntegerv

        public static void nalcGetIntegerv​(long deviceHandle,
                                           int token,
                                           int size,
                                           long dest)
        Unsafe version of: GetIntegerv
        Parameters:
        size - the size of the dest buffer
      • alcCreateContext

        public static long alcCreateContext​(long deviceHandle,
                                            @Nullable
                                            int[] attrList)
        Array version of: CreateContext
      • alcGetIntegerv

        public static void alcGetIntegerv​(long deviceHandle,
                                          int token,
                                          int[] dest)
        Array version of: GetIntegerv