diff -uNr --exclude=autom4te.cache --exclude=.cvsignore hugs98-Mar2005-patched/fptools/libraries/OpenAL/LICENSE ghc-6.4.2/libraries/OpenAL/LICENSE --- hugs98-Mar2005-patched/fptools/libraries/OpenAL/LICENSE 2004-01-03 04:03:07.000000000 +0900 +++ ghc-6.4.2/libraries/OpenAL/LICENSE 2006-03-22 00:58:03.000000000 +0900 @@ -1,4 +1,4 @@ -Copyright (c) 2003-2004, Sven Panne +Copyright (c) 2003-2005, Sven Panne All rights reserved. Redistribution and use in source and binary forms, with or without diff -uNr --exclude=autom4te.cache --exclude=.cvsignore hugs98-Mar2005-patched/fptools/libraries/OpenAL/Makefile ghc-6.4.2/libraries/OpenAL/Makefile --- hugs98-Mar2005-patched/fptools/libraries/OpenAL/Makefile 2005-03-03 01:39:55.000000000 +0900 +++ ghc-6.4.2/libraries/OpenAL/Makefile 2006-03-22 00:58:03.000000000 +0900 @@ -4,6 +4,12 @@ include $(TOP)/mk/boilerplate.mk -include config.mk +ifneq "$(findstring clean, $(MAKECMDGOALS))" "" +# if we're cleaning, then config.mk might have been cleaned already +AL_BUILD_PACKAGE=yes +PACKAGE=OpenAL +endif + ifneq "$(AL_BUILD_PACKAGE)" "no" # ----------------------------------------------------------------------------- @@ -18,19 +24,17 @@ Sound \ Sound/OpenAL \ Sound/OpenAL/AL \ - Sound/OpenAL/ALC \ - Sound/OpenAL/ALUT + Sound/OpenAL/ALC PACKAGE_DEPS = base OpenGL SRC_HC_OPTS += -Wall -fffi -Iinclude '-\#include "HsOpenAL.h"' -cpp # WinDoze DLL hell +# NOTE: For some obscure/unknown reason, OpenAL uses ccall, even on WinDoze... +SRC_HC_OPTS += -DCALLCONV=ccall ifeq "$(TARGETPLATFORM)" "i386-unknown-mingw32" -SRC_HC_OPTS += -DCALLCONV=stdcall SRC_HC_OPTS := $(subst -mno-cygwin,,$(SRC_HC_OPTS)) -else -SRC_HC_OPTS += -DCALLCONV=ccall endif PACKAGE_CPP_OPTS += -DMAINTAINER=$(MAINTAINER) @@ -41,18 +45,14 @@ package.conf.inplace \ package.conf.installed \ -Sound/OpenAL/AL/BasicTypes.$(way_)o \ -Sound/OpenAL/AL/Format.$(way_)o \ -Sound/OpenAL/ALC/BasicTypes.$(way_)o \ -Sound/OpenAL/ALC/Errors.$(way_)o \ -Sound/OpenAL/ALC/Queries.$(way_)o : include/HsOpenALConfig.h +Sound/OpenAL/Config.$(way_)o \ +Sound/OpenAL/Constants.$(way_)o : include/HsOpenALConfig.h endif # ----------------------------------------------------------------------------- -DIST_CLEAN_FILES += OpenAL.buildinfo config.cache config.status -LATE_DIST_CLEAN_FILES += config.mk +DIST_CLEAN_FILES += OpenAL.buildinfo config.cache config.status config.mk extraclean:: $(RM) -rf autom4te.cache diff -uNr --exclude=autom4te.cache --exclude=.cvsignore hugs98-Mar2005-patched/fptools/libraries/OpenAL/OpenAL.buildinfo.in ghc-6.4.2/libraries/OpenAL/OpenAL.buildinfo.in --- hugs98-Mar2005-patched/fptools/libraries/OpenAL/OpenAL.buildinfo.in 2005-01-16 22:13:05.000000000 +0900 +++ ghc-6.4.2/libraries/OpenAL/OpenAL.buildinfo.in 2006-03-22 00:58:03.000000000 +0900 @@ -2,6 +2,7 @@ -- System-dependent values used by Distribution.Simple.defaultUserHooks -- buildable: @BUILD_PACKAGE_BOOL@ +ghc-options: -DCALLCONV=@CALLCONV@ cc-options: -DCALLCONV=@CALLCONV@ ld-options: @AL_LIBS@ frameworks: @AL_FRAMEWORKS@ diff -uNr --exclude=autom4te.cache --exclude=.cvsignore hugs98-Mar2005-patched/fptools/libraries/OpenAL/OpenAL.cabal ghc-6.4.2/libraries/OpenAL/OpenAL.cabal --- hugs98-Mar2005-patched/fptools/libraries/OpenAL/OpenAL.cabal 2005-02-11 10:55:55.000000000 +0900 +++ ghc-6.4.2/libraries/OpenAL/OpenAL.cabal 2006-03-22 00:58:03.000000000 +0900 @@ -1,5 +1,5 @@ name: OpenAL -version: 1.0 +version: 1.2 license: BSD3 license-file: LICENSE maintainer: Sven Panne @@ -10,27 +10,36 @@ exposed-modules: Sound.OpenAL, Sound.OpenAL.AL, + Sound.OpenAL.AL.ALboolean, + Sound.OpenAL.AL.Attenuation, Sound.OpenAL.AL.BasicTypes, Sound.OpenAL.AL.Buffer, + Sound.OpenAL.AL.BufferInternal, + Sound.OpenAL.AL.Doppler, + Sound.OpenAL.AL.Errors, + Sound.OpenAL.AL.Extensions, + Sound.OpenAL.AL.Format, Sound.OpenAL.AL.Listener, Sound.OpenAL.AL.Source, + Sound.OpenAL.AL.StringQueries, Sound.OpenAL.ALC, + Sound.OpenAL.ALC.BasicTypes, + Sound.OpenAL.ALC.Capture, Sound.OpenAL.ALC.Context, Sound.OpenAL.ALC.Device, Sound.OpenAL.ALC.Errors, - Sound.OpenAL.ALC.Extensions, - Sound.OpenAL.ALUT, - Sound.OpenAL.ALUT.Initialization, - Sound.OpenAL.ALUT.WAV + Sound.OpenAL.ALC.Extensions other-modules: - Sound.OpenAL.AL.ALboolean, - Sound.OpenAL.AL.Format, Sound.OpenAL.AL.PeekPoke, Sound.OpenAL.AL.QueryUtils, - Sound.OpenAL.ALC.BasicTypes, - Sound.OpenAL.ALC.Queries, - Sound.OpenAL.ALUT.Exception + Sound.OpenAL.AL.SourceState, + Sound.OpenAL.AL.String, + Sound.OpenAL.ALC.ALCboolean, + Sound.OpenAL.ALC.QueryUtils, + Sound.OpenAL.ALC.String, + Sound.OpenAL.Config, + Sound.OpenAL.Constants include-dirs: include includes: "HsOpenAL.h" build-depends: base, OpenGL -extensions: CPP +extensions: CPP, ForeignFunctionInterface diff -uNr --exclude=autom4te.cache --exclude=.cvsignore hugs98-Mar2005-patched/fptools/libraries/OpenAL/Sound/OpenAL/AL/ALboolean.hs ghc-6.4.2/libraries/OpenAL/Sound/OpenAL/AL/ALboolean.hs --- hugs98-Mar2005-patched/fptools/libraries/OpenAL/Sound/OpenAL/AL/ALboolean.hs 2004-01-03 04:03:08.000000000 +0900 +++ ghc-6.4.2/libraries/OpenAL/Sound/OpenAL/AL/ALboolean.hs 2006-03-22 00:58:03.000000000 +0900 @@ -2,7 +2,7 @@ -------------------------------------------------------------------------------- -- | -- Module : Sound.OpenAL.AL.ALboolean --- Copyright : (c) Sven Panne 2003-2004 +-- Copyright : (c) Sven Panne 2003-2005 -- License : BSD-style (see the file libraries/OpenAL/LICENSE) -- -- Maintainer : sven.panne@aedion.de @@ -14,16 +14,17 @@ -------------------------------------------------------------------------------- module Sound.OpenAL.AL.ALboolean ( - ALboolean, marshalALboolean, unmarshalALboolean + marshalALboolean, unmarshalALboolean ) where import Sound.OpenAL.AL.BasicTypes ( ALboolean ) +import Sound.OpenAL.Constants ( al_FALSE, al_TRUE ) -------------------------------------------------------------------------------- marshalALboolean :: Bool -> ALboolean -marshalALboolean False = 0 -marshalALboolean True = 1 +marshalALboolean False = al_FALSE +marshalALboolean True = al_TRUE unmarshalALboolean :: ALboolean -> Bool -unmarshalALboolean = (/= 0) +unmarshalALboolean = (/= al_FALSE) diff -uNr --exclude=autom4te.cache --exclude=.cvsignore hugs98-Mar2005-patched/fptools/libraries/OpenAL/Sound/OpenAL/AL/Attenuation.hs ghc-6.4.2/libraries/OpenAL/Sound/OpenAL/AL/Attenuation.hs --- hugs98-Mar2005-patched/fptools/libraries/OpenAL/Sound/OpenAL/AL/Attenuation.hs 1970-01-01 09:00:00.000000000 +0900 +++ ghc-6.4.2/libraries/OpenAL/Sound/OpenAL/AL/Attenuation.hs 2006-03-22 00:58:03.000000000 +0900 @@ -0,0 +1,211 @@ +-------------------------------------------------------------------------------- +-- | +-- Module : Sound.OpenAL.AL.Attenuation +-- Copyright : (c) Sven Panne 2005 +-- License : BSD-style (see the file libraries/OpenAL/LICENSE) +-- +-- Maintainer : sven.panne@aedion.de +-- Stability : provisional +-- Portability : portable +-- +-- This module corresponds to section 3.4 (Attenuation By Distance) of the +-- OpenAL Specification and Reference (version 1.1). +-- +-------------------------------------------------------------------------------- + +module Sound.OpenAL.AL.Attenuation ( + -- * Introduction + -- $Introduction + + -- * Handling the Distance Model + DistanceModel(..), distanceModel + + -- * Evaluation of Gain\/Attenuation Related State + -- $EvaluationOfGainAttenuationRelatedState + + -- * No Culling By Distance + -- $NoCullingByDistance +) where + +import Foreign.Marshal.Alloc ( alloca ) +import Foreign.Ptr ( Ptr ) +import Graphics.Rendering.OpenGL.GL.StateVar ( StateVar, makeStateVar ) +import Sound.OpenAL.AL.BasicTypes ( ALint, ALenum ) +import Sound.OpenAL.AL.PeekPoke ( peek1 ) +import Sound.OpenAL.AL.QueryUtils ( + GetPName(GetDistanceModel), marshalGetPName ) +import Sound.OpenAL.Constants ( + al_NONE, al_INVERSE_DISTANCE, al_INVERSE_DISTANCE_CLAMPED, + al_LINEAR_DISTANCE, al_LINEAR_DISTANCE_CLAMPED, al_EXPONENT_DISTANCE, + al_EXPONENT_DISTANCE_CLAMPED ) + +#ifdef __HADDOCK__ +import Sound.OpenAL.AL.Source ( + sourceGain, gainBounds, coneAngles, coneOuterGain, referenceDistance, + rolloffFactor, maxDistance ) +#endif + +-------------------------------------------------------------------------------- +-- $Introduction +-- Samples usually use the entire dynamic range of the chosen format\/encoding, +-- independent of their real world intensity. In other words, a jet engine and a +-- clockwork both will have samples with full amplitude. The application will +-- then have to adjust source gain accordingly to account for relative +-- differences. +-- +-- Source gain is then attenuated by distance. The effective attenuation of a +-- source depends on many factors, among which distance attenuation and source +-- and listener gain are only some of the contributing factors. Even if the +-- source and listener gain exceed 1 (amplification beyond the guaranteed +-- dynamic range), distance and other attenuation might ultimately limit the +-- overall gain to a value below 1. + +-------------------------------------------------------------------------------- +-- $EvaluationOfGainAttenuationRelatedState +-- While amplification\/attenuation commute (multiplication of scaling factors), +-- clamping operations do not. The order in which various gain related +-- operations are applied is: +-- +-- 1. Distance attenuation is calculated first, including minimum +-- ('referenceDistance') and maximum ('maxDistance') thresholds. +-- +-- 2. The result is then multiplied by source gain. +-- +-- 3. If the source is directional (the inner cone angle is less than the outer +-- cone angle, see 'coneAngles'), an angle-dependent attenuation is calculated +-- depending on 'coneOuterGain', and multiplied with the distance-dependent +-- attenuation. The resulting attenuation factor for the given angle and +-- distance between listener and source is multiplied with 'sourceGain'. +-- +-- 4. The effective gain computed this way is compared against 'gainBounds'. +-- +-- 5. The result is guaranteed to be clamped to 'gainBounds', and subsequently +-- multiplied by listener gain which serves as an overall volume control. +-- +-- The implementation is free to clamp listener gain if necessary due to +-- hardware or implementation constraints. + +-------------------------------------------------------------------------------- +-- $NoCullingByDistance +-- With the DS3D compatible inverse clamped distance model, OpenAL provides a +-- per-source 'maxDistance' attribute that can be used to define a distance +-- beyond which the source will not be further attenuated by distance. The DS3D +-- distance attenuation model and its clamping of volume is also extended by a +-- mechanism to cull (mute) sources from processing, based on distance. However, +-- the OpenAL does not support culling a source from processing based on a +-- distance threshold. +-- +-- At this time OpenAL is not meant to support culling at all. Culling based on +-- distance, or bounding volumes, or other criteria, is best left to the +-- application. For example, the application might employ sophisticated +-- techniques to determine whether sources are audible that are beyond the scope +-- of OpenAL. In particular, rule based culling inevitably introduces acoustic +-- artifacts. E.g. if the listener-source distance is nearly equal to the culling +-- threshold distance, but varies above and below, there will be popping +-- artifacts in the absence of hysteresis. + +-------------------------------------------------------------------------------- + +-- | OpenAL currently supports six modes of operation with respect to distance +-- attenuation, including one that is similar to the IASIG I3DL2 model. The +-- application chooses one of these models (or chooses to disable +-- distance-dependent attenuation) on a per-context basis. +-- +-- The distance used in the formulas for the \"clamped\" modes below is clamped +-- to be in the range between 'referenceDistance' and 'maxDistance': +-- +-- /clamped distance/ = +-- max('referenceDistance', min(/distance/, 'maxDistance')) +-- +-- The linear models are not physically realistic, but do allow full attenuation +-- of a source beyond a specified distance. The OpenAL implementation is still +-- free to apply any range clamping as necessary. +-- +-- With all the distance models, if the formula can not be evaluated then the +-- source will not be attenuated. For example, if a linear model is being used +-- with 'referenceDistance' equal to 'maxDistance', then the gain equation will +-- have a divide-by-zero error in it. In this case, there is no attenuation for +-- that source. + +data DistanceModel = + NoAttenuation + -- ^ Bypass all distance attenuation calculation for all sources. The + -- implementation is expected to optimize this situation. + | InverseDistance + -- ^ Inverse distance rolloff model, which is equivalent to the IASIG I3DL2 + -- model with the exception that 'referenceDistance' does not imply any + -- clamping. + -- + -- /gain/ = 'referenceDistance' \/ ('referenceDistance' + + -- 'rolloffFactor' \* (/distance/ - 'referenceDistance')) + -- + -- The 'referenceDistance' parameter used here is a per-source attribute + -- which is the distance at which the listener will experience gain + -- (unless the implementation had to clamp effective gain to the available + -- dynamic range). 'rolloffFactor' is per-source parameter the application + -- can use to increase or decrease the range of a source by decreasing or + -- increasing the attenuation, respectively. The default value is 1. The + -- implementation is free to optimize for a 'rolloffFactor' value of 0, + -- which indicates that the application does not wish any distance + -- attenuation on the respective source. + | InverseDistanceClamped + -- ^ Inverse Distance clamped model, which is essentially the inverse + -- distance rolloff model, extended to guarantee that for distances below + -- 'referenceDistance', gain is clamped. This mode is equivalent to the + -- IASIG I3DL2 distance model. + | LinearDistance + -- ^ Linear distance rolloff model, modeling a linear dropoff in gain as + -- distance increases between the source and listener. + -- + -- /gain/ = (1 - 'rolloffFactor' \* (/distance/ - 'referenceDistance') \/ + -- ('maxDistance' - 'referenceDistance')) + | LinearDistanceClamped + -- ^ Linear Distance clamped model, which is the linear model, extended to + -- guarantee that for distances below 'referenceDistance', gain is clamped. + | ExponentDistance + -- ^ Exponential distance rolloff model, modeling an exponential dropoff in + -- gain as distance increases between the source and listener. + -- + -- /gain/ = (/distance/ \/ 'referenceDistance') \*\* (- 'rolloffFactor') + | ExponentDistanceClamped + -- ^ Exponential Distance clamped model, which is the exponential model, + -- extended to guarantee that for distances below 'referenceDistance', + -- gain is clamped. + deriving ( Eq, Ord, Show ) + +marshalDistanceModel :: DistanceModel -> ALenum +marshalDistanceModel x = case x of + NoAttenuation -> al_NONE + InverseDistance -> al_INVERSE_DISTANCE + InverseDistanceClamped -> al_INVERSE_DISTANCE_CLAMPED + LinearDistance -> al_LINEAR_DISTANCE + LinearDistanceClamped -> al_LINEAR_DISTANCE_CLAMPED + ExponentDistance -> al_EXPONENT_DISTANCE + ExponentDistanceClamped -> al_EXPONENT_DISTANCE_CLAMPED + +unmarshalDistanceModel :: ALenum -> DistanceModel +unmarshalDistanceModel x + | x == al_NONE = NoAttenuation + | x == al_INVERSE_DISTANCE = InverseDistance + | x == al_INVERSE_DISTANCE_CLAMPED = InverseDistanceClamped + | x == al_LINEAR_DISTANCE = LinearDistance + | x == al_LINEAR_DISTANCE_CLAMPED = LinearDistanceClamped + | x == al_EXPONENT_DISTANCE = ExponentDistance + | x == al_EXPONENT_DISTANCE_CLAMPED = ExponentDistanceClamped + | otherwise = error ("unmarshalDistanceModel: illegal value " ++ show x) + +-- | Contains the current per-context distance model. + +distanceModel :: StateVar DistanceModel +distanceModel = + makeStateVar + (alloca $ \buf -> do + alGetIntegerv (marshalGetPName GetDistanceModel) buf + peek1 (unmarshalDistanceModel . fromIntegral) buf) + (alDistanceModel . marshalDistanceModel) + +foreign import CALLCONV unsafe "alGetIntegerv" + alGetIntegerv :: ALenum -> Ptr ALint -> IO () + +foreign import CALLCONV unsafe "alDistanceModel" + alDistanceModel :: ALenum -> IO () diff -uNr --exclude=autom4te.cache --exclude=.cvsignore hugs98-Mar2005-patched/fptools/libraries/OpenAL/Sound/OpenAL/AL/BasicTypes.hs ghc-6.4.2/libraries/OpenAL/Sound/OpenAL/AL/BasicTypes.hs --- hugs98-Mar2005-patched/fptools/libraries/OpenAL/Sound/OpenAL/AL/BasicTypes.hs 2004-01-03 04:03:08.000000000 +0900 +++ ghc-6.4.2/libraries/OpenAL/Sound/OpenAL/AL/BasicTypes.hs 2006-03-22 00:58:03.000000000 +0900 @@ -1,72 +1,49 @@ -------------------------------------------------------------------------------- -- | -- Module : Sound.OpenAL.AL.BasicTypes --- Copyright : (c) Sven Panne 2003-2004 +-- Copyright : (c) Sven Panne 2003-2005 -- License : BSD-style (see the file libraries/OpenAL/LICENSE) -- -- Maintainer : sven.panne@aedion.de -- Stability : provisional -- Portability : portable -- --- This module corresponds to section 2.1.1 (Primitive Types) of the OpenAL --- Specification and Reference (version 1.0). +-- This module corresponds to section 2.2 (Primitive Types) of the OpenAL +-- Specification and Reference (version 1.1). -- -------------------------------------------------------------------------------- module Sound.OpenAL.AL.BasicTypes ( - ALboolean, ALbyte, ALshort, ALint, ALubyte, ALushort, ALuint, ALsizei, - ALenum, ALbitfield, ALfloat, ALclampf, ALdouble, ALclampd -) where - --------------------------------------------------------------------------------- + -- * Primitive Types + -- $PrimitiveTypes -import Data.Int -import Data.Word + -- * Floating-Point Computation + -- $FloatingPointComputation --------------------------------------------------------------------------------- + ALboolean, ALchar, ALbyte, ALubyte, ALshort, ALushort, ALint, ALuint, + ALsizei, ALenum, ALfloat, ALdouble +) where -#include "HsOpenALConfig.h" +import Sound.OpenAL.Config -------------------------------------------------------------------------------- - --- | Boolean (min. 1 bit) -type ALboolean = HTYPE_ALBOOLEAN - --- | Signed 2\'s complement binary integer (min. 8 bits) -type ALbyte = HTYPE_ALBYTE - --- | Unsigned binary integer (min. 8 bits) -type ALubyte = HTYPE_ALUBYTE - --- | Signed 2\'s complement binary integer (min. 16 bits) -type ALshort = HTYPE_ALSHORT - --- | Unsigned binary integer (min. 16 bits) -type ALushort = HTYPE_ALUSHORT - --- | Signed 2\'s complement binary integer (min. 32 bits) -type ALint = HTYPE_ALINT - --- | Unsigned binary integer (min. 32 bits) -type ALuint = HTYPE_ALUINT - --- | Non-negatitve binary integer size (min. 32 bits) -type ALsizei = HTYPE_ALSIZEI - --- | Enumerated binary integer value (min. 32 bits) -type ALenum = HTYPE_ALENUM - --- | Bit field (min. 32 bits) -type ALbitfield = HTYPE_ALBITFIELD - --- | Floating-point value (min. 32 bits) -type ALfloat = HTYPE_ALFLOAT - --- | Floating-point value clamped to [0,1] (min. 32 bits) -type ALclampf = HTYPE_ALCLAMPF - --- | Floating-point value (min. 64 bits) -type ALdouble = HTYPE_ALDOUBLE - --- | Floating-point value clamped to [0,1] (min. 64 bits) -type ALclampd = HTYPE_ALCLAMPD +-- $PrimitiveTypes +-- As OpenAL is meant to allow for seamless integration with OpenGL code if +-- needed, the OpenAL library primitive (scalar) data types mimic the OpenGL +-- data types. Guaranteed minimum sizes are stated for OpenGL data types, but +-- the actual choice of C data type is left to the implementation. All +-- implementations on a given binary architecture, however, must use a common +-- definition of these data types. + +-------------------------------------------------------------------------------- +-- $FloatingPointComputation +-- Any representable floating-point value is legal as input to an OpenAL command +-- that requires floating point data. The result of providing a value that is +-- not a floating point number to such a command is unspecified, but must not +-- lead to OpenAL being interrupted or terminated. In IEEE arithmetic, for +-- example, providing a negative zero or a denormalized number to an OpenAL +-- command yields predictable results, while providing a NaN or infinity yields +-- unspecified results. Some calculations require division. In such cases +-- (including implied divisions required by vector normalizations), a division +-- by zero produces an unspecified result but must not lead to OpenAL +-- interruption or termination. diff -uNr --exclude=autom4te.cache --exclude=.cvsignore hugs98-Mar2005-patched/fptools/libraries/OpenAL/Sound/OpenAL/AL/Buffer.hs ghc-6.4.2/libraries/OpenAL/Sound/OpenAL/AL/Buffer.hs --- hugs98-Mar2005-patched/fptools/libraries/OpenAL/Sound/OpenAL/AL/Buffer.hs 2004-05-12 04:31:01.000000000 +0900 +++ ghc-6.4.2/libraries/OpenAL/Sound/OpenAL/AL/Buffer.hs 2006-03-22 00:58:03.000000000 +0900 @@ -1,34 +1,101 @@ -------------------------------------------------------------------------------- -- | -- Module : Sound.OpenAL.AL.Buffer --- Copyright : (c) Sven Panne 2003-2004 +-- Copyright : (c) Sven Panne 2003-2005 -- License : BSD-style (see the file libraries/OpenAL/LICENSE) -- -- Maintainer : sven.panne@aedion.de -- Stability : provisional -- Portability : portable -- +-- This module corresponds to chapter 6 (Buffers) of the OpenAL Specification +-- and Reference (version 1.1). +-- +-- A buffer encapsulates OpenAL state related to storing sample data. The +-- application can request and release buffer objects, and fill them with +-- data. Data can be supplied compressed and encoded as long as the format is +-- supported. Buffers can, internally, contain waveform data as uncompressed or +-- compressed samples. +-- +-- Unlike source (see "Sound.OpenAL.AL.Source") and listener (see +-- "Sound.OpenAL.AL.Listener") objects, buffer objects can be shared among AL +-- contexts. Buffers are referenced by sources. A single buffer can be referred +-- to by multiple sources. This separation allows drivers and hardware to +-- optimize storage and processing where applicable. +-- +-- The simplest supported format for buffer data is PCM. PCM data is assumed to +-- use the processor\'s native byte order. Other formats use the byte order +-- native to that format. +-- +-- At this time, buffer states are defined for purposes of discussion. The +-- states described in this section are not exposed through the API (can not be +-- queried, or be set directly), and the state description used in the +-- implementation might differ from this. +-- +-- A buffer is considered to be in one of the following states, with respect to +-- all sources: +-- +-- [/unused/] The buffer is not included in any queue for any source. In +-- particular, the buffer is neither pending nor current for any source. The +-- buffer name can be deleted at this time. +-- +-- [/processed/] The buffer is listed in the queue of at least one source, but +-- is neither pending nor current for any source. The buffer can be deleted as +-- soon as it has been unqueued for all sources it is queued with. +-- +-- [/pending/] There is at least one source for which the buffer has been queued, +-- for which the buffer data has not yet been dereferenced. The buffer can only +-- be unqueued for those sources that have dereferenced the data in the buffer +-- in its entirety, and cannot be deleted or changed. +-- +-- The buffer state is dependent on the state of all sources that is has been +-- queued for. A single queue occurrence of a buffer propagates the buffer state +-- (over all sources) from /unused/ to /processed/ or higher. Sources that are +-- in the 'Stopped' or 'Initial' states still have queue entries that cause +-- buffers to be /processed/. +-- +-- A single queue entry with a single source for which the buffer is not yet +-- /processed/ propagates the buffer\'s queuing state to /pending/. +-- +-- Buffers that are /processed/ for a given source can be unqueued from that +-- source\'s queue. Buffers that have been unqueued from all sources are +-- /unused/. Buffers that are /unused/ can be deleted, or changed by writing +-- 'bufferData'. +-- -------------------------------------------------------------------------------- module Sound.OpenAL.AL.Buffer ( - Format(..), BufferSize, Frequency, BufferData(..), - Buffer, bufferData + Buffer, MemoryRegion(..), Format(..), BufferData(..), bufferData ) where -import Control.Monad ( liftM ) import Foreign.Marshal.Alloc ( alloca ) -import Foreign.Marshal.Array ( withArrayLen, peekArray, allocaArray ) import Foreign.Ptr ( Ptr, nullPtr ) -import Foreign.Storable ( Storable(peek) ) -import Graphics.Rendering.OpenGL.GL.BufferObjects ( ObjectName(..) ) import Graphics.Rendering.OpenGL.GL.StateVar ( StateVar, makeStateVar ) -import Sound.OpenAL.AL.BasicTypes +import Sound.OpenAL.AL.BufferInternal ( Buffer ) +import Sound.OpenAL.AL.BasicTypes ( ALint, ALsizei, ALenum ) import Sound.OpenAL.AL.Format ( Format(..), marshalFormat ) -import Sound.OpenAL.AL.ALboolean ( unmarshalALboolean ) +import Sound.OpenAL.AL.PeekPoke ( peek1 ) +import Sound.OpenAL.ALC.Context ( Frequency ) +import Sound.OpenAL.Constants ( al_FREQUENCY, al_SIZE, al_BITS, al_CHANNELS ) + +#ifdef __HADDOCK__ +import Sound.OpenAL.AL.SourceState ( SourceState(..) ) +import Sound.OpenAL.AL.Errors ( ALErrorCategory(..) ) +#endif -------------------------------------------------------------------------------- -data BufferData a = BufferData Format (Ptr a) BufferSize Frequency +data MemoryRegion a = MemoryRegion (Ptr a) ALsizei +#ifdef __HADDOCK__ +-- Help Haddock a bit, because it doesn't do any instance inference. +instance Eq (MemoryRegion a) +instance Ord (MemoryRegion a) +instance Show (MemoryRegion a) +#else + deriving ( Eq, Ord, Show ) +#endif + +data BufferData a = BufferData (MemoryRegion a) Format Frequency #ifdef __HADDOCK__ -- Help Haddock a bit, because it doesn't do any instance inference. instance Eq (BufferData a) @@ -38,37 +105,25 @@ deriving ( Eq, Ord, Show ) #endif -type BufferSize = ALsizei - -type Frequency = ALsizei -- or Float??? - -------------------------------------------------------------------------------- -newtype Buffer = Buffer { bufferID :: ALuint } - deriving ( Eq, Ord, Show ) - -instance ObjectName Buffer where - genObjectNames n = - allocaArray n $ \buf -> do - alGenBuffers (fromIntegral n) buf - liftM (map Buffer) $ peekArray n buf - - deleteObjectNames buffers = - withArrayLen (map bufferID buffers) $ - alDeleteBuffers . fromIntegral - - isObjectName = liftM unmarshalALboolean . alIsBuffer . bufferID - -foreign import CALLCONV unsafe "alGenBuffers" - alGenBuffers :: ALsizei -> Ptr ALuint -> IO () - -foreign import CALLCONV unsafe "alDeleteBuffers" - alDeleteBuffers :: ALsizei -> Ptr ALuint -> IO () - -foreign import CALLCONV unsafe "alIsBuffer" - alIsBuffer :: ALuint -> IO ALboolean - --------------------------------------------------------------------------------- +-- | A special case of buffer state is the actual sound sample data stored in +-- association with the buffer. Applications can specify sample data using +-- 'bufferData'. +-- +-- The data specified is copied to an internal software, or if possible, +-- hardware buffer. The implementation is free to apply decompression, +-- conversion, resampling, and filtering as needed. The internal format of the +-- buffer is not exposed to the application, and not accessible. +-- +-- Buffers containing audio data with more than one channel will be played +-- without 3D spatialization features, these formats are normally used for +-- background music. Applications should always check for an error condition +-- after attempting to specify buffer data in case an implementation has to +-- generate an 'ALOutOfMemory' or a conversion related 'ALInvalidValue' error. +-- The application is free to reuse the memory specified by the data pointer +-- once 'bufferData' is set. The implementation has to dereference, e.g. copy, +-- the data while accessing 'bufferData' execution. bufferData :: Buffer -> StateVar (BufferData a) bufferData buffer = makeStateVar (getBufferData buffer) (setBufferData buffer) @@ -80,11 +135,11 @@ raw <- return nullPtr -- ToDo: AL_DATA query missing!!! size <- getBufferi buffer Size frequency <- getBufferi buffer Frequency - return $ BufferData (makeFormat channels bits) raw size frequency + return $ BufferData (MemoryRegion raw size) (makeFormat channels bits) frequency setBufferData :: Buffer -> BufferData a -> IO () -setBufferData buffer (BufferData format raw size frequency) = - alBufferData buffer (marshalFormat format) raw size frequency +setBufferData buffer (BufferData (MemoryRegion raw size) format frequency) = + alBufferData buffer (marshalFormat format) raw size (round frequency) foreign import CALLCONV unsafe "alBufferData" alBufferData :: Buffer -> ALenum -> Ptr a -> ALsizei -> ALsizei -> IO () @@ -95,10 +150,8 @@ makeFormat :: ALint -> ALint -> Format makeFormat 1 8 = Mono8 makeFormat 2 8 = Stereo8 -makeFormat 4 8 = Quad8 makeFormat 1 16 = Mono16 makeFormat 2 16 = Stereo16 -makeFormat 4 16 = Quad16 makeFormat channels bits = error ("makeFormat: illegal values " ++ show (channels, bits)) @@ -106,17 +159,16 @@ data BufferQuery = Frequency + | Size | Bits | Channels - | Size - -- AL_DATA ??? marshalBufferQuery :: BufferQuery -> ALenum marshalBufferQuery x = case x of - Frequency -> 0x2001 - Bits -> 0x2002 - Channels -> 0x2003 - Size -> 0x2004 + Frequency -> al_FREQUENCY + Size -> al_SIZE + Bits -> al_BITS + Channels -> al_CHANNELS -------------------------------------------------------------------------------- @@ -124,7 +176,7 @@ getBufferi buffer query = alloca $ \buf -> do alGetBufferi buffer (marshalBufferQuery query) buf - liftM fromIntegral $ peek buf + peek1 fromIntegral buf foreign import CALLCONV unsafe "alGetBufferi" alGetBufferi :: Buffer -> ALenum -> Ptr ALint -> IO () diff -uNr --exclude=autom4te.cache --exclude=.cvsignore hugs98-Mar2005-patched/fptools/libraries/OpenAL/Sound/OpenAL/AL/BufferInternal.hs ghc-6.4.2/libraries/OpenAL/Sound/OpenAL/AL/BufferInternal.hs --- hugs98-Mar2005-patched/fptools/libraries/OpenAL/Sound/OpenAL/AL/BufferInternal.hs 1970-01-01 09:00:00.000000000 +0900 +++ ghc-6.4.2/libraries/OpenAL/Sound/OpenAL/AL/BufferInternal.hs 2006-03-22 00:58:03.000000000 +0900 @@ -0,0 +1,75 @@ +-- #hide +-------------------------------------------------------------------------------- +-- | +-- Module : Sound.OpenAL.AL.BufferInternal +-- Copyright : (c) Sven Panne 2003-2005 +-- License : BSD-style (see the file libraries/OpenAL/LICENSE) +-- +-- Maintainer : sven.panne@aedion.de +-- Stability : provisional +-- Portability : portable +-- +-- This is a purely internal module for (un-)marshaling Buffer. +-- +-------------------------------------------------------------------------------- + +module Sound.OpenAL.AL.BufferInternal ( + Buffer, marshalBuffer, unmarshalBuffer +) where + +import Foreign.Marshal.Array ( withArrayLen, peekArray, allocaArray ) +import Foreign.Ptr ( Ptr, castPtr ) +import Foreign.Storable ( Storable(..) ) +import Graphics.Rendering.OpenGL.GL.BufferObjects ( ObjectName(..) ) +import Sound.OpenAL.AL.ALboolean ( unmarshalALboolean ) +import Sound.OpenAL.AL.BasicTypes ( ALboolean, ALuint, ALsizei ) +import Sound.OpenAL.AL.PeekPoke ( peek1, poke1 ) + +-------------------------------------------------------------------------------- + +-- | The abstract buffer type. + +newtype Buffer = Buffer { bufferID :: ALuint } + deriving ( Eq, Ord, Show ) + +-- | A dummy buffer. + +nullBuffer :: Buffer +nullBuffer = Buffer 0 + +marshalBuffer :: Maybe Buffer -> ALuint +marshalBuffer = bufferID . maybe nullBuffer id + +unmarshalBuffer :: ALuint -> Maybe Buffer +unmarshalBuffer b = + if b == bufferID nullBuffer then Nothing else Just (Buffer b) + +instance Storable Buffer where + sizeOf ~(Buffer b) = sizeOf b + alignment ~(Buffer b) = alignment b + peek = peek1 Buffer . castPtr + poke ptr (Buffer b) = poke1 (castPtr ptr) b + +-------------------------------------------------------------------------------- +-- This should really be in Sound.OpenAL.AL.Buffer, but we have it here to +-- avoid an orphan module. + +instance ObjectName Buffer where + genObjectNames n = + allocaArray n $ \buf -> do + alGenBuffers (fromIntegral n) buf + peekArray n buf + + deleteObjectNames buffers = + withArrayLen buffers $ alDeleteBuffers . fromIntegral + + isObjectName = fmap unmarshalALboolean . alIsBuffer + +foreign import CALLCONV unsafe "alGenBuffers" + alGenBuffers :: ALsizei -> Ptr Buffer -> IO () + +foreign import CALLCONV unsafe "alDeleteBuffers" + alDeleteBuffers :: ALsizei -> Ptr Buffer -> IO () + +foreign import CALLCONV unsafe "alIsBuffer" + alIsBuffer :: Buffer -> IO ALboolean diff -uNr --exclude=autom4te.cache --exclude=.cvsignore hugs98-Mar2005-patched/fptools/libraries/OpenAL/Sound/OpenAL/AL/Doppler.hs ghc-6.4.2/libraries/OpenAL/Sound/OpenAL/AL/Doppler.hs --- hugs98-Mar2005-patched/fptools/libraries/OpenAL/Sound/OpenAL/AL/Doppler.hs 1970-01-01 09:00:00.000000000 +0900 +++ ghc-6.4.2/libraries/OpenAL/Sound/OpenAL/AL/Doppler.hs 2006-03-22 00:58:03.000000000 +0900 @@ -0,0 +1,92 @@ +-------------------------------------------------------------------------------- +-- | +-- Module : Sound.OpenAL.AL.Doppler +-- Copyright : (c) Sven Panne 2005 +-- License : BSD-style (see the file libraries/OpenAL/LICENSE) +-- +-- Maintainer : sven.panne@aedion.de +-- Stability : provisional +-- Portability : portable +-- +-- This module corresponds to section 3.5.2. (Velocity Dependent Doppler Effect) +-- of the OpenAL Specification and Reference (version 1.1). +-- +-------------------------------------------------------------------------------- + +module Sound.OpenAL.AL.Doppler ( + -- * Introduction + -- $Introduction + dopplerFactor, speedOfSound +) where + +import Foreign.Ptr ( FunPtr ) +import Graphics.Rendering.OpenGL.GL.StateVar ( + HasGetter(get), StateVar, makeStateVar ) +import Sound.OpenAL.AL.BasicTypes ( ALenum, ALfloat ) +import Sound.OpenAL.AL.Extensions ( alProcAddress ) +import Sound.OpenAL.AL.QueryUtils ( + GetPName(GetDopplerFactor,GetSpeedOfSound), marshalGetPName ) + +#ifdef __HADDOCK__ +import Sound.OpenAL.AL.Errors ( ALError(ALInvalidValue) ) +#endif + +-------------------------------------------------------------------------------- + +-- | 'dopplerFactor' is a simple scaling of source and listener velocities to +-- exaggerate or deemphasize the Doppler (pitch) shift resulting from the +-- calculation. Setting 'dopplerFactor' to a negative value will result in an +-- 'ALInvalidValue' error, the command is then ignored. The default value is 1. +-- The implementation is free to optimize the case of 'dopplerFactor' containing +-- zero, as this effectively disables the effect. + +dopplerFactor :: StateVar ALfloat +dopplerFactor = makeDopplerVar GetDopplerFactor "alDopplerFactor" + +-------------------------------------------------------------------------------- + +-- | 'speedOfSound' allows the application to change the reference (propagation) +-- speed used in the Doppler calculation. The source and listener velocities +-- should be expressed in the same units as the speed of sound. Setting +-- 'speedOfSound' to a negative or zero value will result in an 'ALInvalidValue' +-- error, the command is ignored then. The default value is 343.3 (appropriate +-- for velocity units of meters and air as the propagation medium). + +speedOfSound :: StateVar ALfloat +speedOfSound = makeDopplerVar GetSpeedOfSound "alSpeedOfSound" + +-------------------------------------------------------------------------------- + +makeDopplerVar :: GetPName -> String -> StateVar ALfloat +makeDopplerVar p apiEntryName = + makeStateVar + (alGetFloat (marshalGetPName p)) + (\value -> do + -- ToDo: Should we check alcVersion or alIsExtensionPresent here? + funPtr <- get (alProcAddress apiEntryName) + invokeWithFloat funPtr value) + +foreign import CALLCONV unsafe "alGetFloat" + alGetFloat :: ALenum -> IO ALfloat + +type Invoker a = FunPtr a -> a + +foreign import CALLCONV unsafe "dynamic" + invokeWithFloat :: Invoker (ALfloat -> IO ()) + +-------------------------------------------------------------------------------- +-- $Introduction +-- The Doppler Effect depends on the velocities of source and listener relative +-- to the medium, and the propagation speed of sound in that medium. The +-- application might want to emphasize or de-emphasize the Doppler Effect as +-- physically accurate calculation might not give the desired results. +-- The amount of frequency shift (pitch change) is proportional to the speed of +-- listener and source along their line of sight. +-- +-- The Doppler Effect as implemented by OpenAL is described in detail in section +-- 3.5.2 of the OpenAL 1.1 specification. Note that effects of the medium (air, +-- water) moving with respect to listener and source are ignored. There are two +-- API calls global to the current context that provide control of the Doppler +-- factor and the speed of sound. Distance and velocity units are completely +-- independent of one another (so you could use different units for each if +-- desired). diff -uNr --exclude=autom4te.cache --exclude=.cvsignore hugs98-Mar2005-patched/fptools/libraries/OpenAL/Sound/OpenAL/AL/Errors.hs ghc-6.4.2/libraries/OpenAL/Sound/OpenAL/AL/Errors.hs --- hugs98-Mar2005-patched/fptools/libraries/OpenAL/Sound/OpenAL/AL/Errors.hs 1970-01-01 09:00:00.000000000 +0900 +++ ghc-6.4.2/libraries/OpenAL/Sound/OpenAL/AL/Errors.hs 2006-03-22 00:58:03.000000000 +0900 @@ -0,0 +1,88 @@ +-------------------------------------------------------------------------------- +-- | +-- Module : Sound.OpenAL.AL.Errors +-- Copyright : (c) Sven Panne 2003-2005 +-- License : BSD-style (see the file libraries/OpenAL/LICENSE) +-- +-- Maintainer : sven.panne@aedion.de +-- Stability : provisional +-- Portability : portable +-- +-- This module corresponds to section 2.7 (AL Errors) of the OpenAL +-- Specification and Reference (version 1.1). +-- +-------------------------------------------------------------------------------- + +module Sound.OpenAL.AL.Errors ( + ALError(..), ALErrorCategory(..), alErrors +) where + +import Graphics.Rendering.OpenGL.GL.StateVar ( + GettableStateVar, makeGettableStateVar ) +import Sound.OpenAL.AL.BasicTypes ( ALenum ) +import Sound.OpenAL.Constants ( + al_NO_ERROR, al_INVALID_NAME, al_INVALID_ENUM, al_INVALID_VALUE, + al_INVALID_OPERATION, al_OUT_OF_MEMORY ) +import Sound.OpenAL.AL.QueryUtils ( StringName(..), getString ) + +-------------------------------------------------------------------------------- + +-- | AL errors consist of a general error category and a description of what +-- went wrong. + +data ALError = ALError ALErrorCategory String + deriving ( Eq, Ord, Show ) + +-------------------------------------------------------------------------------- + +-- | General AL error categories. + +data ALErrorCategory = + ALInvalidEnum + | ALInvalidValue + | ALInvalidOperation + | ALInvalidName + | ALOutOfMemory + deriving ( Eq, Ord, Show ) + +unmarshalALErrorCategory :: ALenum -> ALErrorCategory +unmarshalALErrorCategory x + | x == al_INVALID_ENUM = ALInvalidEnum + | x == al_INVALID_VALUE = ALInvalidValue + | x == al_INVALID_OPERATION = ALInvalidOperation + | x == al_INVALID_NAME = ALInvalidName + | x == al_OUT_OF_MEMORY = ALOutOfMemory + | otherwise = error ("unmarshalALErrorCategory: illegal value " ++ show x) + +-------------------------------------------------------------------------------- + +-- | OpenAL detects only a subset of those conditions that could be considered +-- errors. This is because in many cases error checking would adversely impact +-- the performance of an error-free program. The state variable 'alErrors' is +-- used to obtain error information. When an error is detected by AL, a flag is +-- set and the error code is recorded. Further errors, if they occur, do not +-- affect this recorded code. When 'alErrors' is read, the error is returned and +-- the flag is cleared, so that a further error will again record its code. If +-- reading 'alErrors' returns @\[\]@ then there has been no detectable error +-- since the last time 'alErrors' (or since the AL was initialized). +-- +-- When an error flag is set, results of AL operations are undefined only if +-- 'ALOutOfMemory' has occurred. In other cases, the command generating the +-- error is ignored so that it has no effect on AL state or output buffer +-- contents. If the error generating command returns a value, it returns zero. +-- If the generating command modifies values through a pointer argument, no +-- change is made to these values. These error semantics apply only to AL +-- errors, not to system errors such as memory access errors. + +alErrors :: GettableStateVar [ALError] +alErrors = + makeGettableStateVar $ do + c <- alGetError + if c == al_NO_ERROR + then return [] + else do + s <- getString (ALErrorCategory c) + return [ ALError (unmarshalALErrorCategory c) s ] + +foreign import CALLCONV unsafe "alGetError" + alGetError :: IO ALenum diff -uNr --exclude=autom4te.cache --exclude=.cvsignore hugs98-Mar2005-patched/fptools/libraries/OpenAL/Sound/OpenAL/AL/Extensions.hs ghc-6.4.2/libraries/OpenAL/Sound/OpenAL/AL/Extensions.hs --- hugs98-Mar2005-patched/fptools/libraries/OpenAL/Sound/OpenAL/AL/Extensions.hs 1970-01-01 09:00:00.000000000 +0900 +++ ghc-6.4.2/libraries/OpenAL/Sound/OpenAL/AL/Extensions.hs 2006-03-22 00:58:03.000000000 +0900 @@ -0,0 +1,102 @@ +-------------------------------------------------------------------------------- +-- | +-- Module : Sound.OpenAL.AL.Extensions +-- Copyright : (c) Sven Panne 2003-2005 +-- License : BSD-style (see the file libraries/OpenAL/LICENSE) +-- +-- Maintainer : sven.panne@aedion.de +-- Stability : provisional +-- Portability : portable +-- +-- This module corresponds to section 3.1.2 (String Queries) and chapter 7 +-- (Appendix: Extensions) of the OpenAL Specification and Reference (version +-- 1.1). +-- +-------------------------------------------------------------------------------- + +module Sound.OpenAL.AL.Extensions ( + alExtensions, alIsExtensionPresent, alProcAddress, alEnumValue, alVersion +) where + +import Foreign.Ptr ( Ptr, FunPtr ) +import Graphics.Rendering.OpenGL.GL.StateVar ( + GettableStateVar, makeGettableStateVar ) +import Sound.OpenAL.AL.ALboolean ( unmarshalALboolean ) +import Sound.OpenAL.AL.BasicTypes ( ALboolean, ALchar, ALenum ) +import Sound.OpenAL.AL.QueryUtils ( StringName(..), getString ) +import Sound.OpenAL.AL.String ( withALString ) + +#ifdef __HADDOCK__ +import Foreign.Ptr ( nullFunPtr ) +#endif + +-------------------------------------------------------------------------------- + +-- | Contains the list of available extensions. + +alExtensions :: GettableStateVar [String] +alExtensions = makeGettableStateVar (fmap words $ getString Extensions) + +-------------------------------------------------------------------------------- + +-- | Contains a version string in the format @\"/\/./\/ /\/\"@. + +alVersion :: GettableStateVar String +alVersion = makeGettableStateVar (getString Version) + +-------------------------------------------------------------------------------- + +-- | To verify that a given extension is available for the current context, use +-- 'alIsExtensionPresent'. For invalid and unsupported string tokens it contains +-- 'False'. The extension name is not case sensitive: The implementation will +-- convert the name to all upper-case internally (and will express extension +-- names in upper-case). + +alIsExtensionPresent :: String -> GettableStateVar Bool +alIsExtensionPresent extensionName = + makeGettableStateVar $ + fmap unmarshalALboolean $ + withALString extensionName alIsExtensionPresent_ + +foreign import CALLCONV unsafe "alIsExtensionPresent" + alIsExtensionPresent_ :: Ptr ALchar -> IO ALboolean + +-------------------------------------------------------------------------------- + +-- | To retrieving function entry addresses, applications can use +-- 'alProcAddress'. It contains 'nullFunPtr' if no entry point with the given +-- name can be found. Implementations are free to use 'nullFunPtr' if an +-- entry point is present, but not applicable for the current context. However +-- the specification does not guarantee this behavior. Applications can use +-- 'alProcAddress' to obtain core API entry points, not just extensions. This +-- is the recommended way to dynamically load and unload OpenAL DLLs as sound +-- drivers. + +alProcAddress :: String -> GettableStateVar (FunPtr a) +alProcAddress funcName = makeGettableStateVar $ + withALString funcName alGetProcAddress + +foreign import CALLCONV unsafe "alGetProcAddress" + alGetProcAddress :: Ptr ALchar -> IO (FunPtr a) + +-------------------------------------------------------------------------------- + +-- | To obtain enumeration values for extensions, the application has to use +-- 'alEnumValue' of an extension token. Enumeration values are defined within +-- the OpenAL name space and allocated according to specification of the core +-- API and the extensions, thus they are context-independent. +-- +-- 'alEnumValue' contains 0 if the enumeration can not be found. The presence of +-- an enum value does not guarantee the applicability of an extension to the +-- current context. A non-zero value indicates merely that the implementation is +-- aware of the existence of this extension. Implementations should not attempt +-- to use 0 to indicate that the extensions is not supported for the current +-- context. + +alEnumValue :: String -> GettableStateVar ALenum +alEnumValue enumName = makeGettableStateVar $ + withALString enumName alGetEnumValue + +foreign import CALLCONV unsafe "alGetEnumValue" + alGetEnumValue :: Ptr ALchar -> IO ALenum diff -uNr --exclude=autom4te.cache --exclude=.cvsignore hugs98-Mar2005-patched/fptools/libraries/OpenAL/Sound/OpenAL/AL/Format.hs ghc-6.4.2/libraries/OpenAL/Sound/OpenAL/AL/Format.hs --- hugs98-Mar2005-patched/fptools/libraries/OpenAL/Sound/OpenAL/AL/Format.hs 2004-04-05 21:55:40.000000000 +0900 +++ ghc-6.4.2/libraries/OpenAL/Sound/OpenAL/AL/Format.hs 2006-03-22 00:58:03.000000000 +0900 @@ -2,13 +2,15 @@ -------------------------------------------------------------------------------- -- | -- Module : Sound.OpenAL.AL.Format --- Copyright : (c) Sven Panne 2003-2004 +-- Copyright : (c) Sven Panne 2003-2005 -- License : BSD-style (see the file libraries/OpenAL/LICENSE) -- -- Maintainer : sven.panne@aedion.de -- Stability : provisional -- Portability : portable -- +-- This is a purely internal module for (un-)marshaling Format. +-- -------------------------------------------------------------------------------- module Sound.OpenAL.AL.Format ( @@ -16,49 +18,33 @@ ) where import Sound.OpenAL.AL.BasicTypes ( ALenum ) +import Sound.OpenAL.Constants ( + al_FORMAT_MONO8, al_FORMAT_MONO16, al_FORMAT_STEREO8, al_FORMAT_STEREO16 ) -------------------------------------------------------------------------------- -#include "HsOpenALConfig.h" - --------------------------------------------------------------------------------- +-- | Valid sound formats. An implementation may expose other formats, see +-- "Sound.OpenAL.ALC.Extensions" for information on determining if additional +-- formats are supported. data Format = Mono8 | Mono16 | Stereo8 | Stereo16 - | IMAADPCMMono16 - | IMAADPCMStereo16 - | Wave - | Vorbis - | Quad8 - | Quad16 deriving ( Eq, Ord, Show ) marshalFormat :: Format -> ALenum marshalFormat x = case x of - Mono8 -> 0x1100 - Mono16 -> 0x1101 - Stereo8 -> 0x1102 - Stereo16 -> 0x1103 - IMAADPCMMono16 -> 0x10000 - IMAADPCMStereo16 -> 0x10001 - Wave -> 0x10002 - Vorbis -> CONST_AL_FORMAT_VORBIS_EXT - Quad8 -> 0x10004 - Quad16 -> 0x10005 + Mono8 -> al_FORMAT_MONO8 + Mono16 -> al_FORMAT_MONO16 + Stereo8 -> al_FORMAT_STEREO8 + Stereo16 -> al_FORMAT_STEREO16 unmarshalFormat :: ALenum -> Format unmarshalFormat x - | x == 0x1100 = Mono8 - | x == 0x1101 = Mono16 - | x == 0x1102 = Stereo8 - | x == 0x1103 = Stereo16 - | x == 0x10000 = IMAADPCMMono16 - | x == 0x10001 = IMAADPCMStereo16 - | x == 0x10002 = Wave - | x == CONST_AL_FORMAT_VORBIS_EXT = Vorbis - | x == 0x10004 = Quad8 - | x == 0x10005 = Quad16 + | x == al_FORMAT_MONO8 = Mono8 + | x == al_FORMAT_MONO16 = Mono16 + | x == al_FORMAT_STEREO8 = Stereo8 + | x == al_FORMAT_STEREO16 = Stereo16 | otherwise = error ("unmarshalFormat: illegal value " ++ show x) diff -uNr --exclude=autom4te.cache --exclude=.cvsignore hugs98-Mar2005-patched/fptools/libraries/OpenAL/Sound/OpenAL/AL/Listener.hs ghc-6.4.2/libraries/OpenAL/Sound/OpenAL/AL/Listener.hs --- hugs98-Mar2005-patched/fptools/libraries/OpenAL/Sound/OpenAL/AL/Listener.hs 2004-01-03 04:03:09.000000000 +0900 +++ ghc-6.4.2/libraries/OpenAL/Sound/OpenAL/AL/Listener.hs 2006-03-22 00:58:03.000000000 +0900 @@ -1,70 +1,112 @@ -------------------------------------------------------------------------------- -- | -- Module : Sound.OpenAL.AL.Listener --- Copyright : (c) Sven Panne 2003-2004 +-- Copyright : (c) Sven Panne 2003-2005 -- License : BSD-style (see the file libraries/OpenAL/LICENSE) -- -- Maintainer : sven.panne@aedion.de -- Stability : provisional -- Portability : portable -- --------------------------------------------------------------------------------- +-- This module corresponds to sections 4.1 (Basic Listener and Source +-- Attributes) and 4.2 (Listener Object) of the OpenAL Specification and +-- Reference (version 1.1). +-- +-- The listener object defines various properties that affect processing of the +-- sound for the actual output. The listener is unique for an OpenAL Context, +-- and has no name. By controlling the listener, the application controls the +-- way the user experiences the virtual world, as the listener defines the +-- sampling\/pickup point and orientation, and other parameters that affect the +-- output stream. +-- +-- It is entirely up to the driver and hardware configuration, i.e. the +-- installation of OpenAL as part of the operating system and hardware setup, +-- whether the output stream is generated for headphones or 2 speakers, 4.1 +-- speakers, or other arrangements, whether (and which) HRTFs are applied, +-- etc... +-- +--------------------------------------------------------------------------------- module Sound.OpenAL.AL.Listener ( - listenerGain, listenerPosition, listenerVelocity, orientation + listenerPosition, listenerVelocity, Gain, listenerGain, orientation ) where -import Foreign.Marshal.Alloc ( alloca ) import Foreign.Marshal.Array ( allocaArray, withArray ) import Foreign.Marshal.Utils ( with ) import Foreign.Ptr ( Ptr ) +import Foreign.Storable ( Storable ) import Graphics.Rendering.OpenGL.GL.CoordTrans ( Vector3(..) ) import Graphics.Rendering.OpenGL.GL.VertexSpec ( Vertex3(..) ) import Graphics.Rendering.OpenGL.GL.StateVar ( StateVar, makeStateVar ) import Sound.OpenAL.AL.BasicTypes ( ALenum, ALfloat ) import Sound.OpenAL.AL.PeekPoke ( peek1, peek3, peek6 ) import Sound.OpenAL.AL.QueryUtils ( - GetPName(GetGain,GetPosition,GetVelocity,GetOrientation), marshalGetPName ) + GetPName(GetPosition,GetVelocity,GetGain,GetOrientation), marshalGetPName ) -------------------------------------------------------------------------------- -listenerGain :: StateVar ALfloat -listenerGain = - makeStateVar - (do alloca $ \buf -> do - getListenerfv GetGain buf - peek1 id buf) - (listenerf GetGain) - --------------------------------------------------------------------------------- +-- | 'listenerPosition' contains the current location of the listener in the +-- world coordinate system. Any 3-tuple of valid float values is allowed. +-- Implementation behavior on encountering NaN and infinity is not defined. The +-- initial position is ('Vertex3' 0 0 0). listenerPosition :: StateVar (Vertex3 ALfloat) -listenerPosition = - makeStateVar - (do allocaArray 3 $ \buf -> do - getListenerfv GetPosition buf - peek3 Vertex3 buf) - (\pos -> with pos $ listenerVertex3 GetPosition) +listenerPosition = makeListenerVar GetPosition 3 (peek3 Vertex3) listener3f -------------------------------------------------------------------------------- +-- | 'listenerVelocity' contains current velocity (speed and direction) of the +-- listener in the world coordinate system. Any 3-tuple of valid float +-- values is allowed, and the initial velocity is ('Vector3' 0 0 0). +-- 'listenerVelocity' does not affect 'listenerPosition'. OpenAL does not +-- calculate the velocity from subsequent position updates, nor does it +-- adjust the position over time based on the specified velocity. Any +-- such calculation is left to the application. For the purposes of sound +-- processing, position and velocity are independent parameters affecting +-- different aspects of the sounds. +-- +-- 'listenerVelocity' is taken into account by the driver to synthesize the +-- Doppler effect perceived by the listener for each source, based on the +-- velocity of both source and listener, and the Doppler related parameters. + listenerVelocity :: StateVar (Vector3 ALfloat) -listenerVelocity = - makeStateVar - (do allocaArray 3 $ \buf -> do - getListenerfv GetVelocity buf - peek3 Vector3 buf) - (\vel -> with vel $ listenerVector3 GetVelocity) +listenerVelocity = makeListenerVar GetVelocity 3 (peek3 Vector3) listener3f + +-------------------------------------------------------------------------------- + +-- | A scalar amplitude multiplier. +type Gain = ALfloat + +-- | 'listenerGain' contains a scalar amplitude multiplier, which is effectively +-- applied to all sources in the current context. The initial value 1 means +-- that the sound is unattenuated. A 'listenerGain' value of 0.5 is equivalent +-- to an attenuation of 6dB. The value zero equals silence (no output). Driver +-- implementations are free to optimize this case and skip mixing and processing +-- stages where applicable. The implementation is in charge of ensuring +-- artifact-free (click-free) changes of gain values and is free to defer actual +-- modification of the sound samples, within the limits of acceptable latencies. +-- +-- A 'listenerGain' larger than 1 (amplification) is permitted. However, the +-- implementation is free to clamp the total gain (effective gain per source +-- times listener gain) to 1 to prevent overflow. + +listenerGain :: StateVar Gain +listenerGain = makeListenerVar GetGain 1 (peek1 id) listenerf -------------------------------------------------------------------------------- +-- | 'orientation' contains an \"at\" vector and an \"up\" vector, where the +-- \"at\" vector represents the \"forward\" direction of the listener and the +-- orthogonal projection of the \"up\" vector into the subspace perpendicular to +-- the \"at\" vector represents the \"up\" direction for the listener. OpenAL +-- expects two vectors that are linearly independent. These vectors are not +-- expected to be normalized. If the two vectors are linearly dependent, +-- behavior is undefined. The initial orientation is ('Vector3' 0 0 (-1), +-- 'Vector3' 0 1 0), i.e. looking down the Z axis with the Y axis pointing +-- upwards. + orientation :: StateVar (Vector3 ALfloat, Vector3 ALfloat) -orientation = - makeStateVar - (do allocaArray 6 $ \buf -> do - getListenerfv GetOrientation buf - peek6 Vector3 buf) - (\(at, up) -> withArray [at, up] $ listenerVector3 GetOrientation) +orientation = makeListenerVar GetOrientation 6 (peek6 Vector3) listenerVector6 -------------------------------------------------------------------------------- @@ -74,31 +116,35 @@ foreign import CALLCONV unsafe "alListenerf" alListenerf :: ALenum -> ALfloat -> IO () -listenerVertex3 :: GetPName -> Ptr (Vertex3 ALfloat) -> IO () -listenerVertex3 = alListenerfv . marshalGetPName +-------------------------------------------------------------------------------- + +listener3f :: Storable a => GetPName -> a -> IO () +listener3f n x = with x $ listenerfv n -listenerVector3 :: GetPName -> Ptr (Vector3 ALfloat) -> IO () -listenerVector3 = alListenerfv . marshalGetPName +listenerVector6 :: GetPName -> (Vector3 ALfloat, Vector3 ALfloat) -> IO () +listenerVector6 n (x, y) = withArray [x, y] $ listenerfv n + +listenerfv :: GetPName -> Ptr a -> IO () +listenerfv = alListenerfv . marshalGetPName foreign import CALLCONV unsafe "alListenerfv" alListenerfv :: ALenum -> Ptr a -> IO () +-------------------------------------------------------------------------------- + getListenerfv :: GetPName -> Ptr ALfloat -> IO () getListenerfv = alGetListenerfv . marshalGetPName foreign import CALLCONV unsafe "alGetListenerfv" alGetListenerfv :: ALenum -> Ptr ALfloat -> IO () -{- -listenerf: -AL_GAIN_LINEAR_LOKI -AL_GAIN - -listenerfv: -AL_POSITION -AL_VELOCITY -AL_ORIENTATION (6: at + up) - -getlistenerfv: -all above --} +-------------------------------------------------------------------------------- + +makeListenerVar :: GetPName -> Int -> (Ptr ALfloat -> IO a) + -> (GetPName -> a -> IO ()) -> StateVar a +makeListenerVar pname size reader writer = + makeStateVar + (allocaArray size $ \buf -> do + getListenerfv pname buf + reader buf) + (writer pname) diff -uNr --exclude=autom4te.cache --exclude=.cvsignore hugs98-Mar2005-patched/fptools/libraries/OpenAL/Sound/OpenAL/AL/PeekPoke.hs ghc-6.4.2/libraries/OpenAL/Sound/OpenAL/AL/PeekPoke.hs --- hugs98-Mar2005-patched/fptools/libraries/OpenAL/Sound/OpenAL/AL/PeekPoke.hs 2004-01-03 04:03:09.000000000 +0900 +++ ghc-6.4.2/libraries/OpenAL/Sound/OpenAL/AL/PeekPoke.hs 2006-03-22 00:58:03.000000000 +0900 @@ -2,7 +2,7 @@ -------------------------------------------------------------------------------- -- | -- Module : Sound.OpenAL.AL.PeekPoke --- Copyright : (c) Sven Panne 2003-2004 +-- Copyright : (c) Sven Panne 2003-2005 -- License : BSD-style (see the file libraries/OpenGL/LICENSE) -- -- Maintainer : sven.panne@aedion.de @@ -14,8 +14,7 @@ -------------------------------------------------------------------------------- module Sound.OpenAL.AL.PeekPoke ( - poke1, poke3, poke6, - peek1, peek3, peek6 + poke1, peek1, peek3, peek6 ) where import Foreign.Ptr ( Ptr ) @@ -32,23 +31,6 @@ poke1 ptr x = pokeElemOff ptr 0 x -{-# INLINE poke3 #-} -poke3 :: Storable a => Ptr a -> a -> a -> a -> IO () -poke3 ptr x y z = do - pokeElemOff ptr 0 x - pokeElemOff ptr 1 y - pokeElemOff ptr 2 z - -{-# INLINE poke6 #-} -poke6 :: Storable a => Ptr a -> (a, a, a) -> (a, a, a) -> IO () -poke6 ptr (x, y, z) (u, v, w) = do - pokeElemOff ptr 0 x - pokeElemOff ptr 1 y - pokeElemOff ptr 2 z - pokeElemOff ptr 3 u - pokeElemOff ptr 4 v - pokeElemOff ptr 5 w - -------------------------------------------------------------------------------- {-# INLINE peek1 #-} diff -uNr --exclude=autom4te.cache --exclude=.cvsignore hugs98-Mar2005-patched/fptools/libraries/OpenAL/Sound/OpenAL/AL/QueryUtils.hs ghc-6.4.2/libraries/OpenAL/Sound/OpenAL/AL/QueryUtils.hs --- hugs98-Mar2005-patched/fptools/libraries/OpenAL/Sound/OpenAL/AL/QueryUtils.hs 2004-01-03 04:03:09.000000000 +0900 +++ ghc-6.4.2/libraries/OpenAL/Sound/OpenAL/AL/QueryUtils.hs 2006-03-22 00:58:03.000000000 +0900 @@ -2,7 +2,7 @@ -------------------------------------------------------------------------------- -- | -- Module : Sound.OpenAL.AL.QueryUtils --- Copyright : (c) Sven Panne 2003-2004 +-- Copyright : (c) Sven Panne 2003-2005 -- License : BSD-style (see the file libraries/OpenGL/LICENSE) -- -- Maintainer : sven.panne@aedion.de @@ -15,124 +15,108 @@ module Sound.OpenAL.AL.QueryUtils ( GetPName(..), marshalGetPName, - getFloat1, getFloat3, getFloat6 + StringName(..), getString ) where -import Control.Monad ( liftM ) -import Foreign.Marshal.Array ( allocaArray ) import Foreign.Ptr ( Ptr ) -import Sound.OpenAL.AL.BasicTypes ( ALenum, ALfloat ) -import Sound.OpenAL.AL.PeekPoke ( peek3, peek6 ) +import Sound.OpenAL.AL.BasicTypes ( ALchar, ALenum ) +import Sound.OpenAL.AL.String ( peekALString ) +import Sound.OpenAL.Constants ( + al_DISTANCE_MODEL, al_DOPPLER_FACTOR, al_SPEED_OF_SOUND, al_POSITION, + al_VELOCITY, al_GAIN, al_ORIENTATION, al_SOURCE_RELATIVE, al_SOURCE_TYPE, + al_LOOPING, al_BUFFER, al_BUFFERS_QUEUED, al_BUFFERS_PROCESSED, al_MIN_GAIN, + al_MAX_GAIN, al_REFERENCE_DISTANCE, al_ROLLOFF_FACTOR, al_MAX_DISTANCE, + al_PITCH, al_DIRECTION, al_CONE_INNER_ANGLE, al_CONE_OUTER_ANGLE, + al_CONE_OUTER_GAIN, al_SEC_OFFSET, al_SAMPLE_OFFSET, al_BYTE_OFFSET, + al_SOURCE_STATE, al_VENDOR, al_RENDERER, al_VERSION, al_EXTENSIONS ) -------------------------------------------------------------------------------- data GetPName = - GetSourceType - | GetSourceRelative - | GetConeInnerAngle - | GetConeOuterAngle - | GetPitch + GetDistanceModel + | GetDopplerFactor + | GetSpeedOfSound + | GetPosition - | GetDirection + | GetVelocity - | GetLooping - | GetStreaming - | GetBuffer | GetGain - | GetByte - | GetMinGain - | GetMaxGain + | GetOrientation - | GetSourceState + + | GetSourceRelative + | GetSourceType + | GetLooping + | GetBuffer | GetBuffersQueued | GetBuffersProcessed - | GetPending - | GetProcessed + | GetMinGain + | GetMaxGain | GetReferenceDistance | GetRolloffFactor - | GetConeOuterGain | GetMaxDistance - | GetFrequency - | GetBits - | GetChannels - | GetSize - | GetVendor - | GetVersion - | GetRenderer - | GetExtensions - | GetDopplerFactor - | GetDopplerVelocity - | GetDistanceScale - | GetDistanceModel - | GetInverseDistance - | GetInverseDistanceClamped + | GetPitch + | GetDirection + | GetConeInnerAngle + | GetConeOuterAngle + | GetConeOuterGain + | GetSecOffset + | GetSampleOffset + | GetByteOffset + | GetSourceState marshalGetPName :: GetPName -> ALenum marshalGetPName x = case x of - GetSourceType -> 0x0200 - GetSourceRelative -> 0x0202 - GetConeInnerAngle -> 0x1001 - GetConeOuterAngle -> 0x1002 - GetPitch -> 0x1003 - GetPosition -> 0x1004 - GetDirection -> 0x1005 - GetVelocity -> 0x1006 - GetLooping -> 0x1007 - GetStreaming -> 0x1008 - GetBuffer -> 0x1009 - GetGain -> 0x100A - GetByte -> 0x100C - GetMinGain -> 0x100D - GetMaxGain -> 0x100E - GetOrientation -> 0x100F - GetSourceState -> 0x1010 - GetBuffersQueued -> 0x1015 - GetBuffersProcessed -> 0x1016 - GetPending -> 0x1017 - GetProcessed -> 0x1018 - GetReferenceDistance -> 0x1020 - GetRolloffFactor -> 0x1021 - GetConeOuterGain -> 0x1022 - GetMaxDistance -> 0x1023 - GetFrequency -> 0x2001 - GetBits -> 0x2002 - GetChannels -> 0x2003 - GetSize -> 0x2004 - GetVendor -> 0xB001 - GetVersion -> 0xB002 - GetRenderer -> 0xB003 - GetExtensions -> 0xB004 - GetDopplerFactor -> 0xC000 - GetDopplerVelocity -> 0xC001 - GetDistanceScale -> 0xC002 - GetDistanceModel -> 0xD000 - GetInverseDistance -> 0xD001 - GetInverseDistanceClamped -> 0xD002 + GetDistanceModel -> al_DISTANCE_MODEL + GetDopplerFactor -> al_DOPPLER_FACTOR + GetSpeedOfSound -> al_SPEED_OF_SOUND + + GetPosition -> al_POSITION + GetVelocity -> al_VELOCITY + GetGain -> al_GAIN + + GetOrientation -> al_ORIENTATION + + GetSourceRelative -> al_SOURCE_RELATIVE + GetSourceType -> al_SOURCE_TYPE + GetLooping -> al_LOOPING + GetBuffer -> al_BUFFER + GetBuffersQueued -> al_BUFFERS_QUEUED + GetBuffersProcessed -> al_BUFFERS_PROCESSED + GetMinGain -> al_MIN_GAIN + GetMaxGain -> al_MAX_GAIN + GetReferenceDistance -> al_REFERENCE_DISTANCE + GetRolloffFactor -> al_ROLLOFF_FACTOR + GetMaxDistance -> al_MAX_DISTANCE + GetPitch -> al_PITCH + GetDirection -> al_DIRECTION + GetConeInnerAngle -> al_CONE_INNER_ANGLE + GetConeOuterAngle -> al_CONE_OUTER_ANGLE + GetConeOuterGain -> al_CONE_OUTER_GAIN + GetSecOffset -> al_SEC_OFFSET + GetSampleOffset -> al_SAMPLE_OFFSET + GetByteOffset -> al_BYTE_OFFSET + GetSourceState -> al_SOURCE_STATE -------------------------------------------------------------------------------- --- Note: OpenAL is not yet orthogonal enough to use getFloatv here, too. - -getFloat1 :: (ALfloat -> a) -> GetPName -> IO a -getFloat1 f = liftM f . alGetFloat . marshalGetPName - -foreign import CALLCONV unsafe "alGetFloat" - alGetFloat :: ALenum -> IO ALfloat - -getFloat3 :: (ALfloat -> ALfloat -> ALfloat -> a) -> GetPName -> IO a -getFloat3 f n = allocaArray 3 $ \buf -> do - getFloatv n buf - peek3 f buf - -getFloat6 :: - (ALfloat -> ALfloat -> ALfloat -> a) - -> GetPName -> IO (a, a) -getFloat6 f n = allocaArray 6 $ \buf -> do - getFloatv n buf - peek6 f buf +data StringName = + Vendor + | Renderer + | Version + | Extensions + | ALErrorCategory ALenum + +marshalStringName :: StringName -> ALenum +marshalStringName x = case x of + Vendor -> al_VENDOR + Renderer -> al_RENDERER + Version -> al_VERSION + Extensions -> al_EXTENSIONS + ALErrorCategory e -> e -getFloatv :: GetPName -> Ptr ALfloat -> IO () -getFloatv = alGetFloatv . marshalGetPName +getString :: StringName -> IO String +getString n = alGetString (marshalStringName n) >>= peekALString -foreign import CALLCONV unsafe "alGetFloatv" - alGetFloatv :: ALenum -> Ptr ALfloat -> IO () +foreign import CALLCONV unsafe "alGetString" + alGetString :: ALenum -> IO (Ptr ALchar) diff -uNr --exclude=autom4te.cache --exclude=.cvsignore hugs98-Mar2005-patched/fptools/libraries/OpenAL/Sound/OpenAL/AL/Source.hs ghc-6.4.2/libraries/OpenAL/Sound/OpenAL/AL/Source.hs --- hugs98-Mar2005-patched/fptools/libraries/OpenAL/Sound/OpenAL/AL/Source.hs 2004-03-30 16:07:15.000000000 +0900 +++ ghc-6.4.2/libraries/OpenAL/Sound/OpenAL/AL/Source.hs 2006-03-22 00:58:03.000000000 +0900 @@ -1,119 +1,775 @@ -------------------------------------------------------------------------------- -- | -- Module : Sound.OpenAL.AL.Source --- Copyright : (c) Sven Panne 2003-2004 +-- Copyright : (c) Sven Panne 2003-2005 -- License : BSD-style (see the file libraries/OpenAL/LICENSE) -- -- Maintainer : sven.panne@aedion.de -- Stability : provisional -- Portability : portable -- +-- This module corresponds to sections 4.1 (Basic Listener and Source +-- Attributes) and 4.3 (Source Objects) of the OpenAL Specification and +-- Reference (version 1.1). +-- +-- Sources specify attributes like position, velocity, and a buffer with sample +-- data. By controlling a source\'s attributes the application can modify and +-- parameterize the static sample data provided by the buffer referenced by the +-- source. Sources define a localized sound, and encapsulate a set of attributes +-- applied to a sound at its origin, i.e. in the very first stage of the +-- processing on the way to the listener. Source related effects have to be +-- applied before listener related effects unless the output is invariant to any +-- collapse or reversal of order. OpenAL also provides additional functions to +-- manipulate and query the execution state of sources: the current playing +-- status of a source, including access to the current sampling position within +-- the associated buffer. +-- -------------------------------------------------------------------------------- module Sound.OpenAL.AL.Source ( - Source + -- * The Source Type + Source, + + -- * Source Attributes + + -- ** Basic Source Attributes + sourcePosition, sourceVelocity, sourceGain, + + -- ** Source Positioning + SourceRelative(..), sourceRelative, + + -- ** Source Type + SourceType(..), sourceType, + + -- ** Buffer Looping + LoopingMode(..), loopingMode, + + -- ** Current Buffer + buffer, + + -- ** Queue State Queries + buffersQueued, buffersProcessed, + + -- ** Bounds on Gain + gainBounds, + + -- ** Distance Model Attributes + referenceDistance, rolloffFactor, maxDistance, + + -- ** Frequency Shift by Pitch + pitch, + + -- ** Direction and Cone + -- $DirectionAndCone + direction, coneAngles, coneOuterGain, + + -- ** Offset + secOffset, sampleOffset, byteOffset, + + -- * Queuing Buffers with a Source + -- $QueuingBuffersWithASource + queueBuffers, unqueueBuffers, + + -- * Managing Source Execution + -- $ManagingSourceExecution + SourceState(..), sourceState, play, pause, stop, rewind ) where -import Control.Monad ( liftM ) +import Control.Monad ( liftM2 ) import Foreign.Marshal.Array ( withArrayLen, peekArray, allocaArray ) -import Foreign.Ptr ( Ptr ) +import Foreign.Marshal.Utils ( with ) +import Foreign.Ptr ( Ptr, castPtr ) +import Foreign.Storable ( Storable(..) ) import Graphics.Rendering.OpenGL.GL.BufferObjects ( ObjectName(..) ) +import Graphics.Rendering.OpenGL.GL.CoordTrans ( Vector3(..) ) +import Graphics.Rendering.OpenGL.GL.VertexSpec ( Vertex3(..) ) +import Graphics.Rendering.OpenGL.GL.StateVar ( + HasGetter(get), HasSetter(($=)), makeStateVar, StateVar, GettableStateVar, + makeGettableStateVar ) +import Sound.OpenAL.AL.ALboolean ( marshalALboolean, unmarshalALboolean ) import Sound.OpenAL.AL.BasicTypes -import Sound.OpenAL.AL.ALboolean ( unmarshalALboolean ) +import Sound.OpenAL.AL.Buffer ( Buffer ) +import Sound.OpenAL.AL.BufferInternal ( marshalBuffer, unmarshalBuffer ) +import Sound.OpenAL.AL.Listener ( Gain ) +import Sound.OpenAL.AL.PeekPoke ( peek1, poke1, peek3 ) +import Sound.OpenAL.AL.SourceState ( SourceState(..), unmarshalSourceState ) +import Sound.OpenAL.AL.QueryUtils ( + GetPName(GetPosition,GetVelocity,GetGain,GetSourceRelative,GetSourceType, + GetLooping,GetBuffer,GetBuffersQueued,GetBuffersProcessed, + GetMinGain,GetMaxGain,GetReferenceDistance,GetRolloffFactor, + GetMaxDistance,GetPitch,GetDirection,GetConeInnerAngle, + GetConeOuterAngle,GetConeOuterGain,GetSecOffset,GetSampleOffset, + GetByteOffset,GetSourceState), + marshalGetPName ) +import Sound.OpenAL.Constants ( al_UNDETERMINED, al_STATIC, al_STREAMING ) + +#ifdef __HADDOCK__ +import Sound.OpenAL.AL.Listener ( listenerGain ) +import Sound.OpenAL.AL.Errors ( ALErrorCategory(..) ) +#endif -------------------------------------------------------------------------------- -newtype Source = Source { sourceID :: ALuint } +-- | The abstract buffer type. + +newtype Source = Source ALuint deriving ( Eq, Ord, Show ) +instance Storable Source where + sizeOf ~(Source b) = sizeOf b + alignment ~(Source b) = alignment b + peek = peek1 Source . castPtr + poke ptr (Source b) = poke1 (castPtr ptr) b + instance ObjectName Source where genObjectNames n = allocaArray n $ \buf -> do alGenSources (fromIntegral n) buf - liftM (map Source) $ peekArray n buf + peekArray n buf - deleteObjectNames sources = - withArrayLen (map sourceID sources) $ - alDeleteSources . fromIntegral + deleteObjectNames = withArraySizei alDeleteSources - isObjectName = liftM unmarshalALboolean . alIsSource . sourceID + isObjectName = fmap unmarshalALboolean . alIsSource foreign import CALLCONV unsafe "alGenSources" - alGenSources :: ALsizei -> Ptr ALuint -> IO () + alGenSources :: ALsizei -> Ptr Source -> IO () foreign import CALLCONV unsafe "alDeleteSources" - alDeleteSources :: ALsizei -> Ptr ALuint -> IO () + alDeleteSources :: ALsizei -> Ptr Source -> IO () foreign import CALLCONV unsafe "alIsSource" - alIsSource :: ALuint -> IO ALboolean + alIsSource :: Source -> IO ALboolean + +-------------------------------------------------------------------------------- + +-- | 'sourcePosition' contains the current location of the source in the world +-- coordinate system. Any 3-tuple of valid float values is allowed. +-- Implementation behavior on encountering NaN and infinity is not defined. The +-- initial position is ('Vertex3' 0 0 0). + +sourcePosition :: Source -> StateVar (Vertex3 ALfloat) +sourcePosition = makeSourceStateVar dictVertex3ALfloat GetPosition + +-- | 'sourceVelocity' contains current velocity (speed and direction) of the +-- source in the world coordinate system. Any 3-tuple of valid float values is +-- allowed, and the initial velocity is ('Vector3' 0 0 0). 'sourceVelocity' does +-- not affect 'sourcePosition'. OpenAL does not calculate the velocity from +-- subsequent position updates, nor does it adjust the position over time based +-- on the specified velocity. Any such calculation is left to the application. +-- For the purposes of sound processing, position and velocity are independent +-- parameters affecting different aspects of the sounds. +-- +-- 'sourceVelocity' is taken into account by the driver to synthesize the +-- Doppler effect perceived by the listener for each source, based on the +-- velocity of both source and listener, and the Doppler related parameters. + +sourceVelocity :: Source -> StateVar (Vector3 ALfloat) +sourceVelocity = makeSourceStateVar dictVector3ALfloat GetVelocity + +-- | 'sourceGain' contains a scalar amplitude multiplier for the given source. +-- The initial value 1 means that the sound is unattenuated. A 'sourceGain' +-- value of 0.5 is equivalent to an attenuation of 6dB. The value zero equals +-- silence (no output). Driver implementations are free to optimize this case +-- and skip mixing and processing stages where applicable. The implementation is +-- in charge of ensuring artifact-free (click-free) changes of gain values and +-- is free to defer actual modification of the sound samples, within the limits +-- of acceptable latencies. +-- +-- A 'sourceGain' larger than 1 (amplification) is permitted. However, the +-- implementation is free to clamp the total gain (effective gain per source +-- times listener gain) to 1 to prevent overflow. + +sourceGain :: Source -> StateVar Gain +sourceGain = makeSourceStateVar dictALfloat GetGain + +-------------------------------------------------------------------------------- + +-- | The entity to which the source attributes 'sourcePosition', +-- 'sourceVelocity' and 'direction' are to be interpreted. + +data SourceRelative = + World + | Listener + deriving ( Eq, Ord, Show ) + +marshalSourceRelative :: SourceRelative -> Bool +marshalSourceRelative = (== Listener) + +unmarshalSourceRelative :: Bool -> SourceRelative +unmarshalSourceRelative x = if x then Listener else World + +-- | If 'sourceRelative' contains 'Listener', it indicates indicates that the +-- values specified by 'sourcePosition', 'sourceVelocity' and 'direction' are to +-- be interpreted relative to the listener position. The initial value is +-- 'World', indicating that those source attributes are to be interpreted +-- relative to the world, i.e. they are considered absolute. +sourceRelative :: Source -> StateVar SourceRelative +sourceRelative = makeSourceStateVar dictSourceRelative GetSourceRelative + +-------------------------------------------------------------------------------- + +-- | When first created, a source will be in the 'Undetermined' state. If a +-- buffer is then attached using 'buffer', then the source will enter the +-- 'Static' state. If the first buffer attached to a source is attached using +-- 'queueBuffers', then the source will enter the 'Streaming' state. A source of +-- either state will be reset to state 'Undetermined' by setting its 'buffer' to +-- 'Nothing', and attaching any buffer to a streaming source will change the +-- state to 'Static'. Attempting to queue a buffer on a static source will +-- result in an 'ALInvalidOperation' error. + +data SourceType = + Undetermined + | Static + | Streaming + deriving ( Eq, Ord, Show ) + +unmarshalSourceType :: ALint -> SourceType +unmarshalSourceType x + | x == al_UNDETERMINED = Undetermined + | x == al_STATIC = Static + | x == al_STREAMING = Streaming + | otherwise = error ("unmarshalSourceType: illegal value " ++ show x) + +-- | 'sourceType' indicates whether a source is ready to queue buffers, ready to +-- use a static buffer, or is in an undetermined state where it can be used for +-- either streaming or static playback. + +sourceType :: Source -> GettableStateVar SourceType +sourceType = makeSourceGettableStateVar dictSourceType GetSourceType + +-------------------------------------------------------------------------------- + +-- | Specifies what should happen when the end of a buffer queue is reached. + +data LoopingMode = + OneShot + | Looping + deriving ( Eq, Ord, Show ) + +marshalLoopingMode :: LoopingMode -> Bool +marshalLoopingMode = (== Looping) + +unmarshalLoopingMode :: Bool -> LoopingMode +unmarshalLoopingMode x = if x then Looping else OneShot + +-- | If 'loopingMode' contains 'Looping', it indicates that the source will not +-- be in the 'Stopped' state once it reaches the end of last buffer in the +-- buffer queue. Instead, the source will immediately promote to 'Initial' and +-- 'Playing'. The initial value is 'OneShot'. 'loopingMode' can be changed on a +-- source in any execution state. In particular, it can be changed on a +-- 'Playing' source. + +loopingMode :: Source -> StateVar LoopingMode +loopingMode = makeSourceStateVar dictLoopingMode GetLooping + +-------------------------------------------------------------------------------- + +-- | 'buffer' contains the current buffer object. Setting 'buffer' to 'Just' a +-- buffer object makes it the head entry in the source\'s queue. Setting +-- 'buffer'for a source in the 'Stopped' or 'Initial' state empties the entire +-- queue, then appends the one buffer specified (or none at all if 'Nothing' +-- was specified). +-- +-- For a source in the 'Playing' or 'Paused' state, setting 'buffer' will result +-- in the 'ALInvalidOperation' error state being set. 'buffer' can be applied only +-- to sources in the 'Initial' and 'Stopped' states. Specifying an invalid +-- buffer name (either because the buffer name doesn\'t exist or because that +-- buffer can\'t be attached to the specified source) will result in an +-- 'ALInvalidValue' error while specifying an invalid source name results in an +-- 'ALInvalidName' error. Setting 'buffer' to 'Nothing' is a legal way to release +-- the current buffer queue on a source in the 'Initial' or 'Stopped' state, +-- whether the source has just one entry (current buffer) or more. Setting +-- 'buffer' to 'Nothing' still causes an 'ALInvalidOperation' for any source in +-- the 'Playing' or 'Paused' state, consequently it cannot be used to mute or +-- stop a source. The initial value is 'Nothing'. + +buffer :: Source -> StateVar (Maybe Buffer) +buffer = makeSourceStateVar dictMaybeBuffer GetBuffer + +-------------------------------------------------------------------------------- + +-- | 'buffersQueued' contains the number of buffers in the queue of a given +-- source. This includes those not yet played, the one currently playing, and +-- the ones that have been played already. It will contain 0 if 'buffer' has +-- been set to 'Nothing'. + +buffersQueued :: Source -> GettableStateVar ALint +buffersQueued = makeSourceGettableStateVar dictALint GetBuffersQueued + +-- | 'buffersProcessed' contains the number of buffers that have been played +-- by a given source. Indirectly, this gives the index of the buffer currently +-- playing. It can be used to determine how much slots are needed for unqueuing +-- them. On a source in the 'Stopped' state, all buffers are processed. On a +-- source in the 'Initial' state, no buffers are processed, all buffers are +-- pending. It will contain 0 if 'buffer' has been set to 'Nothing'. + +buffersProcessed :: Source -> GettableStateVar ALint +buffersProcessed = makeSourceGettableStateVar dictALint GetBuffersProcessed + +-------------------------------------------------------------------------------- + +-- | 'gainBounds' contains two scalar amplitude thresholds between 0 and 1 +-- (included): The minimum guaranteed gain for this source and the maximum gain +-- permitted, with initial values 0 and 1, respectively At the end of the +-- processing of various attenuation factors such as distance based attenuation +-- and 'sourceGain', the effective gain calculated is compared to these values: +-- +-- If the effective gain is lower than the minimum gain, the minimum gain is +-- applied. This happens before the 'listenerGain' is applied. If a zero minimum +-- gain is set, then the effective gain will not be corrected. +-- +-- If the effective gain is higher than the maximum gain, the maximum gain is +-- applied. This happens before the 'listenerGain' is applied. If the +-- 'listenerGain' times the maximum gain still exceeds the maximum gain the +-- implementation can handle, the implementation is free to clamp. If a zero +-- maximum gain is set, then the source is effectively muted. The implementation +-- is free to optimize for this situation, but no optimization is required or +-- recommended as setting 'sourceGain' to zero is the proper way to mute a +-- source. + +gainBounds :: Source -> StateVar (Gain, Gain) +gainBounds source = + pairStateVars + (makeSourceStateVar dictALfloat GetMinGain source) + (makeSourceStateVar dictALfloat GetMaxGain source) + +-------------------------------------------------------------------------------- +-- | 'referenceDistance' is used for distance attenuation calculations based on +-- inverse distance with rolloff. Depending on the distance model it will also +-- act as a distance threshold below which gain is clamped. See +-- "Sound.OpenAL.AL.Attenuation" for details. The initial value is 1. + +referenceDistance :: Source -> StateVar ALfloat +referenceDistance = makeSourceStateVar dictALfloat GetReferenceDistance + +-- | 'rolloffFactor' is used for distance attenuation calculations based on +-- inverse distance with rolloff. For distances smaller than 'maxDistance' (and, +-- depending on the distance model, larger than 'referenceDistance'), this will +-- scale the distance attenuation over the applicable range. See +-- "Sound.OpenAL.AL.Attenuation" for details how the attenuation is computed as +-- a function of the distance. The initial value is 1. +-- +-- In particular, 'rolloffFactor' can be set to zero for those sources that are +-- supposed to be exempt from distance attenuation. The implementation is +-- encouraged to optimize this case, bypassing distance attenuation calculation +-- entirely on a persource basis. + +rolloffFactor :: Source -> StateVar ALfloat +rolloffFactor = makeSourceStateVar dictALfloat GetRolloffFactor + +-- | 'maxDistance' is used for distance attenuation calculations based on +-- inverse distance with rolloff, if the inverse clamped distance model is +-- used. In this case, distances greater than 'maxDistance' will be clamped to +-- 'maxDistance'. 'maxDistance' based clamping is applied before minimum gain +-- clamping (see 'gainBounds'), so if the effective gain at 'maxDistance' is +-- larger than the minimum gain, the minimum gain will have no effect. No +-- culling is supported. The initial value is the largest representable +-- 'ALfloat'. + +maxDistance :: Source -> StateVar ALfloat +maxDistance = makeSourceStateVar dictALfloat GetMaxDistance + +-------------------------------------------------------------------------------- + +-- | 'pitch' contains the desired pitch shift, where 1 (the initial value) +-- equals identity. Each reduction by 50 percent equals a pitch shift of -12 +-- semitones (one octave reduction). Each doubling equals a pitch shift of 12 +-- semitones (one octave increase). Zero is not a legal value. Implementations +-- may clamp the actual output pitch range to any values subject to the +-- implementation's own limits. + +pitch :: Source -> StateVar ALfloat +pitch = makeSourceStateVar dictALfloat GetPitch + +-------------------------------------------------------------------------------- +-- $DirectionAndCone +-- Each source can be directional, depending on the settings for 'coneAngles'. +-- There are three zones defined: the inner cone, the outside zone, and the +-- transitional zone in between. The angle-dependent gain for a directional +-- source is constant inside the inner cone, and changes over the transitional +-- zone to the value specified outside the outer cone. 'sourceGain' is applied +-- for the inner cone, with an application selectable 'coneOuterGain' factor to +-- define the gain in the outer zone. In the transitional zone +-- implementation-dependent interpolation between 'sourceGain' and 'sourceGain' +-- times 'coneOuterGain' is applied. + +-------------------------------------------------------------------------------- + +-- | If 'direction' does not contain the zero vector ('Vector3' 0 0 0), the +-- source is directional. The sound emission is presumed to be symmetric around +-- the direction vector (cylinder symmetry). Sources are not oriented in full 3 +-- degrees of freedom, only two angles are effectively needed. +-- +-- The zero vector is the initial value, indicating that a source is not +-- directional. Specifying a non-zero vector will make the source directional. +-- Specifying a zero vector for a directional source will effectively mark it as +-- nondirectional. + +direction :: Source -> StateVar (Vector3 ALfloat) +direction = makeSourceStateVar dictVector3ALfloat GetDirection + +-- | 'coneAngles' contains the inner and outer angles of the sound cone, in +-- degrees. The default of 360 for the inner cone angle means that it covers the +-- entire world, which is equivalent to an omni-directional source. The default +-- of 360 for the outer cone angle means that it covers the entire world. If the +-- inner angle is also 360, then the zone for angle-dependent attenuation is +-- zero. + +coneAngles :: Source -> StateVar (ALfloat, ALfloat) +coneAngles source = + pairStateVars + (makeSourceStateVar dictALfloat GetConeInnerAngle source) + (makeSourceStateVar dictALfloat GetConeOuterAngle source) + +-- | 'coneOuterGain' contains the factor with which 'sourceGain' is multiplied +-- to determine the effective gain outside the cone defined by the outer angle. +-- The effective gain applied outside the outer cone is 'sourceGain' times +-- 'coneOuterGain'. Changing 'sourceGain' affects all directions, i.e. the +-- source is attenuated in all directions, for any position of the listener. The +-- application has to change 'coneOuterGain' as well if a different behavior is +-- desired. + +coneOuterGain :: Source -> StateVar Gain +coneOuterGain = makeSourceStateVar dictALfloat GetConeOuterGain + +-------------------------------------------------------------------------------- + +-- | 'secOffset' contains the playback position, expressed in seconds (the value +-- will loop back to zero for looping sources). +-- +-- When setting 'secOffset' on a source which is already playing, the playback +-- will jump to the new offset unless the new offset is out of range, in which +-- case an 'ALInvalidValue' error is set. If the source is not playing, then the +-- offset will be applied on the next 'play' call. +-- +-- The position is relative to the beginning of all the queued buffers for the +-- source, and any queued buffers traversed by a set call will be marked as +-- processed. +-- +-- This value is based on byte position, so a pitch-shifted source will have an +-- exaggerated playback speed. For example, you can be 0.5 seconds into a buffer +-- having taken only 0.25 seconds to get there if the pitch is set to 2. + +secOffset :: Source -> StateVar ALfloat +secOffset = makeSourceStateVar dictALfloat GetSecOffset + +-- | 'sampleOffset' contains the playback position, expressed in samples (the +-- value will loop back to zero for looping sources). For a compressed format, +-- this value will represent an exact offset within the uncompressed data. +-- +-- When setting 'sampleOffset' on a source which is already playing, the +-- playback will jump to the new offset unless the new offset is out of range, +-- in which case an 'ALInvalidValue' error is set. If the source is not playing, +-- then the offset will be applied on the next 'play' call. A 'stop', 'rewind', +-- or a second 'play' call will reset the offset to the beginning of the buffer. +-- +-- The position is relative to the beginning of all the queued buffers for the +-- source, and any queued buffers traversed by a set call will be marked as +-- processed. + +sampleOffset :: Source -> StateVar ALint +sampleOffset = makeSourceStateVar dictALint GetSampleOffset + +-- | 'byteOffset' contains the playback position, expressed in bytes (the value +-- will loop back to zero for looping sources). For a compressed format, this +-- value may represent an approximate offset within the compressed data buffer. +-- +-- When setting 'byteOffset' on a source which is already playing, the playback +-- will jump to the new offset unless the new offset is out of range, in which +-- case an 'ALInvalidValue' error is set. If the source is not playing, then the +-- offset will be applied on the next 'play' call. A 'stop', 'rewind', or a +-- second 'play' call will reset the offset to the beginning of the buffer. +-- +-- The position is relative to the beginning of all the queued buffers for the +-- source, and any queued buffers traversed by a set call will be marked as +-- processed. + +byteOffset :: Source -> StateVar ALint +byteOffset = makeSourceStateVar dictALint GetByteOffset + +-------------------------------------------------------------------------------- + +pairStateVars :: StateVar a -> StateVar b -> StateVar (a,b) +pairStateVars var1 var2 = + makeStateVar + (liftM2 (,) (get var1) (get var2)) + (\(val1,val2) -> do var1 $= val1; var2 $= val2) + +data Dictionary a b c = Dictionary { + alGetter :: Source -> ALenum -> Ptr b -> IO (), + alSetter :: Source -> ALenum -> Ptr b -> IO (), + size :: Int, + peekSize :: Ptr b -> IO a, + marshal :: a -> c } + +dictALint :: Dictionary ALint ALint ALint +dictALint = Dictionary { + alGetter = alGetSourceiv, + alSetter = alSourceiv, + size = 1, + peekSize = peek1 id, + marshal = id } + +dictALfloat :: Dictionary ALfloat ALfloat ALfloat +dictALfloat = Dictionary { + alGetter = alGetSourcefv, + alSetter = alSourcefv, + size = 1, + peekSize = peek1 id, + marshal = id } + +dictSourceRelative :: Dictionary SourceRelative ALint ALint +dictSourceRelative = Dictionary { + alGetter = alGetSourceiv, + alSetter = alSourceiv, + size = 1, + peekSize = peek1 (unmarshalSourceRelative . unmarshalALboolean . fromIntegral), + marshal = fromIntegral . marshalALboolean . marshalSourceRelative } + +dictSourceType :: Dictionary SourceType ALint ALint +dictSourceType = Dictionary { + alGetter = alGetSourceiv, + alSetter = undefined, + size = 1, + peekSize = peek1 unmarshalSourceType, + marshal = undefined } + +dictLoopingMode :: Dictionary LoopingMode ALint ALint +dictLoopingMode = Dictionary { + alGetter = alGetSourceiv, + alSetter = alSourceiv, + size = 1, + peekSize = peek1 (unmarshalLoopingMode . unmarshalALboolean . fromIntegral), + marshal = fromIntegral . marshalALboolean . marshalLoopingMode } + +dictSourceState :: Dictionary SourceState ALint ALint +dictSourceState = Dictionary { + alGetter = alGetSourceiv, + alSetter = undefined, + size = 1, + peekSize = peek1 unmarshalSourceState, + marshal = undefined } + +dictVertex3ALfloat :: Dictionary (Vertex3 ALfloat) ALfloat (Vertex3 ALfloat) +dictVertex3ALfloat = Dictionary { + alGetter = alGetSourcefv, + alSetter = alSourcefv, + size = 3, + peekSize = peek3 Vertex3, + marshal = id } + +dictVector3ALfloat :: Dictionary (Vector3 ALfloat) ALfloat (Vector3 ALfloat) +dictVector3ALfloat = Dictionary { + alGetter = alGetSourcefv, + alSetter = alSourcefv, + size = 3, + peekSize = peek3 Vector3, + marshal = id } + +dictMaybeBuffer :: Dictionary (Maybe Buffer) ALint ALint +dictMaybeBuffer = Dictionary { + alGetter = alGetSourceiv, + alSetter = alSourceiv, + size = 1, + peekSize = peek1 (unmarshalBuffer . fromIntegral), + marshal = fromIntegral . marshalBuffer } + +makeGetter :: Storable b => Dictionary a b c -> GetPName -> Source -> IO a +makeGetter dict name source = + allocaArray (size dict) $ \buf -> do + alGetter dict source (marshalGetPName name) buf + peekSize dict buf + +makeSetter :: Storable c => Dictionary a b c -> GetPName -> Source -> a -> IO () +makeSetter dict name source value = + with (marshal dict value) $ + alSetter dict source (marshalGetPName name) . castPtr + +makeSourceStateVar :: + (Storable b, Storable c) => + Dictionary a b c -> GetPName -> Source -> StateVar a +makeSourceStateVar dict name source = + makeStateVar + (makeGetter dict name source) + (makeSetter dict name source) + +makeSourceGettableStateVar :: + (Storable b, Storable c) => + Dictionary a b c -> GetPName -> Source -> GettableStateVar a +makeSourceGettableStateVar dict name source = + makeGettableStateVar + (makeGetter dict name source) + +-------------------------------------------------------------------------------- + +foreign import CALLCONV unsafe "alGetSourcefv" + alGetSourcefv :: Source -> ALenum -> Ptr ALfloat -> IO () + +foreign import CALLCONV unsafe "alSourcefv" + alSourcefv :: Source -> ALenum -> Ptr ALfloat -> IO () + +foreign import CALLCONV unsafe "alGetSourceiv" + alGetSourceiv :: Source -> ALenum -> Ptr ALint -> IO () + +-- Note: Older OpenAL implementations have no alSourceiv, so we emulate it here. +alSourceiv :: Source -> ALenum -> Ptr ALint -> IO () +alSourceiv source n buf = peek buf >>= alSourcei source n + +foreign import CALLCONV unsafe "alSourcei" + alSourcei :: Source -> ALenum -> ALint -> IO () + +-------------------------------------------------------------------------------- +-- $QueuingBuffersWithASource +-- OpenAL does not specify a built-in streaming mechanism. There is no mechanism +-- to stream data into a buffer object. Instead, the API has a more flexible and +-- versatile mechanism to queue buffers for sources. There are many ways to use +-- this feature, with streaming being only one of them. +-- +-- Streaming is replaced by queuing static buffers. This effectively moves any +-- multi-buffer caching into the application and allows the application to +-- select how many buffers it wants to use, the size of the buffers, and whether +-- these are re-used in cycle, pooled, or thrown away. +-- +-- Looping (over a finite number of repetitions) can be implemented by +-- explicitly repeating buffers in the queue. Infinite loops can (theoretically) +-- be accomplished by sufficiently large repetition counters. If only a single +-- buffer is supposed to be repeated infinitely, using the respective source +-- attribute 'loopingMode' is recommended. +-- +-- Loop Points for restricted looping inside a buffer can in many cases be +-- replaced by splitting the sample into several buffers and queuing the sample +-- fragments (including repetitions) accordingly. +-- +-- Buffers can be queued, unqueued after they have been used, and either be +-- deleted, or refilled and queued again. Splitting large samples over several +-- buffers maintained in a queue has distinct advantages over approaches that +-- require explicit management of samples and sample indices. + +-------------------------------------------------------------------------------- + +-- | The application can queue up one or multiple buffer names using +-- 'queueBuffers'. The buffers will be queued in the sequence in which they +-- appear in the list. +-- +-- This command is legal on a source in any playback state (to allow for +-- streaming, queuing has to be possible on a 'Playing' source). +-- +-- All buffers in a queue must have the same format and attributes. An attempt +-- to mix formats or other buffer attributes will result in a failure and an +-- 'ALInvalidValue' error will be thrown. If the queue operation fails, the source +-- queue will remain unchanged (even if some of the buffers could have been +-- queued). + +queueBuffers :: Source -> [Buffer] -> IO () +queueBuffers = withArraySizei . alSourceQueueBuffers + +withArraySizei :: Storable a => (ALsizei -> Ptr a -> IO ()) -> [a] -> IO () +withArraySizei f xs = withArrayLen xs $ f . fromIntegral + +foreign import CALLCONV unsafe "alSourceQueueBuffers" + alSourceQueueBuffers :: Source -> ALsizei -> Ptr Buffer -> IO () + +-------------------------------------------------------------------------------- + +-- | Once a queue entry for a buffer has been appended to a queue and is pending +-- processing, it should not be changed. Removal of a given queue entry is not +-- possible unless either the source is stopped (in which case then entire queue +-- is considered processed), or if the queue entry has already been processed +-- ('Playing' or 'Paused' source). A playing source will enter the 'Stopped' +-- state if it completes playback of the last buffer in its queue (the same +-- behavior as when a single buffer has been attached to a source and has +-- finished playback). +-- +-- The 'unqueueBuffers' command removes a number of buffers entries that have +-- finished processing, in the order of appearance, from the queue. The +-- operation will fail with an 'ALInvalidValue' error if more buffers are +-- requested than available, leaving the destination arguments unchanged. + +unqueueBuffers :: Source -> [Buffer] -> IO () +unqueueBuffers = withArraySizei . alSourceUnqueueBuffers + +foreign import CALLCONV unsafe "alSourceUnqueueBuffers" + alSourceUnqueueBuffers :: Source -> ALsizei -> Ptr Buffer -> IO () + +-------------------------------------------------------------------------------- +-- $ManagingSourceExecution +-- The execution state of a source can be queried. OpenAL provides a set of +-- functions that initiate state transitions causing sources to start and stop +-- execution. + +-------------------------------------------------------------------------------- + +-- | Contains the current execution state of the given source. The initial state +-- of any source is 'Initial'. +-- +-- Note that the 'Initial' state is not necessarily identical to the initial +-- state in which a source is created, because the other source attributes are +-- not automatically reset to their initial values. 'Initial' merely indicates +-- that the source can be executed using the 'play' command. A 'Stopped' or +-- 'Initial' source can be reset into the default configuration by using a +-- sequence of source commands as necessary. As the application has to specify +-- all relevant state anyway to create a useful source configuration, no reset +-- command is provided. + +sourceState :: Source -> GettableStateVar SourceState +sourceState source = + makeGettableStateVar + (makeGetter dictSourceState GetSourceState source) + +-------------------------------------------------------------------------------- -{- -sourcei/sourcef/sourcefv: -AL_BUFFER -AL_CONE_INNER_ANGLE -AL_CONE_OUTER_ANGLE -AL_CONE_OUTER_GAIN -AL_DIRECTION -AL_GAIN -AL_GAIN_LINEAR_LOKI -AL_LOOPING -AL_MAX_DISTANCE -AL_MAX_GAIN -AL_MIN_GAIN -AL_PITCH -AL_POSITION -AL_REFERENCE_DISTANCE -AL_ROLLOFF_FACTOR -AL_SOURCE_RELATIVE -AL_STREAMING -AL_VELOCITY - -getsourceiv -AL_BUFFERS_PROCESSED -AL_BUFFERS_QUEUED -AL_BYTE_LOKI -AL_CONE_INNER_ANGLE -AL_CONE_OUTER_ANGLE -AL_CONE_OUTER_GAIN -AL_DIRECTION -AL_GAIN -AL_GAIN_LINEAR_LOKI -AL_LOOPING -AL_MAX_DISTANCE -AL_PITCH -AL_POSITION -AL_REFERENCE_DISTANCE -AL_ROLLOFF_FACTOR -AL_SOURCE_RELATIVE -AL_SOURCE_STATE -AL_STREAMING -AL_VELOCITY - -getsourcefv -*AL_BUFFER -AL_BUFFERS_PROCESSED -AL_BUFFERS_QUEUED -AL_BYTE_LOKI -AL_CONE_INNER_ANGLE -AL_CONE_OUTER_ANGLE -AL_CONE_OUTER_GAIN -AL_DIRECTION -AL_GAIN -AL_GAIN_LINEAR_LOKI -AL_LOOPING -AL_MAX_DISTANCE -*AL_MAX_GAIN -*AL_MIN_GAIN -AL_PITCH -AL_POSITION -AL_REFERENCE_DISTANCE -AL_ROLLOFF_FACTOR -AL_SOURCE_RELATIVE -AL_SOURCE_STATE -AL_STREAMING -AL_VELOCITY +-- | 'play' applied to an 'Initial' source will promote the source to 'Playing', +-- thus the data found in the buffer will be fed into the processing, starting +-- at the beginning. 'play' applied to a 'Playing' source will restart the +-- source from the beginning. It will not affect the configuration, and will +-- leave the source in 'Playing' state, but reset the sampling offset to the +-- beginning. 'play' applied to a 'Paused' source will resume processing using +-- the source state as preserved at the 'pause' operation. 'play' applied to a +-- 'Stopped' source will propagate it to 'Initial' then to 'Playing' +-- immediately. + +play :: [Source] -> IO () +play = withArraySizei alSourcePlayv + +foreign import CALLCONV unsafe "alSourcePlayv" + alSourcePlayv :: ALsizei -> Ptr Source -> IO () + +-- | 'pause' applied to an 'Initial' source is a legal NOP. 'pause' applied to a +-- 'Playing' source will change its state to 'Paused'. The source is exempt from +-- processing, its current state is preserved. 'pause' applied to a 'Paused' +-- source is a legal NOP. 'pause' applied to a 'Stopped' source is a legal NOP. + +pause :: [Source] -> IO () +pause = withArraySizei alSourcePausev + +foreign import CALLCONV unsafe "alSourcePausev" + alSourcePausev :: ALsizei -> Ptr Source -> IO () + +-- | 'stop' applied to an 'Initial' source is a legal NOP. 'stop' applied to a +-- 'Playing' source will change its state to 'Stopped'. The source is exempt +-- from processing, its current state is preserved. 'stop' applied to a 'Paused' +-- source will change its state to 'Stopped', with the same consequences as on a +-- 'Playing' source. 'stop' applied to a 'Stopped' source is a legal NOP. + +stop :: [Source] -> IO () +stop = withArraySizei alSourceStopv + +foreign import CALLCONV unsafe "alSourceStopv" + alSourceStopv :: ALsizei -> Ptr Source -> IO () + +-- | 'rewind' applied to an 'Initial' source is a legal NOP. 'rewind' applied to +-- a 'Playing' source will change its state to 'Stopped' then 'Initial'. The +-- source is exempt from processing: its current state is preserved, with the +-- exception of the sampling offset, which is reset to the beginning. 'rewind' +-- applied to a 'Paused' source will change its state to 'Initial', with the +-- same consequences as on a 'Playing' source. 'rewind' applied to an 'Stopped' +-- source promotes the source to 'Initial', resetting the sampling offset to the +-- beginning. +rewind :: [Source] -> IO () +rewind = withArraySizei alSourceRewindv --} +foreign import CALLCONV unsafe "alSourceRewindv" + alSourceRewindv :: ALsizei -> Ptr Source -> IO () diff -uNr --exclude=autom4te.cache --exclude=.cvsignore hugs98-Mar2005-patched/fptools/libraries/OpenAL/Sound/OpenAL/AL/SourceState.hs ghc-6.4.2/libraries/OpenAL/Sound/OpenAL/AL/SourceState.hs --- hugs98-Mar2005-patched/fptools/libraries/OpenAL/Sound/OpenAL/AL/SourceState.hs 1970-01-01 09:00:00.000000000 +0900 +++ ghc-6.4.2/libraries/OpenAL/Sound/OpenAL/AL/SourceState.hs 2006-03-22 00:58:03.000000000 +0900 @@ -0,0 +1,46 @@ +-- #hide +-------------------------------------------------------------------------------- +-- | +-- Module : Sound.OpenAL.AL.SourceState +-- Copyright : (c) Sven Panne 2003-2005 +-- License : BSD-style (see the file libraries/OpenAL/LICENSE) +-- +-- Maintainer : sven.panne@aedion.de +-- Stability : provisional +-- Portability : portable +-- +-------------------------------------------------------------------------------- + +module Sound.OpenAL.AL.SourceState ( + SourceState(..), unmarshalSourceState +) where + +import Sound.OpenAL.AL.BasicTypes ( ALint ) +import Sound.OpenAL.Constants ( al_INITIAL, al_PLAYING, al_PAUSED, al_STOPPED ) + +-------------------------------------------------------------------------------- + +-- | Each source can be in one of four possible execution states: 'Initial', +-- 'Playing', 'Paused', 'Stopped'. Sources that are either 'Playing' or 'Paused' +-- are considered active. Sources that are 'Stopped' or 'Initial' are considered +-- inactive. Only 'Playing' sources are included in the processing. The +-- implementation is free to skip those processing stages for sources that have +-- no effect on the output (e.g. mixing for a source muted by zero gain, but not +-- sample offset increments). Depending on the current state of a source certain +-- (e.g. repeated) state transition commands are legal NOPs: they will be +-- ignored, no error is generated. + +data SourceState = + Initial + | Playing + | Paused + | Stopped + deriving ( Eq, Ord, Show ) + +unmarshalSourceState :: ALint -> SourceState +unmarshalSourceState x + | x == al_INITIAL = Initial + | x == al_PLAYING = Playing + | x == al_PAUSED = Paused + | x == al_STOPPED = Stopped + | otherwise = error ("unmarshalSourceState: illegal value " ++ show x) diff -uNr --exclude=autom4te.cache --exclude=.cvsignore hugs98-Mar2005-patched/fptools/libraries/OpenAL/Sound/OpenAL/AL/String.hs ghc-6.4.2/libraries/OpenAL/Sound/OpenAL/AL/String.hs --- hugs98-Mar2005-patched/fptools/libraries/OpenAL/Sound/OpenAL/AL/String.hs 1970-01-01 09:00:00.000000000 +0900 +++ ghc-6.4.2/libraries/OpenAL/Sound/OpenAL/AL/String.hs 2006-03-22 00:58:03.000000000 +0900 @@ -0,0 +1,31 @@ +-- #hide +-------------------------------------------------------------------------------- +-- | +-- Module : Sound.OpenAL.AL.String +-- Copyright : (c) Sven Panne 2005 +-- License : BSD-style (see the file libraries/OpenAL/LICENSE) +-- +-- Maintainer : sven.panne@aedion.de +-- Stability : provisional +-- Portability : portable +-- +-------------------------------------------------------------------------------- + +module Sound.OpenAL.AL.String ( + withALString, peekALString +) where + +import Foreign.C.String ( withCString, peekCString ) +import Foreign.Ptr ( Ptr, castPtr ) +import Sound.OpenAL.AL.BasicTypes ( ALchar ) + +-------------------------------------------------------------------------------- + +-- AL uses "Ptr ALchar" instead of "CString" for strings, so some wrappers +-- are quite handy. + +withALString :: String -> (Ptr ALchar -> IO a) -> IO a +withALString str action = withCString str (action . castPtr) + +peekALString :: Ptr ALchar -> IO String +peekALString = peekCString . castPtr diff -uNr --exclude=autom4te.cache --exclude=.cvsignore hugs98-Mar2005-patched/fptools/libraries/OpenAL/Sound/OpenAL/AL/StringQueries.hs ghc-6.4.2/libraries/OpenAL/Sound/OpenAL/AL/StringQueries.hs --- hugs98-Mar2005-patched/fptools/libraries/OpenAL/Sound/OpenAL/AL/StringQueries.hs 1970-01-01 09:00:00.000000000 +0900 +++ ghc-6.4.2/libraries/OpenAL/Sound/OpenAL/AL/StringQueries.hs 2006-03-22 00:58:03.000000000 +0900 @@ -0,0 +1,34 @@ +-------------------------------------------------------------------------------- +-- | +-- Module : Sound.OpenAL.AL.StringQueries +-- Copyright : (c) Sven Panne 2003-2005 +-- License : BSD-style (see the file libraries/OpenAL/LICENSE) +-- +-- Maintainer : sven.panne@aedion.de +-- Stability : provisional +-- Portability : portable +-- +-- This module corresponds to section 3.1.2 (String Queries) of the OpenAL +-- Specification and Reference (version 1.1). +-- +-------------------------------------------------------------------------------- + +module Sound.OpenAL.AL.StringQueries ( + alVendor, alRenderer +) where + +import Graphics.Rendering.OpenGL.GL.StateVar ( + GettableStateVar, makeGettableStateVar ) +import Sound.OpenAL.AL.QueryUtils ( StringName(..), getString ) + +-------------------------------------------------------------------------------- + +-- | Contains the name of the vendor. + +alVendor :: GettableStateVar String +alVendor = makeGettableStateVar (getString Vendor) + +-- | Contains information about the specific renderer. + +alRenderer :: GettableStateVar String +alRenderer = makeGettableStateVar (getString Renderer) diff -uNr --exclude=autom4te.cache --exclude=.cvsignore hugs98-Mar2005-patched/fptools/libraries/OpenAL/Sound/OpenAL/AL.hs ghc-6.4.2/libraries/OpenAL/Sound/OpenAL/AL.hs --- hugs98-Mar2005-patched/fptools/libraries/OpenAL/Sound/OpenAL/AL.hs 2004-01-03 04:03:07.000000000 +0900 +++ ghc-6.4.2/libraries/OpenAL/Sound/OpenAL/AL.hs 2006-03-22 00:58:03.000000000 +0900 @@ -1,23 +1,128 @@ -------------------------------------------------------------------------------- -- | -- Module : Sound.OpenAL.AL --- Copyright : (c) Sven Panne 2003-2004 +-- Copyright : (c) Sven Panne 2003-2005 -- License : BSD-style (see the file libraries/OpenAL/LICENSE) -- -- Maintainer : sven.panne@aedion.de -- Stability : provisional -- Portability : portable -- +-- This module corresponds to chapters 2 (OpenAL Operation), 3 (State and State +-- Requests), 4 (Listener and Sources) and 5 (Buffers) of the OpenAL +-- Specification and Reference (version 1.1). +-- -------------------------------------------------------------------------------- module Sound.OpenAL.AL ( + -- * OpenAL Fundamentals + -- $OpenALFundamentals + + -- * Basic AL Operation + -- $BasicALOperation + + -- * Time and Frequency + -- $TimeAndFrequency + + -- * Space and Distance + -- $SpaceAndDistance + + -- * Coordinate System + -- $CoordinateSystem + module Sound.OpenAL.AL.BasicTypes, - module Sound.OpenAL.AL.Buffer, + module Sound.OpenAL.AL.Errors, + module Sound.OpenAL.AL.StringQueries, + module Sound.OpenAL.AL.Attenuation, + module Sound.OpenAL.AL.Doppler, + module Sound.OpenAL.AL.Listener, module Sound.OpenAL.AL.Source, - module Sound.OpenAL.AL.Listener + module Sound.OpenAL.AL.Buffer, + module Sound.OpenAL.AL.Extensions ) where import Sound.OpenAL.AL.BasicTypes -import Sound.OpenAL.AL.Buffer -import Sound.OpenAL.AL.Source +import Sound.OpenAL.AL.Errors +import Sound.OpenAL.AL.StringQueries +import Sound.OpenAL.AL.Attenuation +import Sound.OpenAL.AL.Doppler import Sound.OpenAL.AL.Listener +import Sound.OpenAL.AL.Source +import Sound.OpenAL.AL.Buffer +import Sound.OpenAL.AL.Extensions + +-------------------------------------------------------------------------------- +-- $OpenALFundamentals +-- OpenAL is concerned with rendering audio into an output buffer and collecting +-- audio data from an input buffer. OpenAL\'s primary use is assumed to be for +-- spatialized audio. There is no support for MIDI. +-- +-- OpenAL has three fundamental primitives or objects: 'Buffer's, 'Source's, and +-- a single listener (see "Sound.OpenAL.AL.Listener"). Each object can be +-- changed independently; the setting of one object does not affect the setting +-- of others. The application can also set modes that affect processing. Modes +-- are set, objects specified, and other OpenAL operations performed by sending +-- commands in the form of function or procedure calls. +-- +-- Sources store locations, directions, and other attributes of an object in 3D +-- space and have a buffer associated with them for playback. When the program +-- wants to play a sound, it controls execution through a source object. Sources +-- are processed independently from each other. +-- +-- Buffers store compressed or uncompressed audio data. It is common to +-- initialize a large set of buffers when the program first starts (or at +-- non-critical times during execution, between levels in a game, for +-- instance). Buffers are referred to by sources. Data (audio sample data) is +-- associated with buffers. +-- +-- There is only one listener (per audio context). The listener attributes are +-- similar to source attributes, but are used to represent where the user is +-- hearing the audio from. The influence of all the sources from the perspective +-- of the listener is mixed and played for the user. + +-------------------------------------------------------------------------------- +-- $BasicALOperation +-- OpenAL can be used for a variety of audio playback tasks, and is an excellent +-- complement to OpenGL for real-time rendering, see +-- "Graphics.Rendering.OpenGL". A programmer who is familiar with OpenGL will +-- immediately notice the similarities between the two APIs in that they +-- describe their 3D environments using similar methods. +-- +-- For an OpenGL\/OpenAL program, most of the audio programming will be in two +-- places in the code: initialization of the program, and the rendering loop. An +-- OpenGL\/OpenAL program will typically contain a section where the graphics +-- and audio systems are initialized, although it may be spread into multiple +-- functions. For OpenAL, initialization normally consists of creating a +-- context, creating the initial set of buffers, loading the buffers with sample +-- data, creating sources, attaching buffers to sources, setting locations and +-- directions for the listener and sources, and setting the initial values for +-- state global to OpenAL. + +-------------------------------------------------------------------------------- +-- $TimeAndFrequency +-- By default, OpenAL uses seconds and Hertz as units for time and frequency, +-- respectively. A float or integral value of one for a variable that specifies +-- quantities like duration, latency, delay, or any other parameter measured as +-- time, specifies 1 second. For frequency, the basic unit is 1\/second, or +-- Hertz. In other words, sample frequencies and frequency cut-offs or filter +-- parameters specifying frequencies are expressed in units of Hertz. + +-------------------------------------------------------------------------------- +-- $SpaceAndDistance +-- OpenAL does not define the units of measurement for distances. The +-- application is free to use meters, inches, or parsecs. OpenAL provides means +-- for simulating the natural attenuation of sound according to distance, and to +-- exaggerate or reduce this effect. However, the resulting effects do not +-- depend on the distance unit used by the application to express source and +-- listener coordinates. OpenAL calculations are scale invariant. The +-- specification assumes Euclidean calculation of distances, and mandates that +-- if two sources are sorted with respect to the Euclidean metric, the distance +-- calculation used by the implementation has to preserve that order. + +-------------------------------------------------------------------------------- +-- $CoordinateSystem +-- OpenAL - like OpenGL - uses a right-handed Cartesian coordinate system (RHS), +-- where in a frontal default view X (thumb) points right, Y (index finger) +-- points up, and Z (middle finger) points towards the viewer\/camera. To switch +-- from a left handed coordinate system (LHS) to a right handed coordinate +-- systems, flip the sign on the Z coordinate. diff -uNr --exclude=autom4te.cache --exclude=.cvsignore hugs98-Mar2005-patched/fptools/libraries/OpenAL/Sound/OpenAL/ALC/ALCboolean.hs ghc-6.4.2/libraries/OpenAL/Sound/OpenAL/ALC/ALCboolean.hs --- hugs98-Mar2005-patched/fptools/libraries/OpenAL/Sound/OpenAL/ALC/ALCboolean.hs 1970-01-01 09:00:00.000000000 +0900 +++ ghc-6.4.2/libraries/OpenAL/Sound/OpenAL/ALC/ALCboolean.hs 2006-03-22 00:58:03.000000000 +0900 @@ -0,0 +1,30 @@ +-- #hide +-------------------------------------------------------------------------------- +-- | +-- Module : Sound.OpenAL.ALC.ALCboolean +-- Copyright : (c) Sven Panne 2005 +-- License : BSD-style (see the file libraries/OpenAL/LICENSE) +-- +-- Maintainer : sven.panne@aedion.de +-- Stability : provisional +-- Portability : portable +-- +-- This is a purely internal module for (un-)marshaling ALCboolean. +-- +-------------------------------------------------------------------------------- + +module Sound.OpenAL.ALC.ALCboolean ( + marshalALCboolean, unmarshalALCboolean +) where + +import Sound.OpenAL.ALC.BasicTypes ( ALCboolean ) +import Sound.OpenAL.Constants ( alc_FALSE, alc_TRUE ) + +-------------------------------------------------------------------------------- + +marshalALCboolean :: Bool -> ALCboolean +marshalALCboolean False = alc_FALSE +marshalALCboolean True = alc_TRUE + +unmarshalALCboolean :: ALCboolean -> Bool +unmarshalALCboolean = (/= alc_FALSE) diff -uNr --exclude=autom4te.cache --exclude=.cvsignore hugs98-Mar2005-patched/fptools/libraries/OpenAL/Sound/OpenAL/ALC/BasicTypes.hs ghc-6.4.2/libraries/OpenAL/Sound/OpenAL/ALC/BasicTypes.hs --- hugs98-Mar2005-patched/fptools/libraries/OpenAL/Sound/OpenAL/ALC/BasicTypes.hs 2004-01-03 04:03:09.000000000 +0900 +++ ghc-6.4.2/libraries/OpenAL/Sound/OpenAL/ALC/BasicTypes.hs 2006-03-22 00:58:03.000000000 +0900 @@ -1,82 +1,24 @@ --- #hide -------------------------------------------------------------------------------- -- | -- Module : Sound.OpenAL.ALC.BasicTypes --- Copyright : (c) Sven Panne 2003-2004 +-- Copyright : (c) Sven Panne 2003-2005 -- License : BSD-style (see the file libraries/OpenAL/LICENSE) -- -- Maintainer : sven.panne@aedion.de -- Stability : provisional -- Portability : portable -- +-- This module corresponds to the introductory parts of chapter 6 (AL Contexts +-- and the ALC API) of the OpenAL Specification and Reference (version 1.1). +-- +-- The context API makes use of ALC types which are defined separately from the +-- AL types - there is an 'ALCboolean', 'ALCchar', etc. +-- -------------------------------------------------------------------------------- module Sound.OpenAL.ALC.BasicTypes ( - ALCenum, - Device(..), isDevice, fromDevice, - withALString, peekALString, - ContextAttribute(..), marshalContextAttribute, unmarshalContextAttribute + ALCboolean, ALCchar, ALCbyte, ALCubyte, ALCshort, ALCushort, ALCint, ALCuint, + ALCsizei, ALCenum, ALCfloat, ALCdouble ) where -import Foreign -import Foreign.C.String ( withCString, peekCString ) -import Sound.OpenAL.AL.BasicTypes ( ALubyte, ALint ) -import Sound.OpenAL.AL.ALboolean ( marshalALboolean, unmarshalALboolean ) -import Sound.OpenAL.AL.Buffer ( Frequency ) - --------------------------------------------------------------------------------- - -#include "HsOpenALConfig.h" - -type ALCenum = HTYPE_ALCENUM - --------------------------------------------------------------------------------- - -type ALCdevice = () - -newtype Device = Device (Ptr ALCdevice) - deriving ( Eq, Ord, Show ) - -isDevice :: Device -> Bool -isDevice (Device dev) = dev /= nullPtr - -fromDevice :: Maybe Device -> Device -fromDevice = maybe (Device nullPtr) id - --------------------------------------------------------------------------------- - --- AL uses "Ptr ALubyte" instead of "CString" for strings, so some wrappers --- are quite handy. - -withALString :: String -> (Ptr ALubyte -> IO a) -> IO a -withALString str action = withCString str (action . castPtr) - -peekALString :: Ptr ALubyte -> IO String -peekALString = peekCString . castPtr - --------------------------------------------------------------------------------- - -data ContextAttribute = - Frequency Frequency - | Refresh ALint - | Sync Bool - | Sources ALint - | Buffers ALint - deriving ( Eq, Ord, Show ) - -marshalContextAttribute :: ContextAttribute -> (ALint,ALint) -marshalContextAttribute a = case a of - Frequency f -> (CONST_ALC_FREQUENCY, fromIntegral f) - Refresh r -> (CONST_ALC_REFRESH, r) - Sync s -> (CONST_ALC_SYNC, fromIntegral (marshalALboolean s)) - Sources s -> (0x200000, s) - Buffers b -> (0x200001, b) - -unmarshalContextAttribute :: (ALint,ALint) -> ContextAttribute -unmarshalContextAttribute a@(x,y) - | x == CONST_ALC_FREQUENCY = Frequency (fromIntegral y) - | x == CONST_ALC_REFRESH = Refresh y - | x == CONST_ALC_SYNC = Sync (unmarshalALboolean (fromIntegral y)) - | x == 0x200000 = Sources y - | x == 0x200001 = Buffers y - | otherwise = error ("unmarshalContextAttribute: illegal value " ++ show a) +import Sound.OpenAL.Config diff -uNr --exclude=autom4te.cache --exclude=.cvsignore hugs98-Mar2005-patched/fptools/libraries/OpenAL/Sound/OpenAL/ALC/Capture.hs ghc-6.4.2/libraries/OpenAL/Sound/OpenAL/ALC/Capture.hs --- hugs98-Mar2005-patched/fptools/libraries/OpenAL/Sound/OpenAL/ALC/Capture.hs 1970-01-01 09:00:00.000000000 +0900 +++ ghc-6.4.2/libraries/OpenAL/Sound/OpenAL/ALC/Capture.hs 2006-03-22 00:58:03.000000000 +0900 @@ -0,0 +1,136 @@ +-------------------------------------------------------------------------------- +-- | +-- Module : Sound.OpenAL.ALC.Capture +-- Copyright : (c) Sven Panne 2005 +-- License : BSD-style (see the file libraries/OpenAL/LICENSE) +-- +-- Maintainer : sven.panne@aedion.de +-- Stability : provisional +-- Portability : portable +-- +-- This module corresponds to section 6.4.2. (Capture) of the OpenAL +-- Specification and Reference (version 1.1). +-- +-------------------------------------------------------------------------------- + +module Sound.OpenAL.ALC.Capture ( + NumSamples, captureOpenDevice, captureStart, captureNumSamples, + captureSamples, captureStop, captureCloseDevice, + captureDefaultDeviceSpecifier, captureDeviceSpecifier, + allCaptureDeviceSpecifiers +) where + +import Foreign.Ptr ( Ptr, nullPtr, FunPtr ) +import Graphics.Rendering.OpenGL.GL.StateVar ( + GettableStateVar, makeGettableStateVar, get ) +import Sound.OpenAL.AL.Buffer ( Format ) +import Sound.OpenAL.AL.Format ( marshalFormat ) +import Sound.OpenAL.ALC.ALCboolean ( unmarshalALCboolean ) +import Sound.OpenAL.ALC.BasicTypes ( + ALCchar, ALCuint, ALCenum, ALCsizei, ALCboolean ) +import Sound.OpenAL.ALC.Context ( Frequency ) +import Sound.OpenAL.ALC.Device ( Device ) +import Sound.OpenAL.ALC.Extensions ( alcProcAddress ) +import Sound.OpenAL.ALC.QueryUtils ( IntQuery(..), getInteger ) +import Sound.OpenAL.ALC.QueryUtils ( + StringQuery(..), getString, getStringRaw, alcIsExtensionPresent ) +import Sound.OpenAL.ALC.String ( withALCString, peekALCStrings ) +import Sound.OpenAL.Config ( ALCdevice, marshalDevice, unmarshalDevice ) + +-------------------------------------------------------------------------------- + +type NumSamples = ALCsizei + +-------------------------------------------------------------------------------- + +type Invoker a = FunPtr a -> a + +getCaptureFunc :: String -> IO (FunPtr a) +getCaptureFunc = get . alcProcAddress Nothing + +-------------------------------------------------------------------------------- + +captureOpenDevice :: + Maybe String -> Frequency -> Format -> NumSamples -> IO (Maybe Device) +captureOpenDevice maybeDeviceSpec frequency format size = do + funPtr <- getCaptureFunc "alcCaptureOpenDevice" + let open deviceSpec = + invokeCaptureOpenDevice funPtr deviceSpec (round frequency) + (fromIntegral (marshalFormat format)) size + fmap unmarshalDevice $ + (maybe (open nullPtr) -- use preferred device + (flip withALCString open) + maybeDeviceSpec) + +foreign import CALLCONV unsafe "dynamic" + invokeCaptureOpenDevice :: Invoker (Ptr ALCchar -> ALCuint -> ALCenum -> ALCsizei -> IO ALCdevice) + +-------------------------------------------------------------------------------- + +captureStart :: Device -> IO () +captureStart = captureStartStop "alcCaptureStart" + +captureStartStop :: String -> Device -> IO () +captureStartStop funName device = do + funPtr <- getCaptureFunc funName + invokeCaptureStartStop funPtr (marshalDevice device) + +foreign import CALLCONV unsafe "dynamic" + invokeCaptureStartStop :: Invoker (ALCdevice -> IO ()) + +-------------------------------------------------------------------------------- + +captureNumSamples :: Device -> GettableStateVar NumSamples +captureNumSamples device = + makeGettableStateVar $ getInteger (Just device) CaptureSamples + +-------------------------------------------------------------------------------- + +captureSamples :: Device -> Ptr a -> NumSamples -> IO () +captureSamples = alcCaptureSamples . marshalDevice + +foreign import CALLCONV unsafe "alcCaptureSamples" + alcCaptureSamples :: ALCdevice -> Ptr a -> NumSamples -> IO () + +-------------------------------------------------------------------------------- + +captureStop :: Device -> IO () +captureStop = captureStartStop "alcCaptureStop" + +-------------------------------------------------------------------------------- + +captureCloseDevice :: Device -> IO Bool +captureCloseDevice device = do + funPtr <- getCaptureFunc "alcCaptureCloseDevice" + fmap unmarshalALCboolean . + invokeCaptureCloseDevice funPtr . marshalDevice $ device + +foreign import CALLCONV unsafe "dynamic" + invokeCaptureCloseDevice :: Invoker (ALCdevice -> IO ALCboolean) + +-------------------------------------------------------------------------------- + +-- | Contains the name of the default capture device. + +captureDefaultDeviceSpecifier :: GettableStateVar String +captureDefaultDeviceSpecifier = makeGettableStateVar $ + getString Nothing CaptureDefaultDeviceSpecifier + +-------------------------------------------------------------------------------- + +-- | Contains the specifier string for the given capture device. + +captureDeviceSpecifier :: Device -> GettableStateVar String +captureDeviceSpecifier device = makeGettableStateVar $ + getString (Just device) CaptureDeviceSpecifier + +-------------------------------------------------------------------------------- + +-- | Contains a list of specifiers for all available capture devices. + +allCaptureDeviceSpecifiers :: GettableStateVar [String] +allCaptureDeviceSpecifiers = makeGettableStateVar $ do + enumExtPresent <- get (alcIsExtensionPresent Nothing "ALC_ENUMERATION_EXT") + if enumExtPresent + then peekALCStrings =<< getStringRaw Nothing CaptureDeviceSpecifier + else fmap (\s -> [s]) $ get captureDefaultDeviceSpecifier diff -uNr --exclude=autom4te.cache --exclude=.cvsignore hugs98-Mar2005-patched/fptools/libraries/OpenAL/Sound/OpenAL/ALC/Context.hs ghc-6.4.2/libraries/OpenAL/Sound/OpenAL/ALC/Context.hs --- hugs98-Mar2005-patched/fptools/libraries/OpenAL/Sound/OpenAL/ALC/Context.hs 2005-02-24 18:58:23.000000000 +0900 +++ ghc-6.4.2/libraries/OpenAL/Sound/OpenAL/ALC/Context.hs 2006-03-22 00:58:03.000000000 +0900 @@ -1,152 +1,198 @@ -------------------------------------------------------------------------------- -- | -- Module : Sound.OpenAL.ALC.Context --- Copyright : (c) Sven Panne 2003-2004 +-- Copyright : (c) Sven Panne 2003-2005 -- License : BSD-style (see the file libraries/OpenAL/LICENSE) -- -- Maintainer : sven.panne@aedion.de -- Stability : provisional -- Portability : portable -- --- Managing Rendering Contexts +-- This module corresponds to section 6.2 (Managing Rendering Contexts) of the +-- OpenAL Specification and Reference (version 1.1). +-- +-- All operations of the AL core API affect a current AL context. Within the +-- scope of AL, the ALC is implied - it is not visible as a handle or function +-- parameter. Only one AL Context per process can be current at a time. +-- Applications maintaining multiple AL Contexts, whether threaded or not, +-- have to set the current context accordingly. Applications can have multiple +-- threads that share one more or contexts. In other words, AL and ALC are +-- threadsafe. -- -------------------------------------------------------------------------------- module Sound.OpenAL.ALC.Context ( - ContextAttribute(..), Context, createContext, destroyContext, currentContext, - processContext, suspendContext, - - contextsDevice, allAttributes + Frequency, ContextAttribute(..), Context, createContext, currentContext, + processContext, suspendContext, destroyContext, contextsDevice, allAttributes ) where -import Control.Monad ( liftM ) import Foreign.Marshal.Array ( withArray0 ) -import Foreign.Ptr ( Ptr, nullPtr ) +import Foreign.Ptr ( Ptr ) import Graphics.Rendering.OpenGL.GL.StateVar ( StateVar, makeStateVar, GettableStateVar, makeGettableStateVar ) -import Sound.OpenAL.AL.BasicTypes ( ALint ) +import Sound.OpenAL.ALC.BasicTypes ( ALCint ) +import Sound.OpenAL.ALC.ALCboolean ( marshalALCboolean, unmarshalALCboolean ) import Sound.OpenAL.ALC.Device ( Device ) -import Sound.OpenAL.ALC.Queries ( IntQuery(..), getInteger, getIntegerv ) -import Sound.OpenAL.ALC.BasicTypes ( - ALCenum, isDevice, - ContextAttribute(..), marshalContextAttribute, unmarshalContextAttribute ) -import Sound.OpenAL.ALC.Errors ( checkError ) +import Sound.OpenAL.ALC.QueryUtils ( IntQuery(..), getInteger, getIntegerv ) +import Sound.OpenAL.Config ( + ALCdevice, marshalDevice, unmarshalDevice, + ALCcontext, Context, nullContext, marshalContext, unmarshalContext, + alcProcessContext, alcDestroyContext, alcMakeContextCurrent ) +import Sound.OpenAL.Constants ( + alc_FREQUENCY, alc_REFRESH, alc_SYNC, alc_MONO_SOURCES, alc_STEREO_SOURCES ) --------------------------------------------------------------------------------- +#ifdef __HADDOCK__ +import Sound.OpenAL.ALC.Errors ( ALCErrorCategory(..) ) +#endif -type ALCcontext = () +-------------------------------------------------------------------------------- -newtype Context = Context (Ptr ALCcontext) - deriving ( Eq, Ord, Show ) +-- | Frequency, specified in samples per second, i.e. units of Hertz \[Hz\]. +-- Note that the underlying OpenAL API currently uses integral frequencies +-- only, but we want to mirror physical reality here more closely. -isContext :: Context -> Bool -isContext (Context ctx) = ctx /= nullPtr +type Frequency = Float -------------------------------------------------------------------------------- --- | Allocates, initializes, and returns a context for the given device with the --- requested attributes. If any attribute cannot have the required value met or --- exceeded, an 'IOError' is thrown. If the device is not valid, an --- 'Sound.OpenAL.ALC.Errors.ALCInvalidDevice' error is set and an 'IOError' is --- thrown. Note that 'createContext' does /not/ set the current context, this --- must be done separately via 'currentContext'. +-- | The application can choose to specify certain attributes for a context at +-- context-creation time. Attributes not specified explicitly are set to +-- implementation dependent defaults. -createContext :: Device -> [ContextAttribute] -> IO Context -createContext device attributes = - let pairToList (key, value) = [key, value] - attrs = concatMap (pairToList . marshalContextAttribute) attributes - in checkError isContext . withArray0 0 attrs $ alcCreateContext device +data ContextAttribute = + Frequency Frequency -- ^ Frequency for mixing output buffer, in units of + -- Hz + | Refresh Frequency -- ^ Refresh intervals, in units of Hz + | Sync Bool -- ^ Flag, indicating a synchronous context + | MonoSources Int -- ^ A hint indicating how many sources should be + -- capable of supporting mono data + | StereoSources Int -- ^ A hint indicating how many sources should be + -- capable of supporting stereo data + deriving ( Eq, Ord, Show ) -foreign import CALLCONV unsafe "alcCreateContext" - alcCreateContext :: Device -> Ptr ALint -> IO Context +marshalContextAttribute :: ContextAttribute -> (ALCint,ALCint) +marshalContextAttribute a = case a of + Frequency f -> (alc_FREQUENCY, round f) + Refresh r -> (alc_REFRESH, round r) + Sync s -> (alc_SYNC, fromIntegral (marshalALCboolean s)) + MonoSources m -> (alc_MONO_SOURCES, fromIntegral m) + StereoSources s -> (alc_STEREO_SOURCES, fromIntegral s) + +unmarshalContextAttribute :: (ALCint,ALCint) -> ContextAttribute +unmarshalContextAttribute a@(x,y) + | x == alc_FREQUENCY = Frequency (fromIntegral y) + | x == alc_REFRESH = Refresh (fromIntegral y) + | x == alc_SYNC = Sync (unmarshalALCboolean (fromIntegral y)) + | x == alc_MONO_SOURCES = MonoSources (fromIntegral y) + | x == alc_STEREO_SOURCES = StereoSources (fromIntegral y) + | otherwise = error ("unmarshalContextAttribute: illegal value " ++ show a) -------------------------------------------------------------------------------- --- | Destroys the given context. +-- | Create a context for a given device and given attributes. Context creation +-- will fail in the following cases: a) if the application requests attributes +-- that, by themselves, can not be provided b) if the combination of specified +-- attributes can not be provided c) if a specified attribute, or the +-- combination of attributes, does not match the default values for unspecified +-- attributes If context creation fails, 'Nothing' will be returned, otherwise +-- 'Just' the new context. Note that 'createContext' does /not/ set the current +-- context, this must be done separately via 'currentContext'. -destroyContext :: Context -> IO () -destroyContext = ignore . alcDestroyContext +createContext :: Device -> [ContextAttribute] -> IO (Maybe Context) +createContext device attributes = do + let pairToList (key, value) = [key, value] + attrs = concatMap (pairToList . marshalContextAttribute) attributes + fmap unmarshalContext . + withArray0 0 attrs . alcCreateContext . marshalDevice $ device -foreign import CALLCONV unsafe "alcDestroyContext" - alcDestroyContext :: Context -> IO ALCenum +foreign import CALLCONV unsafe "alcCreateContext" + alcCreateContext :: ALCdevice -> Ptr ALCint -> IO ALCcontext -------------------------------------------------------------------------------- --- | 'Just' the current context, 'Nothing' means paused. +-- | Contains 'Just' the current context with respect to OpenAL operation, or +-- 'Nothing' if there is no current context. Setting it to the latter is useful +-- when shutting OpenAL down. The state variable applies 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. currentContext :: StateVar (Maybe Context) currentContext = makeStateVar getCurrentContext makeContextCurrent --- | Returns 'Just' the current context or 'Nothing' if there is none. - getCurrentContext :: IO (Maybe Context) -getCurrentContext = do - context <- alcGetCurrentContext - return $ if isContext context then Nothing else Just context +getCurrentContext = fmap unmarshalContext $ alcGetCurrentContext foreign import CALLCONV unsafe "alcGetCurrentContext" - alcGetCurrentContext :: IO Context - --- | Makes the given context the current context or pauses when given 'Nothing'. + alcGetCurrentContext :: IO ALCcontext makeContextCurrent :: Maybe Context -> IO () -makeContextCurrent mbContext = - ignore $ alcMakeContextCurrent (maybe (Context nullPtr) id mbContext) - -foreign import CALLCONV unsafe "alcMakeContextCurrent" - alcMakeContextCurrent :: Context -> IO ALCenum +makeContextCurrent = + fmap (const ()) . alcMakeContextCurrent . marshalContext . maybe nullContext id -------------------------------------------------------------------------------- --- | Performs processing on a synced context, nop on an asynchronous 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 like offset +-- increments are supposed to be performed), the application has to use +-- 'processContext'. Repeated calls to 'processContext' are legal, and do not +-- affect a context that is already marked as processing. The default state of a +-- context created by 'createContext' is that it is processing. processContext :: Context -> IO () -processContext = ignore . alcProcessContext +processContext = fmap (const ()) . alcProcessContext . marshalContext -foreign import CALLCONV unsafe "alcProcessContext" - alcProcessContext :: Context -> IO 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 like offset increments is not supposed to +-- be changed), the application has to use 'suspendContext'. Repeated calls to +-- 'suspendContext' are legal, and do not affect a context that is already +-- marked as suspended. --- | Suspends processing on an asynchronous context. This is a legal nop on a --- synced context. +suspendContext :: Context -> IO () +suspendContext = alcSuspendContext . marshalContext foreign import CALLCONV unsafe "alcSuspendContext" - suspendContext :: Context -> IO () + alcSuspendContext :: ALCcontext -> IO () -------------------------------------------------------------------------------- --- ALC's error handling is highly irregular: Somtimes a success/failure value is --- returned in addition to setting the internal error state. We don't do the --- same in our Haskell API, effectively ignoring the returned value. +-- | Destroy the given context. Note that the the correct way to destroy a +-- context is to first release it by setting 'currentContext' to +-- 'Nothing'. Applications should not attempt to destroy a current context, +-- doing so will not work and will result in an 'ALCInvalidOperation' error. -ignore :: IO a -> IO () -ignore action = do - action - return () +destroyContext :: Context -> IO () +destroyContext = fmap (const ()) . alcDestroyContext . marshalContext -------------------------------------------------------------------------------- --- | 'Just' the device of the given context or 'Nothing' if the context is --- invalid. +-- | Contains 'Just' the device of the given context or 'Nothing' if the context +-- is invalid. contextsDevice :: Context -> GettableStateVar (Maybe Device) -contextsDevice context = makeGettableStateVar $ do - device <- alcGetContextsDevice context - return $ if isDevice device then Nothing else Just device +contextsDevice = + makeGettableStateVar . + fmap unmarshalDevice . alcGetContextsDevice . marshalContext foreign import CALLCONV unsafe "alcGetContextsDevice" - alcGetContextsDevice :: Context -> IO Device + alcGetContextsDevice :: ALCcontext -> IO ALCdevice -------------------------------------------------------------------------------- --- | Note that we need a current context here! +-- | Contains the attribute list for the current context of the specified +-- device. allAttributes :: Device -> GettableStateVar [ContextAttribute] allAttributes device = makeGettableStateVar $ do - numALints <- liftM fromIntegral $ getInteger device AttributesSize - liftM toContextAttributes $ getIntegerv device AllAttributes numALints + numALCints <- fmap fromIntegral $ getInteger (Just device) AttributesSize + fmap toContextAttributes $ getIntegerv (Just device) AllAttributes numALCints -toContextAttributes :: [ALint] -> [ContextAttribute] +toContextAttributes :: [ALCint] -> [ContextAttribute] toContextAttributes xs = case xs of [] -> [] -- should only happen when device and/or current context is invalid (0:_) -> [] diff -uNr --exclude=autom4te.cache --exclude=.cvsignore hugs98-Mar2005-patched/fptools/libraries/OpenAL/Sound/OpenAL/ALC/Device.hs ghc-6.4.2/libraries/OpenAL/Sound/OpenAL/ALC/Device.hs --- hugs98-Mar2005-patched/fptools/libraries/OpenAL/Sound/OpenAL/ALC/Device.hs 2004-04-05 23:15:54.000000000 +0900 +++ ghc-6.4.2/libraries/OpenAL/Sound/OpenAL/ALC/Device.hs 2006-03-22 00:58:03.000000000 +0900 @@ -1,79 +1,223 @@ -------------------------------------------------------------------------------- -- | -- Module : Sound.OpenAL.ALC.Device --- Copyright : (c) Sven Panne 2003-2004 +-- Copyright : (c) Sven Panne 2003-2005 -- License : BSD-style (see the file libraries/OpenAL/LICENSE) -- -- Maintainer : sven.panne@aedion.de -- Stability : provisional -- Portability : portable -- --- Managing Devices +-- This module corresponds to section 6.1 (Managing Devices) of the OpenAL +-- Specification and Reference (version 1.1). +-- +-- ALC introduces the notion of a device. A device can be, depending on the +-- implementation, a hardware device, or a daemon\/OS service\/actual +-- server. This mechanism also permits different drivers (and hardware) to +-- coexist within the same system, as well as allowing several applications to +-- share system resources for audio, including a single hardware output +-- device. The details are left to the implementation, which has to map the +-- available backends to unique device specifiers. -- -------------------------------------------------------------------------------- module Sound.OpenAL.ALC.Device ( Device, openDevice, closeDevice, - deviceSpecifier, alcVersion, - defaultDeviceSpecifier, allDeviceSpecifiers + defaultDeviceSpecifier, deviceSpecifier, allDeviceSpecifiers ) where -import Control.Monad ( liftM, liftM2 ) import Foreign.Ptr ( Ptr, nullPtr ) +import Foreign.Marshal.Utils ( maybePeek ) import Graphics.Rendering.OpenGL.GL.StateVar ( GettableStateVar, makeGettableStateVar, get ) -import Sound.OpenAL.AL.BasicTypes ( ALubyte, ALint ) -import Sound.OpenAL.ALC.Queries( - StringQuery(..), alcGetString, alcGetString_, - IntQuery(..), getInteger, - alcIsExtensionPresent ) -import Sound.OpenAL.ALC.BasicTypes ( Device, isDevice, withALString ) -import Sound.OpenAL.ALC.Errors ( checkError ) +import Sound.OpenAL.ALC.BasicTypes ( ALCchar ) +import Sound.OpenAL.ALC.QueryUtils ( + StringQuery(..), getString, getStringRaw, alcIsExtensionPresent ) +import Sound.OpenAL.ALC.String ( withALCString, peekALCString, peekALCStrings ) +import Sound.OpenAL.Config ( + Device, ALCdevice, unmarshalDevice, closeDevice ) -------------------------------------------------------------------------------- --- | Opens a device, using an alrc expression to specify attributes for the --- device. Throws an IOError on failure. The ALC error flag is cleared in any --- case. +-- | 'openDevice' allows the application (i.e. the client program) to connect to +-- a device (i.e. the server). If the function returns 'Nothing', then no sound +-- driver\/device has been found. The argument to 'openDevice' specifies a +-- certain device or device configuration. If it is 'Nothing', the +-- implementation will provide an implementation specific default, see +-- 'defaultDeviceSpecifier'. Otherwise it is 'Just' an implementation-dependent +-- string. You can use 'allDeviceSpecifiers' to get a list of the known OpenAL +-- devices. +-- +-- /Notes for Windows:/ There are 3 possible device strings, each having a +-- deprecated equivalent for legacy applications only: +-- +-- * @\"Generic Hardware\"@ (legacy string: @\"DirectSound3D\"@) +-- +-- * @\"Generic Software\"@ (legacy string: @\"DirectSound\"@) +-- +-- * @\"Generic Software Fallback\"@ (legacy string: @\"MMSYSTEM\"@) +-- +-- /Notes for Linux\/\*nix:/ If an @.openalrc@ file is present in the user\'s +-- home directory, it is loaded first, otherwise @\/etc\/openalrc@ is tried. +-- The bindings (if any) of @devices@, @direction@, @sampling-rate@, and +-- @speaker-num@ (see below) after loading one of these files take precedence +-- over any bindings done via the argument to 'openDevice'. +-- +-- The syntax of these files is lisp-based and a sequence of expressions, where +-- an expression is one the following: +-- +-- * A boolean value of the form @\#f@ or @\#t@, which evaluate to /false/ and +-- /true/, respectively. +-- +-- * An non-negative integer value, i.e. a sequence of decimal digits, +-- evaluating to itself. +-- +-- * A (signed) floating point value, as recoginzed by C\'s @atof()@, evaluating +-- to itself. +-- +-- * A pointer value of the form @\#p/num/@, where /num/ can be an octal, +-- decimal or hexadecimal value, as recoginzed by C\`s @strtol()@, evaluating +-- to itself. This kind of expression is currently unused. +-- +-- * A string, i.e. a sequence of printable\/whitespace characters between +-- double quotes, evaluating to itself. +-- +-- * A symbol, i.e. a sequence of almost all characters which don\'t form a +-- simple expression like the ones mentioned below, e.g. @foo@, @bar1@, @3baz@, +-- ... The symbol evaluates to the value currently bound to it. +-- +-- * A function application of the form @(/symbol/ /expression/...)@. The +-- function bound to the symbol is applied to the evaluated arguments. +-- +-- * A quotation of the form @(quote /expression/)@ or @\'/expression/@, +-- evaluating to the unevaluated /expression/ itself. +-- +-- * A definition of the form @(define /symbol/ /expression/)@, binding /symbol/ +-- to the value of /expression/. The whole expression evaluates to the value of +-- /expression/, too. +-- +-- * A conjunction of boolean expressions of the form @(and /expression/...)@. +-- Each /expression/ is evaluated in turn, and if one of them evaluates to +-- /false/, the value of the whole expression is /false/. Otherwise the value is +-- /true/. +-- +-- * An extension loading mechanism of the form @(load-extension +-- /libraryName/)@, where /libraryName/ has to evaluate to a string. This tries +-- to load the dynamic library with up to 3 special entry points: +-- @alExtension_03282000@ (pointing to a mandatory NULL-terminated sequence of +-- pairs of pointers to names and extension functions), @alExtInit_03282000@ (an +-- optional initialization function), and @alExtFini_03282000@ (an optional +-- cleanup function). If the extension could be loaded successfully, the whole +-- expression evaluates to /true/, otherwise to /false/. +-- +-- Some symbols have a special meaning for OpenAL: +-- +-- [@devices@] Has the form @(/devspec/...)@, where /devspec/ is either a +-- symbol\/string specifying a device or @(/device/ /device-param/...)@, +-- specifying a device with additional parameters. These optional device +-- parameters are stored in a variable @device-params@, but are currently +-- unused. The first device which can successfully opened is used. +-- +-- [@direction@] Type string or symbol: @\"read\"@ specifies that the device +-- should be an input device, everything else means output device (default). +-- +-- [@sampling-rate@] Type integer or float: Specifies the internal mixing +-- frequency, default is 44.1kHz. +-- +-- [@speaker-num@] Type integer or float: Specifies the number of speakers, +-- which can be 1, 2 (default), or 4. +-- +-- [@alsa-device@] Type string, @alsa@ backend only: Specifies both +-- @alsa-out-device@ and @alsa-in-device@, default @\"plughw:0,0\"@. +-- +-- [@alsa-out-device@] Type string, @alsa@ backend only: Specifies the ALSA +-- output device, defaults to the value of @alsa-device@. +-- +-- [@alsa-in-device@] Type string, @alsa@ backend only: Specifies the ALSA +-- input device, defaults to the value of @alsa-device@. +-- +-- [@native-in-device@] Type string, @native@ backend on IRIX only. +-- +-- [@native-out-device@] Type string, @native@ backend on IRIX only. +-- +-- [@native-rear-out-device@] Type string, @native@ backend on IRIX only. +-- +-- [@native-use-select@] Type boolean, @native@ backend on Linux only: If @\#t@, +-- wait up to 0.8sec for the device to become ready for writing. If @\#f@, just +-- try to write and hope it won\'t hang forever. The latter might be necessary +-- for some drivers which don\'t implement @select()@ , like some Aureal +-- drivers. +-- +-- [@lin-dsp-path@] Type string, @native@ backend on Linux only: Path to DSP +-- device for writing, tried before @\/dev\/sound\/dsp@ and @\/dev\/sound@ if +-- set. +-- +-- [@lin-dsp-read-path@] Type string, @native@ backend on Linux only: Path to +-- DSP device for reading, tried before @\/dev\/sound\/dsp@ and @\/dev\/sound@ +-- if set. Defaults to the value of @lin-dsp-path@. +-- +-- [@native-backend-debug@] Type boolean, @native@ backend on Darwin only: If +-- set to @\#f@, be a bit verbose on stderr about what\'s going on in the +-- backend. +-- +-- [@source-rolloff-factor@] Type integer or float: Value of the initial rolloff +-- factor for sources, default is @1.0@. +-- +-- [@listener-position@] List of 3 integers or floats: Value of the initial +-- listener position, default is @(0 0 0)@. +-- +-- [@listener-velocity@] List of 3 integers or floats: Value of the initial +-- listener velocity, default is @(0 0 0)@. +-- +-- [@listener-orientation@] List of 6 integers or floats: Value of the initial +-- listener orientation (at\/up), default is @(0 0 -1 0 1 0)@. +-- +-- The string given to 'openDevice' has to be of the form @\'((/symbol/ +-- /expression/) ...)@, which means basically a sequence of @define@ +-- expressions. Example: +-- +-- @ +-- \"\'((sampling-rate 8000) (native-backend-debug \#f))\" +-- @ +-- +-- /Note:/ The information above has been reverse-engineered from the OpenAL SI +-- and could be inaccurate. Any corrections and\/or additions are highly +-- welcome. -openDevice :: Maybe String -> IO Device +openDevice :: Maybe String -> IO (Maybe Device) openDevice maybeDeviceSpec = - checkError isDevice $ + fmap unmarshalDevice $ maybe (alcOpenDevice nullPtr) -- use preferred device - (flip withALString alcOpenDevice) + (flip withALCString alcOpenDevice) maybeDeviceSpec foreign import CALLCONV unsafe "alcOpenDevice" - alcOpenDevice :: Ptr ALubyte -> IO Device + alcOpenDevice :: Ptr ALCchar -> IO ALCdevice + +-------------------------------------------------------------------------------- --- | Closes the given device. +-- | Contains 'Just' the specifier string for the default device or 'Nothing' if +-- there is no sound support at all. -foreign import CALLCONV unsafe "alcCloseDevice" - closeDevice :: Device -> IO () +defaultDeviceSpecifier :: GettableStateVar (Maybe String) +defaultDeviceSpecifier = makeGettableStateVar $ + getStringRaw Nothing DefaultDeviceSpecifier >>= maybePeek peekALCString -------------------------------------------------------------------------------- +-- | Contains the specifier string for the given device. + deviceSpecifier :: Device -> GettableStateVar String deviceSpecifier device = makeGettableStateVar $ - alcGetString (Just device) DeviceSpecifier - --------------------------------------------------------------------------------- - -alcVersion :: Device -> GettableStateVar (ALint, ALint) -- ToDo: Without Device????? -alcVersion device = makeGettableStateVar $ - liftM2 (,) (getInteger device MajorVersion) (getInteger device MinorVersion) + getString (Just device) DeviceSpecifier -------------------------------------------------------------------------------- -defaultDeviceSpecifier :: GettableStateVar String -defaultDeviceSpecifier = makeGettableStateVar $ - alcGetString Nothing DefaultDeviceSpecifier +-- | Contains a list of specifiers for all available devices. allDeviceSpecifiers :: GettableStateVar [String] allDeviceSpecifiers = makeGettableStateVar $ do - enumExtPresent <- alcIsExtensionPresent Nothing "ALC_ENUMERATION_EXT" + enumExtPresent <- get (alcIsExtensionPresent Nothing "ALC_ENUMERATION_EXT") if enumExtPresent - then do - ptr <- alcGetString_ Nothing DeviceSpecifier - return [] -- Todo!!!!! - else liftM (\s -> [s]) $ get defaultDeviceSpecifier + then getStringRaw Nothing DeviceSpecifier >>= peekALCStrings + else get defaultDeviceSpecifier >>= (return . maybe [] (\s -> [s])) diff -uNr --exclude=autom4te.cache --exclude=.cvsignore hugs98-Mar2005-patched/fptools/libraries/OpenAL/Sound/OpenAL/ALC/Errors.hs ghc-6.4.2/libraries/OpenAL/Sound/OpenAL/ALC/Errors.hs --- hugs98-Mar2005-patched/fptools/libraries/OpenAL/Sound/OpenAL/ALC/Errors.hs 2004-01-03 04:03:09.000000000 +0900 +++ ghc-6.4.2/libraries/OpenAL/Sound/OpenAL/ALC/Errors.hs 2006-03-22 00:58:03.000000000 +0900 @@ -1,65 +1,93 @@ -------------------------------------------------------------------------------- -- | -- Module : Sound.OpenAL.ALC.Errors --- Copyright : (c) Sven Panne 2003-2004 +-- Copyright : (c) Sven Panne 2003-2005 -- License : BSD-style (see the file libraries/OpenAL/LICENSE) -- -- Maintainer : sven.panne@aedion.de -- Stability : provisional -- Portability : portable -- --- Errors +-- This module corresponds to section 6.3.6 (Query for Error Conditions) of the +-- OpenAL Specification and Reference (version 1.1). -- -------------------------------------------------------------------------------- module Sound.OpenAL.ALC.Errors ( - ALCerror(..), alcGetError, checkError + ALCError(..), ALCErrorCategory(..), alcErrors ) where -import Sound.OpenAL.ALC.BasicTypes ( ALCenum, Device, fromDevice ) +import Graphics.Rendering.OpenGL.GL.StateVar ( + GettableStateVar, makeGettableStateVar ) +import Sound.OpenAL.ALC.BasicTypes ( ALCenum ) +import Sound.OpenAL.ALC.Device ( Device ) +import Sound.OpenAL.ALC.QueryUtils ( StringQuery(..), getString ) +import Sound.OpenAL.Constants ( + alc_NO_ERROR, alc_INVALID_DEVICE, alc_INVALID_CONTEXT, alc_INVALID_ENUM, + alc_INVALID_VALUE, alc_OUT_OF_MEMORY, alc_INVALID_OPERATION ) +import Sound.OpenAL.Config ( ALCdevice, marshalDevice ) -------------------------------------------------------------------------------- -#include "HsOpenALConfig.h" +-- | ALC errors consist of a general error category and a description of what +-- went wrong. + +data ALCError = ALCError ALCErrorCategory String + deriving ( Eq, Ord, Show ) -------------------------------------------------------------------------------- -data ALCerror = - ALCInvalidDevice - | ALCInvalidContext - | ALCInvalidEnum +-- | General ALC error categories. + +data ALCErrorCategory = + ALCInvalidEnum | ALCInvalidValue + | ALCInvalidOperation + | ALCInvalidDevice + | ALCInvalidContext | ALCOutOfMemory deriving ( Eq, Ord, Show ) -unmarshalALCerror :: ALCenum -> ALCerror -unmarshalALCerror x - | x == CONST_ALC_INVALID_DEVICE = ALCInvalidDevice - | x == CONST_ALC_INVALID_CONTEXT = ALCInvalidContext - | x == CONST_ALC_INVALID_ENUM = ALCInvalidEnum - | x == CONST_ALC_INVALID_VALUE = ALCInvalidValue - | x == CONST_ALC_OUT_OF_MEMORY = ALCOutOfMemory - | otherwise = error ("unmarshalALCerror: illegal value " ++ show x) +unmarshalALCErrorCategory :: ALCenum -> ALCErrorCategory +unmarshalALCErrorCategory x + | x == alc_INVALID_ENUM = ALCInvalidEnum + | x == alc_INVALID_VALUE = ALCInvalidValue + | x == alc_INVALID_OPERATION = ALCInvalidOperation + | x == alc_INVALID_DEVICE = ALCInvalidDevice + | x == alc_INVALID_CONTEXT = ALCInvalidContext + | x == alc_OUT_OF_MEMORY = ALCOutOfMemory + | otherwise = error ("unmarshalALCErrorCategory: illegal value " ++ show x) -------------------------------------------------------------------------------- -alcGetError :: Maybe Device -> IO (Maybe ALCerror) -- ToDo: The device is always unused! -alcGetError device = do - e <- alcGetError_ (fromDevice device) - return $ if e == CONST_ALC_NO_ERROR then Nothing else Just (unmarshalALCerror e) +-- | OpenAL detects only a subset of those conditions that could be considered +-- errors. This is because in many cases error checking would adversely impact +-- the performance of an error-free program. The state variable 'alcErrors' is +-- used to obtain error information. When an error is detected by ALC, a flag is +-- set and the error code is recorded. Further errors, if they occur, do not +-- affect this recorded code. When 'alcErrors' is read, the error for the given +-- device is returned and the flag is cleared, so that a further error will +-- again record its code. If reading 'alcErrors' returns @\[\]@ then there has +-- been no detectable error since the last time 'alcErrors' (or since the ALC +-- was initialized). +-- +-- When an error flag is set, results of ALC operations are undefined only if +-- 'ALCOutOfMemory' has occurred. In other cases, the command generating the +-- error is ignored so that it has no effect on ALC state or output buffer +-- contents. If the error generating command returns a value, it returns zero. +-- If the generating command modifies values through a pointer argument, no +-- change is made to these values. These error semantics apply only to ALC +-- errors, not to system errors such as memory access errors. + +alcErrors :: Device -> GettableStateVar [ALCError] +alcErrors device = + makeGettableStateVar $ do + c <- alcGetError (marshalDevice device) + if c == alc_NO_ERROR + then return [] + else do + s <- getString (Just device) (ALCErrorCategory c) + return [ ALCError (unmarshalALCErrorCategory c) s ] foreign import CALLCONV unsafe "alcGetError" - alcGetError_ :: Device -> IO ALCenum - --------------------------------------------------------------------------------- - --- OpenAL does not always set the error flag, especially for out of memory --- conditions, so we hack around this fact below. *sigh* -checkError :: (a -> Bool) -> IO a -> IO a -checkError predicate action = do - alcGetError Nothing -- clear error flag - val <- action - if predicate val - then return val - else do err <- alcGetError Nothing - ioError . userError . show . maybe ALCOutOfMemory id $ err + alcGetError :: ALCdevice -> IO ALCenum diff -uNr --exclude=autom4te.cache --exclude=.cvsignore hugs98-Mar2005-patched/fptools/libraries/OpenAL/Sound/OpenAL/ALC/Extensions.hs ghc-6.4.2/libraries/OpenAL/Sound/OpenAL/ALC/Extensions.hs --- hugs98-Mar2005-patched/fptools/libraries/OpenAL/Sound/OpenAL/ALC/Extensions.hs 2004-01-03 04:03:09.000000000 +0900 +++ ghc-6.4.2/libraries/OpenAL/Sound/OpenAL/ALC/Extensions.hs 2006-03-22 00:58:03.000000000 +0900 @@ -1,51 +1,86 @@ -------------------------------------------------------------------------------- -- | -- Module : Sound.OpenAL.ALC.Extensions --- Copyright : (c) Sven Panne 2003-2004 +-- Copyright : (c) Sven Panne 2003-2005 -- License : BSD-style (see the file libraries/OpenAL/LICENSE) -- -- Maintainer : sven.panne@aedion.de -- Stability : provisional -- Portability : portable -- --- Extension Handling +-- This module corresponds to the extension handling parts of section 6.3 +-- (ALC Queries) of the OpenAL Specification and Reference (version 1.1). -- -------------------------------------------------------------------------------- module Sound.OpenAL.ALC.Extensions ( - alcExtensions, alcIsExtensionPresent, alcGetProcAddress, alcGetEnumValue + alcExtensions, alcIsExtensionPresent, alcProcAddress, alcEnumValue, + alcVersion ) where -import Control.Monad ( liftM ) +import Control.Monad ( liftM2 ) import Foreign.Ptr ( Ptr, FunPtr ) import Graphics.Rendering.OpenGL.GL.StateVar ( GettableStateVar, makeGettableStateVar ) -import Sound.OpenAL.AL.BasicTypes -import Sound.OpenAL.ALC.BasicTypes ( fromDevice, withALString ) +import Sound.OpenAL.ALC.BasicTypes ( ALCchar, ALCenum, ALCint ) import Sound.OpenAL.ALC.Device ( Device ) -import Sound.OpenAL.ALC.Queries ( - StringQuery(..), alcGetString, alcIsExtensionPresent ) +import Sound.OpenAL.ALC.QueryUtils ( + StringQuery(..), getString, IntQuery(..), getInteger, alcIsExtensionPresent ) +import Sound.OpenAL.ALC.String ( withALCString ) +import Sound.OpenAL.Config ( ALCdevice, nullDevice, marshalDevice ) -------------------------------------------------------------------------------- -alcExtensions :: GettableStateVar [String] -alcExtensions = makeGettableStateVar $ - liftM words $ alcGetString Nothing Extensions +-- | Contains a list of available context extensions. + +alcExtensions :: Device -> GettableStateVar [String] +alcExtensions device = makeGettableStateVar $ + fmap words $ getString (Just device) Extensions -------------------------------------------------------------------------------- -alcGetProcAddress :: Maybe Device -> String -> IO (FunPtr a) -alcGetProcAddress device funcName = - withALString funcName (alcGetProcAddress_ (fromDevice device)) +-- | The application is expected to verify the applicability of an extension or +-- core function entry point before requesting it by name, by use of +-- 'alcIsExtensionPresent'. Extension entry points can be retrieved using +-- 'alcProcAddress'. Entry points can be device specific, but are not context +-- specific. Using 'Nothing' as the device does not guarantee that the entry +-- point is returned, even if available for one of the available devices. + +alcProcAddress :: Maybe Device -> String -> GettableStateVar (FunPtr a) +alcProcAddress maybeDevice funcName = + makeGettableStateVar . + withALCString funcName . + alcGetProcAddress . marshalDevice . maybe nullDevice id $ maybeDevice foreign import CALLCONV unsafe "alcGetProcAddress" - alcGetProcAddress_ :: Device -> Ptr ALubyte -> IO (FunPtr a) + alcGetProcAddress :: ALCdevice -> Ptr ALCchar -> IO (FunPtr a) -------------------------------------------------------------------------------- -alcGetEnumValue :: Maybe Device -> String -> IO ALenum -alcGetEnumValue device enumName = - withALString enumName (alcGetEnumValue_ (fromDevice device)) +-- | Enumeration\/token values are device independent, but tokens defined for +-- extensions might not be present for a given device. Using 'Nothing' as the +-- device is legal, but only the tokens defined by the AL core are +-- guaranteed. Availability of extension tokens depends on the ALC extension. + +alcEnumValue :: Maybe Device -> String -> GettableStateVar ALCenum +alcEnumValue maybeDevice enumName = + makeGettableStateVar . + withALCString enumName . + alcGetEnumValue . marshalDevice . maybe nullDevice id $ maybeDevice foreign import CALLCONV unsafe "alcGetEnumValue" - alcGetEnumValue_ :: Device -> Ptr ALubyte -> IO ALenum + alcGetEnumValue :: ALCdevice -> Ptr ALCchar -> IO ALCenum + +-------------------------------------------------------------------------------- + +-- | Contains the \"/major/./minor/\" specification revision for this implementation. + +alcVersion :: GettableStateVar String +alcVersion = + makeGettableStateVar $ + liftM2 makeVersionString + (getInteger Nothing MajorVersion) + (getInteger Nothing MinorVersion) + +makeVersionString :: ALCint -> ALCint -> String +makeVersionString major minor = show major ++ "." ++ show minor diff -uNr --exclude=autom4te.cache --exclude=.cvsignore hugs98-Mar2005-patched/fptools/libraries/OpenAL/Sound/OpenAL/ALC/Queries.hs ghc-6.4.2/libraries/OpenAL/Sound/OpenAL/ALC/Queries.hs --- hugs98-Mar2005-patched/fptools/libraries/OpenAL/Sound/OpenAL/ALC/Queries.hs 2004-01-03 04:03:09.000000000 +0900 +++ ghc-6.4.2/libraries/OpenAL/Sound/OpenAL/ALC/Queries.hs 1970-01-01 09:00:00.000000000 +0900 @@ -1,99 +0,0 @@ --- #hide --------------------------------------------------------------------------------- --- | --- Module : Sound.OpenAL.ALC.Queries --- Copyright : (c) Sven Panne 2003-2004 --- License : BSD-style (see the file libraries/OpenAL/LICENSE) --- --- Maintainer : sven.panne@aedion.de --- Stability : provisional --- Portability : portable --- --------------------------------------------------------------------------------- - -module Sound.OpenAL.ALC.Queries ( - StringQuery(..), alcGetString, alcGetString_, - IntQuery(..), marshalIntQuery, getInteger, getIntegerv, - alcIsExtensionPresent -) where - -import Control.Monad ( liftM, when ) -import Foreign -import Sound.OpenAL.AL.BasicTypes ( ALubyte, ALint, ALenum, ALsizei ) -import Sound.OpenAL.AL.ALboolean ( ALboolean, unmarshalALboolean ) -import Sound.OpenAL.ALC.BasicTypes ( - Device, fromDevice, withALString, peekALString ) - --------------------------------------------------------------------------------- - -#include "HsOpenALConfig.h" - --------------------------------------------------------------------------------- - -data StringQuery = - DefaultDeviceSpecifier - | DeviceSpecifier - | Extensions - -marshalStringQuery :: StringQuery -> ALenum -marshalStringQuery x = case x of - DefaultDeviceSpecifier -> CONST_ALC_DEFAULT_DEVICE_SPECIFIER - DeviceSpecifier -> CONST_ALC_DEVICE_SPECIFIER - Extensions -> CONST_ALC_EXTENSIONS - --------------------------------------------------------------------------------- - -alcGetString :: Maybe Device -> StringQuery -> IO String -alcGetString device query = alcGetString_ device query >>= peekALString - -alcGetString_ :: Maybe Device -> StringQuery -> IO (Ptr ALubyte) -alcGetString_ device = alcGetString__ (fromDevice device) . marshalStringQuery - -foreign import CALLCONV unsafe "alcGetString" - alcGetString__ :: Device -> ALenum -> IO (Ptr ALubyte) - --------------------------------------------------------------------------------- - -data IntQuery = - MajorVersion - | MinorVersion - | AttributesSize - | AllAttributes - -marshalIntQuery :: IntQuery -> ALenum -marshalIntQuery x = case x of - MajorVersion -> CONST_ALC_MAJOR_VERSION - MinorVersion -> CONST_ALC_MINOR_VERSION - AttributesSize -> CONST_ALC_ATTRIBUTES_SIZE - AllAttributes -> CONST_ALC_ALL_ATTRIBUTES - --------------------------------------------------------------------------------- - -getInteger :: Device -> IntQuery -> IO ALint -getInteger device query = liftM head $ getIntegerv device query 1 - --- We are extremely careful below to avoid segfaults in case that there is no --- current context, an invalid device, etc. -getIntegerv :: Device -> IntQuery -> Int -> IO [ALint] -getIntegerv device query numALints = - withArray (replicate numALints 0) $ \buf -> do - let numBytes = fromIntegral (numALints * sizeOf (0 :: ALint)) - when (numALints > 0) $ - alcGetIntegerv device (marshalIntQuery query) numBytes buf - peekArray numALints buf - -foreign import CALLCONV unsafe "alcGetIntegerv" - alcGetIntegerv :: Device -> ALenum -> ALsizei -> Ptr ALint -> IO () - --------------------------------------------------------------------------------- - --- | Returns 'True' if the given ALC extension is present on the given device, --- 'False' otherwise. - -alcIsExtensionPresent :: Maybe Device -> String -> IO Bool -alcIsExtensionPresent device extensionName = - liftM unmarshalALboolean $ - withALString extensionName (alcIsExtensionPresent_ (fromDevice device)) - -foreign import CALLCONV unsafe "alcIsExtensionPresent" - alcIsExtensionPresent_ :: Device -> Ptr ALubyte -> IO ALboolean diff -uNr --exclude=autom4te.cache --exclude=.cvsignore hugs98-Mar2005-patched/fptools/libraries/OpenAL/Sound/OpenAL/ALC/QueryUtils.hs ghc-6.4.2/libraries/OpenAL/Sound/OpenAL/ALC/QueryUtils.hs --- hugs98-Mar2005-patched/fptools/libraries/OpenAL/Sound/OpenAL/ALC/QueryUtils.hs 1970-01-01 09:00:00.000000000 +0900 +++ ghc-6.4.2/libraries/OpenAL/Sound/OpenAL/ALC/QueryUtils.hs 2006-03-22 00:58:03.000000000 +0900 @@ -0,0 +1,122 @@ +-- #hide +-------------------------------------------------------------------------------- +-- | +-- Module : Sound.OpenAL.ALC.QueryUtils +-- Copyright : (c) Sven Panne 2003-2005 +-- License : BSD-style (see the file libraries/OpenAL/LICENSE) +-- +-- Maintainer : sven.panne@aedion.de +-- Stability : provisional +-- Portability : portable +-- +-------------------------------------------------------------------------------- + +module Sound.OpenAL.ALC.QueryUtils ( + StringQuery(..), getString, getStringRaw, + IntQuery(..), marshalIntQuery, getInteger, getIntegerv, + alcIsExtensionPresent +) where + +import Control.Monad ( when ) +import Foreign.Marshal.Array ( withArray, peekArray ) +import Foreign.Ptr ( Ptr ) +import Graphics.Rendering.OpenGL.GL.StateVar ( + GettableStateVar, makeGettableStateVar ) +import Sound.OpenAL.ALC.ALCboolean ( unmarshalALCboolean ) +import Sound.OpenAL.ALC.BasicTypes ( + ALCboolean, ALCchar, ALCint, ALCenum, ALCsizei ) +import Sound.OpenAL.ALC.String ( withALCString, peekALCString ) +import Sound.OpenAL.Config ( Device, ALCdevice, nullDevice, marshalDevice ) +import Sound.OpenAL.Constants ( + alc_DEFAULT_DEVICE_SPECIFIER, alc_DEVICE_SPECIFIER, alc_EXTENSIONS, + alc_CAPTURE_DEFAULT_DEVICE_SPECIFIER, alc_CAPTURE_DEVICE_SPECIFIER, + alc_ATTRIBUTES_SIZE, alc_ALL_ATTRIBUTES, alc_MAJOR_VERSION, + alc_MINOR_VERSION, alc_CAPTURE_SAMPLES ) + +-------------------------------------------------------------------------------- + +data StringQuery = + DefaultDeviceSpecifier + | DeviceSpecifier + | Extensions + | CaptureDefaultDeviceSpecifier + | CaptureDeviceSpecifier + | ALCErrorCategory ALCenum + +marshalStringQuery :: StringQuery -> ALCenum +marshalStringQuery x = case x of + DefaultDeviceSpecifier -> alc_DEFAULT_DEVICE_SPECIFIER + DeviceSpecifier -> alc_DEVICE_SPECIFIER + Extensions -> alc_EXTENSIONS + CaptureDefaultDeviceSpecifier -> alc_CAPTURE_DEFAULT_DEVICE_SPECIFIER + CaptureDeviceSpecifier -> alc_CAPTURE_DEVICE_SPECIFIER + ALCErrorCategory e -> e + +-------------------------------------------------------------------------------- + +getString :: Maybe Device -> StringQuery -> IO String +getString device query = getStringRaw device query >>= peekALCString + +getStringRaw :: Maybe Device -> StringQuery -> IO (Ptr ALCchar) +getStringRaw maybeDevice = + alcGetString (marshalMaybeDevice maybeDevice) . marshalStringQuery + +marshalMaybeDevice :: Maybe Device -> ALCdevice +marshalMaybeDevice = marshalDevice . maybe nullDevice id + +foreign import CALLCONV unsafe "alcGetString" + alcGetString :: ALCdevice -> ALCenum -> IO (Ptr ALCchar) + +-------------------------------------------------------------------------------- + +data IntQuery = + AttributesSize + | AllAttributes + | MajorVersion + | MinorVersion + | CaptureSamples + +marshalIntQuery :: IntQuery -> ALCenum +marshalIntQuery x = case x of + AttributesSize -> alc_ATTRIBUTES_SIZE + AllAttributes -> alc_ALL_ATTRIBUTES + MajorVersion -> alc_MAJOR_VERSION + MinorVersion -> alc_MINOR_VERSION + CaptureSamples -> alc_CAPTURE_SAMPLES + +-------------------------------------------------------------------------------- + +getInteger :: Maybe Device -> IntQuery -> IO ALCint +getInteger maybeDevice query = fmap head $ getIntegerv maybeDevice query 1 + +-- We are extremely careful below to avoid segfaults in case that there is no +-- current context, an invalid device, etc. +getIntegerv :: Maybe Device -> IntQuery -> ALCsizei -> IO [ALCint] +getIntegerv maybeDevice query numALCints = + let n = fromIntegral numALCints + in withArray (replicate n 0) $ \buf -> do + when (numALCints > 0) $ + alcGetIntegerv (marshalMaybeDevice maybeDevice) + (marshalIntQuery query) numALCints buf + peekArray n buf + +foreign import CALLCONV unsafe "alcGetIntegerv" + alcGetIntegerv :: ALCdevice -> ALCenum -> ALCsizei -> Ptr ALCint -> IO () + +-------------------------------------------------------------------------------- + +-- | To verify that a given extension is available for the current context and +-- the device it is associated with, use 'alcIsExtensionPresent'. For invalid +-- and unsupported string tokens it contains 'False'. Using 'Nothing' as the +-- device is acceptable. The extension name is not case sensitive: The +-- implementation will convert the name to all upper-case internally (and will +-- express extension names in upper-case). + +alcIsExtensionPresent :: Maybe Device -> String -> GettableStateVar Bool +alcIsExtensionPresent maybeDevice extensionName = makeGettableStateVar $ + fmap unmarshalALCboolean $ + withALCString extensionName $ + alcIsExtensionPresent_ (marshalMaybeDevice maybeDevice) + +foreign import CALLCONV unsafe "alcIsExtensionPresent" + alcIsExtensionPresent_ :: ALCdevice -> Ptr ALCchar -> IO ALCboolean diff -uNr --exclude=autom4te.cache --exclude=.cvsignore hugs98-Mar2005-patched/fptools/libraries/OpenAL/Sound/OpenAL/ALC/String.hs ghc-6.4.2/libraries/OpenAL/Sound/OpenAL/ALC/String.hs --- hugs98-Mar2005-patched/fptools/libraries/OpenAL/Sound/OpenAL/ALC/String.hs 1970-01-01 09:00:00.000000000 +0900 +++ ghc-6.4.2/libraries/OpenAL/Sound/OpenAL/ALC/String.hs 2006-03-22 00:58:03.000000000 +0900 @@ -0,0 +1,42 @@ +-- #hide +-------------------------------------------------------------------------------- +-- | +-- Module : Sound.OpenAL.ALC.String +-- Copyright : (c) Sven Panne 2005 +-- License : BSD-style (see the file libraries/OpenAL/LICENSE) +-- +-- Maintainer : sven.panne@aedion.de +-- Stability : provisional +-- Portability : portable +-- +-------------------------------------------------------------------------------- + +module Sound.OpenAL.ALC.String ( + withALCString, peekALCString, peekALCStrings +) where + +import Foreign.C.String ( withCString, peekCString ) +import Foreign.Marshal.Array ( lengthArray0 ) +import Foreign.Ptr ( Ptr, castPtr, plusPtr ) +import Sound.OpenAL.ALC.BasicTypes ( ALCchar ) + +-------------------------------------------------------------------------------- + +-- AL uses "Ptr ALCchar" instead of "CString" for strings, so some wrappers +-- are quite handy. + +withALCString :: String -> (Ptr ALCchar -> IO a) -> IO a +withALCString str action = withCString str (action . castPtr) + +peekALCString :: Ptr ALCchar -> IO String +peekALCString = peekCString . castPtr + +peekALCStrings :: Ptr ALCchar -> IO [String] +peekALCStrings ptr = loop ptr [] + where loop p strs = do + str <- peekALCString p + if str == "" + then return (reverse strs) + else do + len <- lengthArray0 0 p + loop (p `plusPtr` (len + 1)) (str : strs) diff -uNr --exclude=autom4te.cache --exclude=.cvsignore hugs98-Mar2005-patched/fptools/libraries/OpenAL/Sound/OpenAL/ALC.hs ghc-6.4.2/libraries/OpenAL/Sound/OpenAL/ALC.hs --- hugs98-Mar2005-patched/fptools/libraries/OpenAL/Sound/OpenAL/ALC.hs 2004-01-03 04:03:07.000000000 +0900 +++ ghc-6.4.2/libraries/OpenAL/Sound/OpenAL/ALC.hs 2006-03-22 00:58:03.000000000 +0900 @@ -1,7 +1,7 @@ -------------------------------------------------------------------------------- -- | -- Module : Sound.OpenAL.ALC --- Copyright : (c) Sven Panne 2003-2004 +-- Copyright : (c) Sven Panne 2003-2005 -- License : BSD-style (see the file libraries/OpenAL/LICENSE) -- -- Maintainer : sven.panne@aedion.de @@ -9,18 +9,27 @@ -- Portability : portable -- -- This module corresponds to chapter 6 (AL Contexts and the ALC API) of the --- OpenAL Specification and Reference (version 1.0). +-- OpenAL Specification and Reference (version 1.1). +-- +-- ALC is a portable API for managing OpenAL contexts, including resource +-- sharing, locking, and unlocking. Within the core AL API the existence of a +-- context is implied, but the context is not exposed. The context encapsulates +-- the state of a given instance of the AL state machine. -- -------------------------------------------------------------------------------- module Sound.OpenAL.ALC ( + module Sound.OpenAL.ALC.BasicTypes, module Sound.OpenAL.ALC.Device, module Sound.OpenAL.ALC.Context, module Sound.OpenAL.ALC.Extensions, - module Sound.OpenAL.ALC.Errors + module Sound.OpenAL.ALC.Errors, + module Sound.OpenAL.ALC.Capture ) where +import Sound.OpenAL.ALC.BasicTypes import Sound.OpenAL.ALC.Device import Sound.OpenAL.ALC.Context import Sound.OpenAL.ALC.Extensions import Sound.OpenAL.ALC.Errors +import Sound.OpenAL.ALC.Capture diff -uNr --exclude=autom4te.cache --exclude=.cvsignore hugs98-Mar2005-patched/fptools/libraries/OpenAL/Sound/OpenAL/ALUT/Exception.hs ghc-6.4.2/libraries/OpenAL/Sound/OpenAL/ALUT/Exception.hs --- hugs98-Mar2005-patched/fptools/libraries/OpenAL/Sound/OpenAL/ALUT/Exception.hs 2004-11-28 00:39:32.000000000 +0900 +++ ghc-6.4.2/libraries/OpenAL/Sound/OpenAL/ALUT/Exception.hs 1970-01-01 09:00:00.000000000 +0900 @@ -1,37 +0,0 @@ --- #hide --------------------------------------------------------------------------------- --- | --- Module : Sound.OpenAL.ALUT.Exception --- Copyright : (c) Sven Panne 2003-2004 --- License : BSD-style (see the file libraries/OpenGL/LICENSE) --- --- Maintainer : sven.panne@aedion.de --- Stability : provisional --- Portability : portable --- --- This is a purely internal module to compensate for differences between --- Haskell implementations. --- --------------------------------------------------------------------------------- - -module Sound.OpenAL.ALUT.Exception ( - bracket_, finally -) where - -#ifdef __NHC__ -finally :: IO a -> IO b -> IO a -a `finally` sequel = do - r <- a - sequel - return r - -{-# INLINE bracket_ #-} -bracket_ :: IO a -> IO b -> IO c -> IO c -bracket_ before after thing = do - before - r <- thing - after - return r -#else -import Control.Exception ( bracket_, finally ) -#endif diff -uNr --exclude=autom4te.cache --exclude=.cvsignore hugs98-Mar2005-patched/fptools/libraries/OpenAL/Sound/OpenAL/ALUT/Initialization.hs ghc-6.4.2/libraries/OpenAL/Sound/OpenAL/ALUT/Initialization.hs --- hugs98-Mar2005-patched/fptools/libraries/OpenAL/Sound/OpenAL/ALUT/Initialization.hs 2004-11-28 00:39:32.000000000 +0900 +++ ghc-6.4.2/libraries/OpenAL/Sound/OpenAL/ALUT/Initialization.hs 1970-01-01 09:00:00.000000000 +0900 @@ -1,40 +0,0 @@ --------------------------------------------------------------------------------- --- | --- Module : Sound.OpenAL.ALUT.Initialization --- Copyright : (c) Sven Panne 2003-2004 --- License : BSD-style (see the file libraries/OpenAL/LICENSE) --- --- Maintainer : sven.panne@aedion.de --- Stability : provisional --- Portability : portable --- --------------------------------------------------------------------------------- - -module Sound.OpenAL.ALUT.Initialization ( - runOpenAL -) where - -import Graphics.Rendering.OpenGL.GL.StateVar ( HasGetter(get), HasSetter(($=)) ) -import Sound.OpenAL.ALUT.Exception ( bracket_ ) -import Sound.OpenAL.ALC.Context ( - createContext, destroyContext, currentContext, contextsDevice ) -import Sound.OpenAL.ALC.Device ( openDevice, closeDevice ) - --------------------------------------------------------------------------------- - -alutInit :: IO () -alutInit = do - device <- openDevice Nothing - context <- createContext device [] - currentContext $= Just context - -alutExit :: IO () -alutExit = get currentContext >>= maybe (return ()) cleanupContext - where cleanupContext context = do - maybeDevice <- get (contextsDevice context) - currentContext $= Nothing - destroyContext context - maybe (return ()) closeDevice maybeDevice - -runOpenAL :: IO a -> IO a -runOpenAL = bracket_ alutInit alutExit diff -uNr --exclude=autom4te.cache --exclude=.cvsignore hugs98-Mar2005-patched/fptools/libraries/OpenAL/Sound/OpenAL/ALUT/WAV.hs ghc-6.4.2/libraries/OpenAL/Sound/OpenAL/ALUT/WAV.hs --- hugs98-Mar2005-patched/fptools/libraries/OpenAL/Sound/OpenAL/ALUT/WAV.hs 2004-05-12 04:36:48.000000000 +0900 +++ ghc-6.4.2/libraries/OpenAL/Sound/OpenAL/ALUT/WAV.hs 1970-01-01 09:00:00.000000000 +0900 @@ -1,70 +0,0 @@ --------------------------------------------------------------------------------- --- | --- Module : Sound.OpenAL.ALUT.WAV --- Copyright : (c) Sven Panne 2003-2004 --- License : BSD-style (see the file libraries/OpenAL/LICENSE) --- --- Maintainer : sven.panne@aedion.de --- Stability : provisional --- Portability : portable --- --------------------------------------------------------------------------------- - -module Sound.OpenAL.ALUT.WAV ( - withWAVFile, withWAVMemory -) where - -import Control.Monad ( liftM ) -import Foreign.C.String ( withCString ) -import Foreign.Marshal.Alloc ( alloca ) -import Foreign.Storable ( Storable(peek) ) -import Foreign.Ptr ( Ptr, castPtr ) -import Sound.OpenAL.AL.BasicTypes ( ALbyte, ALsizei, ALenum ) -import Sound.OpenAL.AL.ALboolean ( ALboolean, unmarshalALboolean ) -import Sound.OpenAL.AL.Buffer ( BufferData(..) ) -import Sound.OpenAL.AL.Format ( marshalFormat, unmarshalFormat ) -import Sound.OpenAL.ALUT.Exception ( finally ) - --------------------------------------------------------------------------------- - -withWAVFile :: FilePath -> (BufferData a -> Bool -> IO b) -> IO b -withWAVFile fileName action = - withCString fileName $ \fileNameBuf -> - withWAVInternal (alutLoadWAVFile (castPtr fileNameBuf)) action - -foreign import CALLCONV unsafe "alutLoadWAVFile" - alutLoadWAVFile :: Ptr ALbyte -> Loader a - -withWAVMemory :: Ptr ALbyte -> (BufferData a -> Bool -> IO b) -> IO b -withWAVMemory mem action = withWAVInternal (alutLoadWAVMemory mem) action - -foreign import CALLCONV unsafe "alutLoadWAVMemory" - alutLoadWAVMemory :: Ptr ALbyte -> Loader a - -type Loader a = Ptr ALenum -> Ptr (Ptr a) -> Ptr ALsizei -> Ptr ALsizei - -> Ptr ALboolean -> IO () - -withWAVInternal :: Loader a -> (BufferData a -> Bool -> IO b) -> IO b -withWAVInternal loader action = do - (bufferData, loop) <- alloca $ \formatBuf -> - alloca $ \rawBuf -> - alloca $ \sizeBuf -> - alloca $ \frequencyBuf -> - alloca $ \loopBuf -> do - loader formatBuf rawBuf sizeBuf frequencyBuf loopBuf - format <- liftM unmarshalFormat $ peek formatBuf - raw <- peek rawBuf - size <- peek sizeBuf - frequency <- peek frequencyBuf - loop <- liftM unmarshalALboolean $ peek loopBuf - return (BufferData format raw size frequency, loop) - action bufferData loop `finally` unloadWAV bufferData - --------------------------------------------------------------------------------- - -unloadWAV :: BufferData a -> IO () -unloadWAV (BufferData format raw size frequency) = - alutUnloadWAV (marshalFormat format) raw size frequency - -foreign import CALLCONV unsafe "alutUnloadWAV" - alutUnloadWAV :: ALenum -> Ptr a -> ALsizei -> ALsizei -> IO () diff -uNr --exclude=autom4te.cache --exclude=.cvsignore hugs98-Mar2005-patched/fptools/libraries/OpenAL/Sound/OpenAL/ALUT.hs ghc-6.4.2/libraries/OpenAL/Sound/OpenAL/ALUT.hs --- hugs98-Mar2005-patched/fptools/libraries/OpenAL/Sound/OpenAL/ALUT.hs 2004-01-03 04:03:07.000000000 +0900 +++ ghc-6.4.2/libraries/OpenAL/Sound/OpenAL/ALUT.hs 1970-01-01 09:00:00.000000000 +0900 @@ -1,19 +0,0 @@ --------------------------------------------------------------------------------- --- | --- Module : Sound.OpenAL.ALUT --- Copyright : (c) Sven Panne 2003-2004 --- License : BSD-style (see the file libraries/OpenAL/LICENSE) --- --- Maintainer : sven.panne@aedion.de --- Stability : provisional --- Portability : portable --- --------------------------------------------------------------------------------- - -module Sound.OpenAL.ALUT ( - module Sound.OpenAL.ALUT.Initialization, - module Sound.OpenAL.ALUT.WAV -) where - -import Sound.OpenAL.ALUT.Initialization -import Sound.OpenAL.ALUT.WAV diff -uNr --exclude=autom4te.cache --exclude=.cvsignore hugs98-Mar2005-patched/fptools/libraries/OpenAL/Sound/OpenAL/Config.hs ghc-6.4.2/libraries/OpenAL/Sound/OpenAL/Config.hs --- hugs98-Mar2005-patched/fptools/libraries/OpenAL/Sound/OpenAL/Config.hs 1970-01-01 09:00:00.000000000 +0900 +++ ghc-6.4.2/libraries/OpenAL/Sound/OpenAL/Config.hs 2006-03-22 00:58:03.000000000 +0900 @@ -0,0 +1,233 @@ +-- #hide +-------------------------------------------------------------------------------- +-- | +-- Module : Sound.OpenAL.Config +-- Copyright : (c) Sven Panne 2005 +-- License : BSD-style (see the file libraries/OpenAL/LICENSE) +-- +-- Maintainer : sven.panne@aedion.de +-- Stability : provisional +-- Portability : portable +-- +-- This purely internal module defines the platform-specific stuff which has +-- been figured out by configure. +-- +-------------------------------------------------------------------------------- + +module Sound.OpenAL.Config ( + -- AL types + ALboolean, ALchar, ALbyte, ALubyte, ALshort, ALushort, ALint, ALuint, + ALsizei, ALenum, ALfloat, ALdouble, + + -- ALC types + ALCboolean, ALCchar, ALCbyte, ALCubyte, ALCshort, ALCushort, ALCint, ALCuint, + ALCsizei, ALCenum, ALCfloat, ALCdouble, + + -- Device stuff + ALCdevice, Device, nullDevice, marshalDevice, unmarshalDevice, closeDevice, + + -- Context stuff + ALCcontext, Context, nullContext, marshalContext, unmarshalContext, + alcProcessContext, alcMakeContextCurrent, alcDestroyContext +) where + +import Data.Int +import Data.Word +import Foreign.Ptr ( Ptr, nullPtr ) + +-------------------------------------------------------------------------------- + +#include "HsOpenALConfig.h" + +-------------------------------------------------------------------------------- +-- AL types + +-- | 8-bit boolean +type ALboolean = HTYPE_ALBOOLEAN + +-- | Character +type ALchar = HTYPE_ALCHAR + +-- | Signed 8-bit 2\'s complement integer +type ALbyte = HTYPE_ALBYTE + +-- | Unsigned 8-bit integer +type ALubyte = HTYPE_ALUBYTE + +-- | Signed 16-bit 2\'s complement integer +type ALshort = HTYPE_ALSHORT + +-- | Unsigned 16-bit integer +type ALushort = HTYPE_ALUSHORT + +-- | Signed 32-bit 2\'s complement integer +type ALint = HTYPE_ALINT + +-- | Unsigned 32-bit integer +type ALuint = HTYPE_ALUINT + +-- | Non-negatitve 32-bit binary integer size +type ALsizei = HTYPE_ALSIZEI + +-- | Enumerated 32-bit value +type ALenum = HTYPE_ALENUM + +-- | 32-bit IEEE754 floating-point +type ALfloat = HTYPE_ALFLOAT + +-- | 64-bit IEEE754 floating-point +type ALdouble = HTYPE_ALDOUBLE + +-------------------------------------------------------------------------------- +-- ALC types + +-- | 8-bit boolean +type ALCboolean = HTYPE_ALCBOOLEAN + +-- | Character +type ALCchar = HTYPE_ALCCHAR + +-- | Signed 8-bit 2\'s complement integer +type ALCbyte = HTYPE_ALCBYTE + +-- | Unsigned 8-bit integer +type ALCubyte = HTYPE_ALCUBYTE + +-- | Signed 16-bit 2\'s complement integer +type ALCshort = HTYPE_ALCSHORT + +-- | Unsigned 16-bit integer +type ALCushort = HTYPE_ALCUSHORT + +-- | Signed 32-bit 2\'s complement integer +type ALCint = HTYPE_ALCINT + +-- | Unsigned 32-bit integer +type ALCuint = HTYPE_ALCUINT + +-- | Non-negatitve 32-bit binary integer size +type ALCsizei = HTYPE_ALCSIZEI + +-- | Enumerated 32-bit value +type ALCenum = HTYPE_ALCENUM + +-- | 32-bit IEEE754 floating-point +type ALCfloat = HTYPE_ALCFLOAT + +-- | 64-bit IEEE754 floating-point +type ALCdouble = HTYPE_ALCDOUBLE + +-------------------------------------------------------------------------------- +-- In OpenAL 1.1, alcCloseDevice() returns an ALCboolean, before it was void. +-- To break a dependency cycle, we have to define the Device type here, too. + +-- | The abstract device type. + +newtype Device = Device ALCdevice + deriving ( Eq, Ord, Show ) + +newtype ALCdevice = ALCdevice (Ptr ALCdevice) + deriving ( Eq, Ord, Show ) + +nullDevice :: Device +nullDevice = Device (ALCdevice nullPtr) + +marshalDevice :: Device -> ALCdevice +marshalDevice (Device device) = device + +unmarshalDevice :: ALCdevice -> Maybe Device +unmarshalDevice device = + if device == marshalDevice nullDevice then Nothing else Just (Device device) + +-- | 'closeDevice' allows the application (i.e. the client program) to +-- disconnect from a device (i.e. the server). It returns 'True' for success and +-- 'False' for failure. Once closed, the 'Device' is invalid. +-- +-- /Note:/ Older OpenAL implementations will always report a success! + +closeDevice :: Device -> IO Bool + +#if ALCCLOSEDEVICE_VOID + +closeDevice = fmap (const True) . alcCloseDevice . marshalDevice + +foreign import CALLCONV unsafe "alcCloseDevice" + alcCloseDevice :: ALCdevice -> IO () + +#else + +-- inlined unmarshalALCboolean here to break dependency cycle +closeDevice = fmap (/= CONST_ALC_FALSE) . alcCloseDevice . marshalDevice + +foreign import CALLCONV unsafe "alcCloseDevice" + alcCloseDevice :: ALCdevice -> IO ALCboolean + +#endif + +-------------------------------------------------------------------------------- +-- In OpenAL 1.1, alcProcessContext() returns void for all platforms, before it +-- returned ALCcontext* on Linux. To break a dependency cycle, we have to define +-- the Context type here, too. + +-- | The abstract context type. + +data Context = Context ALCcontext + deriving ( Eq, Ord, Show ) + +newtype ALCcontext = ALCcontext (Ptr ALCcontext) + deriving ( Eq, Ord, Show ) + +nullContext :: Context +nullContext = Context (ALCcontext nullPtr) + +marshalContext :: Context -> ALCcontext +marshalContext (Context context) = context + +unmarshalContext :: ALCcontext -> Maybe Context +unmarshalContext context = + if context == marshalContext nullContext then Nothing else Just (Context context) + +#if ALCPROCESSCONTEXT_VOID + +foreign import CALLCONV unsafe "alcProcessContext" + alcProcessContext :: ALCcontext -> IO () + +#else + +foreign import CALLCONV unsafe "alcProcessContext" + alcProcessContext :: ALCcontext -> IO ALCcontext + +#endif + +-------------------------------------------------------------------------------- +-- In OpenAL 1.1, alcMakeContextCurrent() returns void, before it was ALCenum on +-- Linux and ALCboolean on other platforms. Currently we default to ALCenum in +-- the latter case. + +#if ALCMAKECONTEXTCURRENT_VOID + +foreign import CALLCONV unsafe "alcMakeContextCurrent" + alcMakeContextCurrent :: ALCcontext -> IO () + +#else + +foreign import CALLCONV unsafe "alcMakeContextCurrent" + alcMakeContextCurrent :: ALCcontext -> IO ALCenum + +#endif + +-------------------------------------------------------------------------------- +-- In OpenAL 1.1, alcDestroyContext() returns void, before it returned ALCenum +-- on Linux. + +#if ALCDESTROYCONTEXT_VOID + +foreign import CALLCONV unsafe "alcDestroyContext" + alcDestroyContext :: ALCcontext -> IO () + +#else + +foreign import CALLCONV unsafe "alcDestroyContext" + alcDestroyContext :: ALCcontext -> IO ALCenum + +#endif diff -uNr --exclude=autom4te.cache --exclude=.cvsignore hugs98-Mar2005-patched/fptools/libraries/OpenAL/Sound/OpenAL/Constants.hs ghc-6.4.2/libraries/OpenAL/Sound/OpenAL/Constants.hs --- hugs98-Mar2005-patched/fptools/libraries/OpenAL/Sound/OpenAL/Constants.hs 1970-01-01 09:00:00.000000000 +0900 +++ ghc-6.4.2/libraries/OpenAL/Sound/OpenAL/Constants.hs 2006-03-22 00:58:03.000000000 +0900 @@ -0,0 +1,166 @@ +-- #hide +-------------------------------------------------------------------------------- +-- | +-- Module : Sound.OpenAL.Constants +-- Copyright : (c) Sven Panne 2005 +-- License : BSD-style (see the file libraries/OpenAL/LICENSE) +-- +-- Maintainer : sven.panne@aedion.de +-- Stability : provisional +-- Portability : portable +-- +-- This purely internal module defines all AL\/ALC constants, which have been +-- figured out by configure. In contrast to OpenGL and GLUT, these constants +-- varied on different platforms in the past and have evolved quite a bit. +-- +-------------------------------------------------------------------------------- + +module Sound.OpenAL.Constants where + +import Sound.OpenAL.Config ( + ALboolean, ALint, ALenum, ALCboolean, ALCint, ALCenum ) + +-------------------------------------------------------------------------------- + +#include "HsOpenALConfig.h" + +-------------------------------------------------------------------------------- + +al_FALSE, al_TRUE :: ALboolean +al_FALSE = CONST_AL_FALSE +al_TRUE = CONST_AL_TRUE + +al_NO_ERROR, al_INVALID_NAME, al_INVALID_ENUM, al_INVALID_VALUE, + al_INVALID_OPERATION, al_OUT_OF_MEMORY :: ALenum +al_NO_ERROR = CONST_AL_NO_ERROR +al_INVALID_NAME = CONST_AL_INVALID_NAME +al_INVALID_ENUM = CONST_AL_INVALID_ENUM +al_INVALID_VALUE = CONST_AL_INVALID_VALUE +al_INVALID_OPERATION = CONST_AL_INVALID_OPERATION +al_OUT_OF_MEMORY = CONST_AL_OUT_OF_MEMORY + +-------------------------------------------------------------------------------- + +al_DISTANCE_MODEL, al_DOPPLER_FACTOR, al_SPEED_OF_SOUND :: ALenum +al_DISTANCE_MODEL = CONST_AL_DISTANCE_MODEL +al_DOPPLER_FACTOR = CONST_AL_DOPPLER_FACTOR +al_SPEED_OF_SOUND = CONST_AL_SPEED_OF_SOUND + +al_VERSION, al_RENDERER, al_VENDOR, al_EXTENSIONS :: ALenum +al_VERSION = CONST_AL_VERSION +al_RENDERER = CONST_AL_RENDERER +al_VENDOR = CONST_AL_VENDOR +al_EXTENSIONS = CONST_AL_EXTENSIONS + +al_NONE, al_INVERSE_DISTANCE, al_INVERSE_DISTANCE_CLAMPED, al_LINEAR_DISTANCE, + al_LINEAR_DISTANCE_CLAMPED, al_EXPONENT_DISTANCE, + al_EXPONENT_DISTANCE_CLAMPED :: ALenum +al_NONE = CONST_AL_NONE +al_INVERSE_DISTANCE = CONST_AL_INVERSE_DISTANCE +al_INVERSE_DISTANCE_CLAMPED = CONST_AL_INVERSE_DISTANCE_CLAMPED +al_LINEAR_DISTANCE = CONST_AL_LINEAR_DISTANCE +al_LINEAR_DISTANCE_CLAMPED = CONST_AL_LINEAR_DISTANCE_CLAMPED +al_EXPONENT_DISTANCE = CONST_AL_EXPONENT_DISTANCE +al_EXPONENT_DISTANCE_CLAMPED = CONST_AL_EXPONENT_DISTANCE_CLAMPED + +-------------------------------------------------------------------------------- + +al_POSITION, al_VELOCITY, al_GAIN :: ALenum +al_POSITION = CONST_AL_POSITION +al_VELOCITY = CONST_AL_VELOCITY +al_GAIN = CONST_AL_GAIN + +al_ORIENTATION :: ALenum +al_ORIENTATION = CONST_AL_ORIENTATION + +al_SOURCE_RELATIVE, al_SOURCE_TYPE, al_LOOPING, al_BUFFER, al_BUFFERS_QUEUED, + al_BUFFERS_PROCESSED, al_MIN_GAIN, al_MAX_GAIN, al_REFERENCE_DISTANCE, + al_ROLLOFF_FACTOR, al_MAX_DISTANCE, al_PITCH, al_DIRECTION, + al_CONE_INNER_ANGLE, al_CONE_OUTER_ANGLE, al_CONE_OUTER_GAIN, al_SEC_OFFSET, + al_SAMPLE_OFFSET, al_BYTE_OFFSET, al_SOURCE_STATE :: ALenum +al_SOURCE_RELATIVE = CONST_AL_SOURCE_RELATIVE +al_SOURCE_TYPE = CONST_AL_SOURCE_TYPE +al_LOOPING = CONST_AL_LOOPING +al_BUFFER = CONST_AL_BUFFER +al_BUFFERS_QUEUED = CONST_AL_BUFFERS_QUEUED +al_BUFFERS_PROCESSED = CONST_AL_BUFFERS_PROCESSED +al_MIN_GAIN = CONST_AL_MIN_GAIN +al_MAX_GAIN = CONST_AL_MAX_GAIN +al_REFERENCE_DISTANCE = CONST_AL_REFERENCE_DISTANCE +al_ROLLOFF_FACTOR = CONST_AL_ROLLOFF_FACTOR +al_MAX_DISTANCE = CONST_AL_MAX_DISTANCE +al_PITCH = CONST_AL_PITCH +al_DIRECTION = CONST_AL_DIRECTION +al_CONE_INNER_ANGLE = CONST_AL_CONE_INNER_ANGLE +al_CONE_OUTER_ANGLE = CONST_AL_CONE_OUTER_ANGLE +al_CONE_OUTER_GAIN = CONST_AL_CONE_OUTER_GAIN +al_SEC_OFFSET = CONST_AL_SEC_OFFSET +al_SAMPLE_OFFSET = CONST_AL_SAMPLE_OFFSET +al_BYTE_OFFSET = CONST_AL_BYTE_OFFSET +al_SOURCE_STATE = CONST_AL_SOURCE_STATE + +al_UNDETERMINED, al_STATIC, al_STREAMING :: ALint +al_UNDETERMINED = CONST_AL_UNDETERMINED +al_STATIC = CONST_AL_STATIC +al_STREAMING = CONST_AL_STREAMING + +al_INITIAL, al_PLAYING, al_PAUSED, al_STOPPED :: ALint +al_INITIAL = CONST_AL_INITIAL +al_PLAYING = CONST_AL_PLAYING +al_PAUSED = CONST_AL_PAUSED +al_STOPPED = CONST_AL_STOPPED + +-------------------------------------------------------------------------------- + +al_FREQUENCY, al_SIZE, al_BITS, al_CHANNELS :: ALenum +al_FREQUENCY = CONST_AL_FREQUENCY +al_SIZE = CONST_AL_SIZE +al_BITS = CONST_AL_BITS +al_CHANNELS = CONST_AL_CHANNELS + +al_FORMAT_MONO8, al_FORMAT_MONO16, al_FORMAT_STEREO8, + al_FORMAT_STEREO16 :: ALenum +al_FORMAT_MONO8 = CONST_AL_FORMAT_MONO8 +al_FORMAT_MONO16 = CONST_AL_FORMAT_MONO16 +al_FORMAT_STEREO8 = CONST_AL_FORMAT_STEREO8 +al_FORMAT_STEREO16 = CONST_AL_FORMAT_STEREO16 + +-------------------------------------------------------------------------------- + +alc_FALSE, alc_TRUE :: ALCboolean +alc_FALSE = CONST_ALC_FALSE +alc_TRUE = CONST_ALC_TRUE + +alc_FREQUENCY, alc_REFRESH, alc_SYNC, alc_MONO_SOURCES, + alc_STEREO_SOURCES :: ALCint +alc_FREQUENCY = CONST_ALC_FREQUENCY +alc_REFRESH = CONST_ALC_REFRESH +alc_SYNC = CONST_ALC_SYNC +alc_MONO_SOURCES = CONST_ALC_MONO_SOURCES +alc_STEREO_SOURCES = CONST_ALC_STEREO_SOURCES + +alc_NO_ERROR, alc_INVALID_DEVICE, alc_INVALID_CONTEXT, alc_INVALID_ENUM, + alc_INVALID_VALUE, alc_INVALID_OPERATION, alc_OUT_OF_MEMORY :: ALCenum +alc_NO_ERROR = CONST_ALC_NO_ERROR +alc_INVALID_DEVICE = CONST_ALC_INVALID_DEVICE +alc_INVALID_CONTEXT = CONST_ALC_INVALID_CONTEXT +alc_INVALID_ENUM = CONST_ALC_INVALID_ENUM +alc_INVALID_VALUE = CONST_ALC_INVALID_VALUE +alc_INVALID_OPERATION = CONST_ALC_INVALID_OPERATION +alc_OUT_OF_MEMORY = CONST_ALC_OUT_OF_MEMORY + +alc_DEFAULT_DEVICE_SPECIFIER, alc_DEVICE_SPECIFIER, alc_EXTENSIONS, + alc_CAPTURE_DEFAULT_DEVICE_SPECIFIER, alc_CAPTURE_DEVICE_SPECIFIER :: ALCenum +alc_DEFAULT_DEVICE_SPECIFIER = CONST_ALC_DEFAULT_DEVICE_SPECIFIER +alc_DEVICE_SPECIFIER = CONST_ALC_DEVICE_SPECIFIER +alc_EXTENSIONS = CONST_ALC_EXTENSIONS +alc_CAPTURE_DEFAULT_DEVICE_SPECIFIER= CONST_ALC_CAPTURE_DEFAULT_DEVICE_SPECIFIER +alc_CAPTURE_DEVICE_SPECIFIER = CONST_ALC_CAPTURE_DEVICE_SPECIFIER + +alc_ATTRIBUTES_SIZE, alc_ALL_ATTRIBUTES, alc_MAJOR_VERSION, alc_MINOR_VERSION, + alc_CAPTURE_SAMPLES :: ALCenum +alc_ATTRIBUTES_SIZE = CONST_ALC_ATTRIBUTES_SIZE +alc_ALL_ATTRIBUTES = CONST_ALC_ALL_ATTRIBUTES +alc_MAJOR_VERSION = CONST_ALC_MAJOR_VERSION +alc_MINOR_VERSION = CONST_ALC_MINOR_VERSION +alc_CAPTURE_SAMPLES = CONST_ALC_CAPTURE_SAMPLES diff -uNr --exclude=autom4te.cache --exclude=.cvsignore hugs98-Mar2005-patched/fptools/libraries/OpenAL/Sound/OpenAL.hs ghc-6.4.2/libraries/OpenAL/Sound/OpenAL.hs --- hugs98-Mar2005-patched/fptools/libraries/OpenAL/Sound/OpenAL.hs 2004-01-03 04:03:07.000000000 +0900 +++ ghc-6.4.2/libraries/OpenAL/Sound/OpenAL.hs 2006-03-22 00:58:03.000000000 +0900 @@ -1,23 +1,181 @@ -------------------------------------------------------------------------------- -- | -- Module : Sound.OpenAL --- Copyright : (c) Sven Panne 2003-2004 +-- Copyright : (c) Sven Panne 2003-2005 -- License : BSD-style (see the file libraries/OpenAL/LICENSE) --- +-- -- Maintainer : sven.panne@aedion.de -- Stability : provisional -- Portability : portable -- --- A convenience module, combining the Haskell bindings for AL, ALC and ALUT. +-- A convenience module, combining the Haskell bindings for AL and ALC. -- -------------------------------------------------------------------------------- module Sound.OpenAL ( + -- * A Brief History of OpenAL + -- $ABriefHistoryOfOpenAL + + -- * What is the OpenAL Audio System? + -- $WhatIsTheOpenALAudioSystem + + -- * Different Views of OpenAL + + -- ** Programmer\'s View of OpenAL + -- $ProgrammersViewOfOpenAL + + -- ** Implementor\'s View of OpenAL + -- $ImplementorsViewOfOpenAL + + -- ** The Specification\'s View of OpenAL + -- $TheSpecificationsViewOfOpenAL + + -- * Legal stuff + -- $LegalStuff + module Sound.OpenAL.AL , module Sound.OpenAL.ALC - , module Sound.OpenAL.ALUT + + -- * Convenience Re-exports from the OpenGL Package + , module Graphics.Rendering.OpenGL.GL.StateVar + , ObjectName(..), Vector3(..), Vertex3(..) ) where import Sound.OpenAL.AL import Sound.OpenAL.ALC -import Sound.OpenAL.ALUT + +import Graphics.Rendering.OpenGL.GL.StateVar +import Graphics.Rendering.OpenGL.GL.BufferObjects ( ObjectName(..) ) +import Graphics.Rendering.OpenGL.GL.CoordTrans ( Vector3(..) ) +import Graphics.Rendering.OpenGL.GL.VertexSpec ( Vertex3(..) ) + +-------------------------------------------------------------------------------- +-- $ABriefHistoryOfOpenAL +-- The first discussions about implementing OpenAL as an audio API complimentary +-- to OpenGL started around 1998. There were a few aborted attempts at creating +-- the headers and a specification, but by late 1999 Loki Entertainment Software +-- was in need for an API of exactly this type and pursued both a specification +-- and a Linux implementation. At around that time, Loki started talking with +-- Creative Labs about standardizing the API and expanding platform support. The +-- OpenAL 1.0 specification was released in early 2000 and compliant OpenAL +-- libraries were released in the same year for Linux, MacOS 8\/9, Windows, and +-- BeOS. Loki Entertainment also shipped several games using OpenAL in 2000: +-- Heavy Gear 2 and Heretic 2 (both under Linux). In 2001, Creative Labs +-- released the first hardware-accelerated OpenAL libraries. The libraries +-- supported the SoundBlaster Live on MacOS 8\/9 and Windows. +-- +-- Since 2001, there has been continuous improvement in OpenAL. Some platforms +-- are less relevant than in 2000 (BeOS and MacOS 8\/9 for instance), but more +-- platforms have been added as well (BSD, Solaris, IRIX, Mac OS X, and the +-- popular console gaming platforms). Hardware support is enabled for many +-- Creative and NVIDIA audio devices under Windows as well. +-- +-- In terms of product support, OpenAL has been used in a large number of titles +-- over the years, on many platforms (for a list of many of the titles, see +-- ). + +-------------------------------------------------------------------------------- +-- $WhatIsTheOpenALAudioSystem +-- OpenAL (for /Open Audio Library/) is a software interface to audio hardware. +-- The interface consists of a number of functions that allow a programmer to +-- specify the objects and operations in producing high-quality audio output, +-- specifically multichannel output of 3D arrangements of sound sources around a +-- listener. +-- +-- The OpenAL API is designed to be cross-platform and easy to use. It resembles +-- the OpenGL API in coding style and conventions. OpenAL uses a syntax +-- resembling that of OpenGL where applicable. For more information on OpenGL, +-- see and the "Graphics.Rendering.OpenGL" module. +-- +-- OpenAL is foremost a means to generate audio in a simulated three-dimensional +-- space. Consequently, legacy audio concepts such as panning and left\/right +-- channels are not directly supported. OpenAL does include extensions +-- compatible with the IA-SIG 3D Level 1 and Level 2 rendering guidelines to +-- handle sound-source directivity and distancerelated attenuation and Doppler +-- effects, as well as environmental effects such as reflection, obstruction, +-- transmission, reverberation. For more information on IA-SIG 3D, see +-- . +-- +-- Like OpenGL, the OpenAL core API has no notion of an explicit rendering +-- context, and operates on an implied current OpenAL Context. Unlike the OpenGL +-- specification, the OpenAL specification includes both the core API (the +-- actual OpenAL API, see "Sound.OpenAL.AL") and the operating system bindings +-- of the ALC API (the /Audio Library Context/, see "Sound.OpenAL.ALC"). Unlike +-- OpenGL\'s GLX, WGL and other OS-specific bindings, the ALC API is portable +-- across platforms as well. + +-------------------------------------------------------------------------------- +-- $ProgrammersViewOfOpenAL +-- To the programmer, OpenAL is a set of commands that allow the specification +-- of sound sources and a listener in three dimensions, combined with commands +-- that control how these sound sources are rendered into the output buffer. The +-- effect of OpenAL commands is not guaranteed to be immediate, as there are +-- latencies depending on the implementation, but ideally such latency should +-- not be noticeable to the user. +-- +-- A typical program that uses OpenAL begins with calls to open a sound device +-- which is used to process output and play it on attached hardware (speakers or +-- headphones). Then, calls are made to allocate an AL context and associate it +-- with the device. Once an AL context is allocated, the programmer is free to +-- issue AL commands. Some calls are used to render sources (point and +-- directional sources, looping or not), while others affect the rendering of +-- these sources including how they are attenuated by distance and relative +-- orientation. + +-------------------------------------------------------------------------------- +-- $ImplementorsViewOfOpenAL +-- To the implementor, OpenAL is a set of commands that affect the operation of +-- CPU and sound hardware. If the hardware consists only of an addressable +-- output buffer, then OpenAL must be implemented almost entirely on the host +-- CPU. In some cases audio hardware provides DSP-based and other acceleration +-- in various degrees. The OpenAL implementor\'s task is to provide the CPU +-- software interface while dividing the work for each AL command between the +-- CPU and the audio hardware. This division should be tailored to the available +-- audio hardware to obtain optimum performance in carrying out AL calls. +-- +-- OpenAL maintains a considerable amount of state information. This state +-- controls how the sources are rendered into the output buffer. Some of this +-- state is directly available to the user: he or she can make calls to obtain +-- its value. Some of it, however, is visible only by the effect it has on what +-- is rendered. One of the main goals of the OpenAL specification is to make +-- OpenAL state information explicit, to elucidate how it changes, and to +-- indicate what its effects are. + +-------------------------------------------------------------------------------- +-- $TheSpecificationsViewOfOpenAL +-- The OpenAL specification (see ) +-- views OpenAL as a state machine that controls a multichannel processing +-- system to synthesize a digital stream, passing sample data through a chain of +-- parametrized digital audio signal processing operations. This model should +-- engender a specification that satisfies the needs of both programmers and +-- implementors. It does not, however, necessarily provide a model for +-- implementation. Any proper implementation must produce results conforming to +-- those produced by the methods specified in the OpenAL specification, but +-- there may be ways to carry out a particular computation that are more +-- efficient than the one specified. + +-------------------------------------------------------------------------------- +-- $LegalStuff +-- The documentation is more or less based upon the OpenAL 1.1 Specification and +-- Reference, which is in turn based upon the older OpenAL Specification and +-- Reference (1.0), published in June 2000. Both copyright notices are presented +-- below: +-- +-- Version 1.1: Published June 2005, Copyright (c) 2005 by authors +-- +-- Version 1.0 Draft Edition: Published June 2000, Copyright (c) 1999-2000 by +-- Loki Software +-- +-- Permission is granted to make and distribute verbatim copies of this manual +-- provided the copyright notice and this permission notice are preserved on all +-- copies. Permission is granted to copy and distribute translations of this +-- manual into another language, under the above conditions for modified +-- versions, except that this permission notice may be stated in a translation +-- approved by the copyright owners. +-- +-- BeOS is a trademark of PalmSource, Inc. Linux is a trademark of Linus +-- Torvalds. Macintosh and Apple are trademarks of Apple Computer, Inc. OpenAL +-- is a trademark of Creative Labs, Inc. OpenGL is a trademark of Silicon +-- Graphics, Inc. UNIX is a trademark of X\/Open Group. Windows is a trademark +-- of Microsoft Corp. X Window System is a trademark of X Consortium, Inc. All +-- other trademarks are property of their respective owners. diff -uNr --exclude=autom4te.cache --exclude=.cvsignore hugs98-Mar2005-patched/fptools/libraries/OpenAL/aclocal.m4 ghc-6.4.2/libraries/OpenAL/aclocal.m4 --- hugs98-Mar2005-patched/fptools/libraries/OpenAL/aclocal.m4 2004-11-22 07:53:36.000000000 +0900 +++ ghc-6.4.2/libraries/OpenAL/aclocal.m4 2006-03-22 00:58:03.000000000 +0900 @@ -1,7 +1,7 @@ # FPTOOLS_CHECK_HTYPE(TYPE [, DEFAULT_VALUE, [, VALUE-FOR-CROSS-COMPILATION]) # # This test should *really* be rewritten!!! -AC_DEFUN(FPTOOLS_CHECK_HTYPE, +AC_DEFUN([FPTOOLS_CHECK_HTYPE], [changequote(<<, >>)dnl dnl The name to #define. define(<>, translit(htype_$1, [a-z *], [A-Z_P]))dnl @@ -59,6 +59,12 @@ # include #endif +#if defined(HAVE_AL_AL_H) +# include +#elif defined(HAVE_OPENAL_AL_H) +# include +#endif + #if defined(HAVE_AL_ALC_H) # include #elif defined(HAVE_OPENAL_ALC_H) @@ -87,8 +93,8 @@ exit(0); }]])],[AC_CV_NAME=`cat conftestval`], [ifelse([$2], , [AC_CV_NAME=NotReallyAType; AC_CV_NAME_supported=no], [AC_CV_NAME=$2])], -[ifelse([$3], , [AC_CV_NAME=NotReallyATypeCross; AC_CV_NAME_supported=no], [AC_CV_NAME=$3])])]) dnl -CPPFLAGS="$fp_check_htype_save_cppflags" +[ifelse([$3], , [AC_CV_NAME=NotReallyATypeCross; AC_CV_NAME_supported=no], [AC_CV_NAME=$3])]) +CPPFLAGS="$fp_check_htype_save_cppflags"]) dnl if test "$AC_CV_NAME_supported" = yes; then AC_MSG_RESULT($AC_CV_NAME) AC_DEFINE_UNQUOTED(AC_TYPE_NAME, $AC_CV_NAME, [Define to Haskell type for $1]) @@ -100,6 +106,7 @@ undefine([AC_CV_NAME_supported])dnl ]) + # FP_COMPUTE_INT(EXPRESSION, VARIABLE, INCLUDES, IF-FAILS) # --------------------------------------------------------- # Assign VARIABLE the value of the compile-time EXPRESSION using INCLUDES for @@ -113,6 +120,7 @@ [_AC_COMPUTE_INT([$1], [$2], [$3], [$4])[]dnl ])# FP_COMPUTE_INT + # FP_CHECK_CONST(EXPRESSION, [INCLUDES = DEFAULT-INCLUDES], [VALUE-IF-FAIL = -1]) # ------------------------------------------------------------------------------- # Defines CONST_EXPRESSION to the value of the compile-time EXPRESSION, using @@ -141,7 +149,7 @@ # FP_CHECK_CONSTS(EXPRESSION..., [INCLUDES = DEFAULT-INCLUDES], [VALUE-IF-FAIL = -1]) # ----------------------------------------------------------------------------------- # List version of FP_CHECK_CONST -AC_DEFUN(FP_CHECK_CONSTS, +AC_DEFUN([FP_CHECK_CONSTS], [FP_CHECK_CONSTS_TEMPLATE([$1])dnl for fp_const_name in $1 do @@ -159,3 +167,119 @@ [enable_openal=$enableval], [enable_openal=yes]) ])# FP_ARG_OPENAL + + +# FP_HEADER_AL +# ------------ +# Check for an AL header, setting the variable fp_found_al_header to no/yes, +# depending on the outcome. +AC_DEFUN([FP_HEADER_AL], +[if test -z "$fp_found_al_header"; then + fp_found_al_header=no + AC_CHECK_HEADERS([AL/al.h OpenAL/al.h], [fp_found_al_header=yes; break]) +fi +]) # FP_HEADER_AL + + +# FP_HEADER_ALC +# ------------- +# Check for an ALC header, setting the variable fp_found_alc_header to no/yes, +# depending on the outcome. +AC_DEFUN([FP_HEADER_ALC], +[if test -z "$fp_found_alc_header"; then + fp_found_alc_header=no + AC_CHECK_HEADERS([AL/alc.h OpenAL/alc.h], [fp_found_alc_header=yes; break]) +fi +]) # FP_HEADER_ALC + + +# FP_FUNC_ALCCLOSEDEVICE_VOID +# --------------------------- +# Defines ALCCLOSEDEVICE_VOID to 1 if `alcCloseDevice' returns void. +AC_DEFUN([FP_FUNC_ALCCLOSEDEVICE_VOID], +[AC_REQUIRE([FP_HEADER_ALC]) +AC_CACHE_CHECK([whether alcCloseDevice returns void], + [fp_cv_func_alcclosedevice_void], + [AC_COMPILE_IFELSE([AC_LANG_PROGRAM([AC_INCLUDES_DEFAULT +#if defined(HAVE_AL_ALC_H) +#include +#elif defined(HAVE_OPENAL_ALC_H) +#include +#endif +], + [[int x = (int)alcCloseDevice(NULL);]])], + [fp_cv_func_alcclosedevice_void=no], + [fp_cv_func_alcclosedevice_void=yes])]) +if test x"$fp_cv_func_alcclosedevice_void" = xyes; then + AC_DEFINE([ALCCLOSEDEVICE_VOID], [1], [Define to 1 if `alcCloseDevice' returns void.]) +fi +]) # FP_FUNC_ALCCLOSEDEVICE_VOID + + +# FP_FUNC_ALCMAKECONTEXTCURRENT_VOID +# ---------------------------------- +# Defines ALCMAKECONTEXTCURRENT_VOID to 1 if `alcMakeContextCurrent' returns void. +AC_DEFUN([FP_FUNC_ALCMAKECONTEXTCURRENT_VOID], +[AC_REQUIRE([FP_HEADER_ALC]) +AC_CACHE_CHECK([whether alcMakeContextCurrent returns void], + [fp_cv_func_alcmakecontextcurrent_void], + [AC_COMPILE_IFELSE([AC_LANG_PROGRAM([AC_INCLUDES_DEFAULT +#if defined(HAVE_AL_ALC_H) +#include +#elif defined(HAVE_OPENAL_ALC_H) +#include +#endif +], + [[int x = (int)alcMakeContextCurrent(NULL);]])], + [fp_cv_func_alcmakecontextcurrent_void=no], + [fp_cv_func_alcmakecontextcurrent_void=yes])]) +if test x"$fp_cv_func_alcmakecontextcurrent_void)" = xyes; then + AC_DEFINE([ALCMAKECONTEXTCURRENT_VOID], [1], [Define to 1 if `alcMakeContextCurrent' returns void.]) +fi +]) # FP_FUNC_ALCMAKECONTEXTCURRENT_VOID + + +# FP_FUNC_ALCPROCESSCONTEXT_VOID +# ------------------------------ +# Defines ALCPROCESSCONTEXT_VOID to 1 if `alcProcessContext' returns void. +AC_DEFUN([FP_FUNC_ALCPROCESSCONTEXT_VOID], +[AC_REQUIRE([FP_HEADER_ALC]) +AC_CACHE_CHECK([whether alcProcessContext returns void], + [fp_cv_func_alcprocesscontext_void], + [AC_COMPILE_IFELSE([AC_LANG_PROGRAM([AC_INCLUDES_DEFAULT +#if defined(HAVE_AL_ALC_H) +#include +#elif defined(HAVE_OPENAL_ALC_H) +#include +#endif +], + [[int x = (int)alcProcessContext(NULL);]])], + [fp_cv_func_alcprocesscontext_void=no], + [fp_cv_func_alcprocesscontext_void=yes])]) +if test x"$fp_cv_func_alcprocesscontext_void" = xyes; then + AC_DEFINE([ALCPROCESSCONTEXT_VOID], [1], [Define to 1 if `alcProcessContext' returns void.]) +fi +]) # FP_FUNC_ALCPROCESSCONTEXT_VOID + + +# FP_FUNC_ALCDESTROYCONTEXT_VOID +# ------------------------------ +# Defines ALCDESTROYCONTEXT_VOID to 1 if `alcDestroyContext' returns void. +AC_DEFUN([FP_FUNC_ALCDESTROYCONTEXT_VOID], +[AC_REQUIRE([FP_HEADER_ALC]) +AC_CACHE_CHECK([whether alcDestroyContext returns void], + [fp_cv_func_alcdestroycontext_void], + [AC_COMPILE_IFELSE([AC_LANG_PROGRAM([AC_INCLUDES_DEFAULT +#if defined(HAVE_AL_ALC_H) +#include +#elif defined(HAVE_OPENAL_ALC_H) +#include +#endif +], + [[int x = (int)alcDestroyContext(NULL);]])], + [fp_cv_func_alcdestroycontext_void=no], + [fp_cv_func_alcdestroycontext_void=yes])]) +if test x"$fp_cv_func_alcdestroycontext_void" = xyes; then + AC_DEFINE([ALCDESTROYCONTEXT_VOID], [1], [Define to 1 if `alcDestroyContext' returns void.]) +fi +]) # FP_FUNC_ALCDESTROYCONTEXT_VOID diff -uNr --exclude=autom4te.cache --exclude=.cvsignore hugs98-Mar2005-patched/fptools/libraries/OpenAL/configure ghc-6.4.2/libraries/OpenAL/configure --- hugs98-Mar2005-patched/fptools/libraries/OpenAL/configure 2005-03-12 08:13:20.000000000 +0900 +++ ghc-6.4.2/libraries/OpenAL/configure 2006-04-19 04:36:53.000000000 +0900 @@ -1,6 +1,6 @@ #! /bin/sh # Guess values for system-dependent variables and create Makefiles. -# Generated by GNU Autoconf 2.57 for Haskell HOpenAL package 1.0. +# Generated by GNU Autoconf 2.57 for Haskell HOpenAL package 1.2. # # Report bugs to . # @@ -268,8 +268,8 @@ # Identity of this package. PACKAGE_NAME='Haskell HOpenAL package' PACKAGE_TARNAME='OpenAL' -PACKAGE_VERSION='1.0' -PACKAGE_STRING='Haskell HOpenAL package 1.0' +PACKAGE_VERSION='1.2' +PACKAGE_STRING='Haskell HOpenAL package 1.2' PACKAGE_BUGREPORT='sven.panne@aedion.de' ac_unique_file="include/HsOpenAL.h.in" @@ -310,7 +310,7 @@ # include #endif" -ac_subst_vars='SHELL PATH_SEPARATOR PACKAGE_NAME PACKAGE_TARNAME PACKAGE_VERSION PACKAGE_STRING PACKAGE_BUGREPORT exec_prefix prefix program_transform_name bindir sbindir libexecdir datadir sysconfdir sharedstatedir localstatedir libdir includedir oldincludedir infodir mandir build_alias host_alias target_alias DEFS ECHO_C ECHO_N ECHO_T LIBS AL_BUILD_PACKAGE CC CFLAGS LDFLAGS CPPFLAGS ac_ct_CC EXEEXT OBJEXT AL_LIBS CPP EGREP AL_FRAMEWORKS BUILD_PACKAGE_BOOL CALLCONV LIBOBJS LTLIBOBJS' +ac_subst_vars='SHELL PATH_SEPARATOR PACKAGE_NAME PACKAGE_TARNAME PACKAGE_VERSION PACKAGE_STRING PACKAGE_BUGREPORT exec_prefix prefix program_transform_name bindir sbindir libexecdir datadir sysconfdir sharedstatedir localstatedir libdir includedir oldincludedir infodir mandir build_alias host_alias target_alias DEFS ECHO_C ECHO_N ECHO_T LIBS AL_BUILD_PACKAGE CC CFLAGS LDFLAGS CPPFLAGS ac_ct_CC EXEEXT OBJEXT AL_LIBS AL_FRAMEWORKS CPP EGREP BUILD_PACKAGE_BOOL CALLCONV LIBOBJS LTLIBOBJS' ac_subst_files='' # Initialize some variables set by options. @@ -779,7 +779,7 @@ # Omit some internal or obsolete options to make the list less imposing. # This message is too long to be a string in the A/UX 3.1 sh. cat <<_ACEOF -\`configure' configures Haskell HOpenAL package 1.0 to adapt to many kinds of systems. +\`configure' configures Haskell HOpenAL package 1.2 to adapt to many kinds of systems. Usage: $0 [OPTION]... [VAR=VALUE]... @@ -836,7 +836,7 @@ if test -n "$ac_init_help"; then case $ac_init_help in - short | recursive ) echo "Configuration of Haskell HOpenAL package 1.0:";; + short | recursive ) echo "Configuration of Haskell HOpenAL package 1.2:";; esac cat <<\_ACEOF @@ -921,7 +921,7 @@ test -n "$ac_init_help" && exit 0 if $ac_init_version; then cat <<\_ACEOF -Haskell HOpenAL package configure 1.0 +Haskell HOpenAL package configure 1.2 generated by GNU Autoconf 2.57 Copyright 1992, 1993, 1994, 1995, 1996, 1998, 1999, 2000, 2001, 2002 @@ -936,7 +936,7 @@ This file contains any messages produced by compilers while running configure, to aid debugging if configure makes a mistake. -It was created by Haskell HOpenAL package $as_me 1.0, which was +It was created by Haskell HOpenAL package $as_me 1.2, which was generated by GNU Autoconf 2.57. Invocation command line was $ $0 $@ @@ -2219,7 +2219,7 @@ fi rm -f conftest.$ac_objext conftest$ac_exeext conftest.$ac_ext if test "$ac_cv_search_alGenSources" = no; then - for ac_lib in openal; do + for ac_lib in openal openal32; do LIBS="-l$ac_lib $ac_func_search_save_LIBS" cat >conftest.$ac_ext <<_ACEOF #line $LINENO "configure" @@ -2283,7 +2283,15 @@ echo "$as_me: WARNING: no OpenAL library found, so this package will not be built" >&2;} else -al_found_header=no +# Ugly... +AL_FRAMEWORKS= +case $host_os in +darwin*) + AL_FRAMEWORKS=OpenAL + ;; +esac + + ac_ext=c ac_cpp='$CPP $CPPFLAGS' ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' @@ -2757,9 +2765,11 @@ done +if test -z "$fp_found_al_header"; then + fp_found_al_header=no -for ac_header in AL/alc.h OpenAL/alc.h +for ac_header in AL/al.h OpenAL/al.h do as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh` if eval "test \"\${$as_ac_Header+set}\" = set"; then @@ -2895,30 +2905,18 @@ cat >>confdefs.h <<_ACEOF #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1 _ACEOF - al_found_header=yes; break + fp_found_al_header=yes; break fi done -if test "$al_found_header" = no; then - { echo "$as_me:$LINENO: WARNING: no OpenAL header found, so this package will not be built" >&5 -echo "$as_me: WARNING: no OpenAL header found, so this package will not be built" >&2;} -else - -AL_BUILD_PACKAGE=yes - -# Ugly... -AL_FRAMEWORKS= -case $target_os in -darwin*) - AL_FRAMEWORKS=OpenAL - ;; -esac - +fi +if test -z "$fp_found_alc_header"; then + fp_found_alc_header=no -for ac_header in AL/alext.h OpenAL/alext.h +for ac_header in AL/alc.h OpenAL/alc.h do as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh` if eval "test \"\${$as_ac_Header+set}\" = set"; then @@ -3054,133 +3052,1600 @@ cat >>confdefs.h <<_ACEOF #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1 _ACEOF - break + fp_found_alc_header=yes; break fi done +fi -echo "$as_me:$LINENO: checking Haskell type for ALboolean" >&5 -echo $ECHO_N "checking Haskell type for ALboolean... $ECHO_C" >&6 -if test "${fptools_cv_htype_ALboolean+set}" = set; then - echo $ECHO_N "(cached) $ECHO_C" >&6 +if test -z "$AL_FRAMEWORKS" && test x"$fp_found_al_header$fp_found_alc_header" != xyesyes; then + { echo "$as_me:$LINENO: WARNING: no OpenAL headers found, so this package will not be built" >&5 +echo "$as_me: WARNING: no OpenAL headers found, so this package will not be built" >&2;} else - fptools_cv_htype_sup_ALboolean=yes -fp_check_htype_save_cppflags="$CPPFLAGS" -CPPFLAGS="$CPPFLAGS $X_CFLAGS" -if test "$cross_compiling" = yes; then - fptools_cv_htype_ALboolean=NotReallyATypeCross; fptools_cv_htype_sup_ALboolean=no + +AL_BUILD_PACKAGE=yes + + + +for ac_header in AL/alext.h OpenAL/alext.h +do +as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh` +if eval "test \"\${$as_ac_Header+set}\" = set"; then + echo "$as_me:$LINENO: checking for $ac_header" >&5 +echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6 +if eval "test \"\${$as_ac_Header+set}\" = set"; then + echo $ECHO_N "(cached) $ECHO_C" >&6 +fi +echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5 +echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6 else - cat >conftest.$ac_ext <<_ACEOF + # Is the header compilable? +echo "$as_me:$LINENO: checking $ac_header usability" >&5 +echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6 +cat >conftest.$ac_ext <<_ACEOF #line $LINENO "configure" /* confdefs.h. */ _ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<_ACEOF /* end confdefs.h. */ -#include -#include - -#if HAVE_SYS_TYPES_H -# include -#endif - -#if HAVE_UNISTD_H -# include -#endif +$ac_includes_default +#include <$ac_header> +_ACEOF +rm -f conftest.$ac_objext +if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 + (eval $ac_compile) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -s conftest.$ac_objext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_header_compiler=yes +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 -#if HAVE_SYS_STAT_H -# include -#endif +ac_header_compiler=no +fi +rm -f conftest.$ac_objext conftest.$ac_ext +echo "$as_me:$LINENO: result: $ac_header_compiler" >&5 +echo "${ECHO_T}$ac_header_compiler" >&6 -#if HAVE_FCNTL_H -# include -#endif +# Is the header present? +echo "$as_me:$LINENO: checking $ac_header presence" >&5 +echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6 +cat >conftest.$ac_ext <<_ACEOF +#line $LINENO "configure" +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +#include <$ac_header> +_ACEOF +if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5 + (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } >/dev/null; then + if test -s conftest.err; then + ac_cpp_err=$ac_c_preproc_warn_flag + else + ac_cpp_err= + fi +else + ac_cpp_err=yes +fi +if test -z "$ac_cpp_err"; then + ac_header_preproc=yes +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 -#if HAVE_SIGNAL_H -# include -#endif + ac_header_preproc=no +fi +rm -f conftest.err conftest.$ac_ext +echo "$as_me:$LINENO: result: $ac_header_preproc" >&5 +echo "${ECHO_T}$ac_header_preproc" >&6 -#if HAVE_TIME_H -# include -#endif +# So? What about this header? +case $ac_header_compiler:$ac_header_preproc in + yes:no ) + { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5 +echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;} + { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5 +echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;} + ( + cat <<\_ASBOX +## ------------------------------------ ## +## Report this to bug-autoconf@gnu.org. ## +## ------------------------------------ ## +_ASBOX + ) | + sed "s/^/$as_me: WARNING: /" >&2 + ;; + no:yes ) + { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5 +echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;} + { echo "$as_me:$LINENO: WARNING: $ac_header: check for missing prerequisite headers?" >&5 +echo "$as_me: WARNING: $ac_header: check for missing prerequisite headers?" >&2;} + { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5 +echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;} + ( + cat <<\_ASBOX +## ------------------------------------ ## +## Report this to bug-autoconf@gnu.org. ## +## ------------------------------------ ## +_ASBOX + ) | + sed "s/^/$as_me: WARNING: /" >&2 + ;; +esac +echo "$as_me:$LINENO: checking for $ac_header" >&5 +echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6 +if eval "test \"\${$as_ac_Header+set}\" = set"; then + echo $ECHO_N "(cached) $ECHO_C" >&6 +else + eval "$as_ac_Header=$ac_header_preproc" +fi +echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5 +echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6 -#if HAVE_TERMIOS_H -# include -#endif +fi +if test `eval echo '${'$as_ac_Header'}'` = yes; then + cat >>confdefs.h <<_ACEOF +#define `echo "HAVE_$ac_header" | $as_tr_cpp` 1 +_ACEOF + break +fi -#if HAVE_STRING_H -# include -#endif +done -#if HAVE_CTYPE_H -# include -#endif -#if defined(HAVE_GL_GL_H) -# include -#elif defined(HAVE_OPENGL_GL_H) -# include -#endif +echo "$as_me:$LINENO: checking whether alcCloseDevice returns void" >&5 +echo $ECHO_N "checking whether alcCloseDevice returns void... $ECHO_C" >&6 +if test "${fp_cv_func_alcclosedevice_void+set}" = set; then + echo $ECHO_N "(cached) $ECHO_C" >&6 +else + cat >conftest.$ac_ext <<_ACEOF +#line $LINENO "configure" +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +$ac_includes_default #if defined(HAVE_AL_ALC_H) -# include +#include #elif defined(HAVE_OPENAL_ALC_H) -# include -#endif - -#if HAVE_SYS_RESOURCE_H -# include +#include #endif -typedef ALboolean testing; - -main() { - FILE *f=fopen("conftestval", "w"); - if (!f) exit(1); - if (((testing)((int)((testing)1.4))) == ((testing)1.4)) { - fprintf(f, "%s%d\n", - ((testing)(-1) < (testing)0) ? "Int" : "Word", - sizeof(testing)*8); - } else { - fprintf(f,"%s\n", - (sizeof(testing) > sizeof(double)) ? "LDouble" : - (sizeof(testing) == sizeof(double)) ? "Double" : "Float"); - } - fclose(f); - exit(0); +int +main () +{ +int x = (int)alcCloseDevice(NULL); + ; + return 0; } _ACEOF -rm -f conftest$ac_exeext -if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5 - (eval $ac_link) 2>&5 +rm -f conftest.$ac_objext +if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 + (eval $ac_compile) 2>&5 ac_status=$? echo "$as_me:$LINENO: \$? = $ac_status" >&5 - (exit $ac_status); } && { ac_try='./conftest$ac_exeext' + (exit $ac_status); } && + { ac_try='test -s conftest.$ac_objext' { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 (eval $ac_try) 2>&5 ac_status=$? echo "$as_me:$LINENO: \$? = $ac_status" >&5 (exit $ac_status); }; }; then - fptools_cv_htype_ALboolean=`cat conftestval` + fp_cv_func_alcclosedevice_void=no else - echo "$as_me: program exited with status $ac_status" >&5 -echo "$as_me: failed program was:" >&5 + echo "$as_me: failed program was:" >&5 sed 's/^/| /' conftest.$ac_ext >&5 -( exit $ac_status ) +fp_cv_func_alcclosedevice_void=yes +fi +rm -f conftest.$ac_objext conftest.$ac_ext +fi +echo "$as_me:$LINENO: result: $fp_cv_func_alcclosedevice_void" >&5 +echo "${ECHO_T}$fp_cv_func_alcclosedevice_void" >&6 +if test x"$fp_cv_func_alcclosedevice_void" = xyes; then + +cat >>confdefs.h <<\_ACEOF +#define ALCCLOSEDEVICE_VOID 1 +_ACEOF + +fi + + +echo "$as_me:$LINENO: checking whether alcMakeContextCurrent returns void" >&5 +echo $ECHO_N "checking whether alcMakeContextCurrent returns void... $ECHO_C" >&6 +if test "${fp_cv_func_alcmakecontextcurrent_void+set}" = set; then + echo $ECHO_N "(cached) $ECHO_C" >&6 +else + cat >conftest.$ac_ext <<_ACEOF +#line $LINENO "configure" +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +$ac_includes_default +#if defined(HAVE_AL_ALC_H) +#include +#elif defined(HAVE_OPENAL_ALC_H) +#include +#endif + +int +main () +{ +int x = (int)alcMakeContextCurrent(NULL); + ; + return 0; +} +_ACEOF +rm -f conftest.$ac_objext +if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 + (eval $ac_compile) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -s conftest.$ac_objext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + fp_cv_func_alcmakecontextcurrent_void=no +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +fp_cv_func_alcmakecontextcurrent_void=yes +fi +rm -f conftest.$ac_objext conftest.$ac_ext +fi +echo "$as_me:$LINENO: result: $fp_cv_func_alcmakecontextcurrent_void" >&5 +echo "${ECHO_T}$fp_cv_func_alcmakecontextcurrent_void" >&6 +if test x"$fp_cv_func_alcmakecontextcurrent_void)" = xyes; then + +cat >>confdefs.h <<\_ACEOF +#define ALCMAKECONTEXTCURRENT_VOID 1 +_ACEOF + +fi + + +echo "$as_me:$LINENO: checking whether alcProcessContext returns void" >&5 +echo $ECHO_N "checking whether alcProcessContext returns void... $ECHO_C" >&6 +if test "${fp_cv_func_alcprocesscontext_void+set}" = set; then + echo $ECHO_N "(cached) $ECHO_C" >&6 +else + cat >conftest.$ac_ext <<_ACEOF +#line $LINENO "configure" +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +$ac_includes_default +#if defined(HAVE_AL_ALC_H) +#include +#elif defined(HAVE_OPENAL_ALC_H) +#include +#endif + +int +main () +{ +int x = (int)alcProcessContext(NULL); + ; + return 0; +} +_ACEOF +rm -f conftest.$ac_objext +if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 + (eval $ac_compile) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -s conftest.$ac_objext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + fp_cv_func_alcprocesscontext_void=no +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +fp_cv_func_alcprocesscontext_void=yes +fi +rm -f conftest.$ac_objext conftest.$ac_ext +fi +echo "$as_me:$LINENO: result: $fp_cv_func_alcprocesscontext_void" >&5 +echo "${ECHO_T}$fp_cv_func_alcprocesscontext_void" >&6 +if test x"$fp_cv_func_alcprocesscontext_void" = xyes; then + +cat >>confdefs.h <<\_ACEOF +#define ALCPROCESSCONTEXT_VOID 1 +_ACEOF + +fi + + +echo "$as_me:$LINENO: checking whether alcDestroyContext returns void" >&5 +echo $ECHO_N "checking whether alcDestroyContext returns void... $ECHO_C" >&6 +if test "${fp_cv_func_alcdestroycontext_void+set}" = set; then + echo $ECHO_N "(cached) $ECHO_C" >&6 +else + cat >conftest.$ac_ext <<_ACEOF +#line $LINENO "configure" +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +$ac_includes_default +#if defined(HAVE_AL_ALC_H) +#include +#elif defined(HAVE_OPENAL_ALC_H) +#include +#endif + +int +main () +{ +int x = (int)alcDestroyContext(NULL); + ; + return 0; +} +_ACEOF +rm -f conftest.$ac_objext +if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 + (eval $ac_compile) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -s conftest.$ac_objext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + fp_cv_func_alcdestroycontext_void=no +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +fp_cv_func_alcdestroycontext_void=yes +fi +rm -f conftest.$ac_objext conftest.$ac_ext +fi +echo "$as_me:$LINENO: result: $fp_cv_func_alcdestroycontext_void" >&5 +echo "${ECHO_T}$fp_cv_func_alcdestroycontext_void" >&6 +if test x"$fp_cv_func_alcdestroycontext_void" = xyes; then + +cat >>confdefs.h <<\_ACEOF +#define ALCDESTROYCONTEXT_VOID 1 +_ACEOF + +fi + + +echo "$as_me:$LINENO: checking Haskell type for ALboolean" >&5 +echo $ECHO_N "checking Haskell type for ALboolean... $ECHO_C" >&6 +if test "${fptools_cv_htype_ALboolean+set}" = set; then + echo $ECHO_N "(cached) $ECHO_C" >&6 +else + fptools_cv_htype_sup_ALboolean=yes +fp_check_htype_save_cppflags="$CPPFLAGS" +CPPFLAGS="$CPPFLAGS $X_CFLAGS" +if test "$cross_compiling" = yes; then + fptools_cv_htype_ALboolean=NotReallyATypeCross; fptools_cv_htype_sup_ALboolean=no +else + cat >conftest.$ac_ext <<_ACEOF +#line $LINENO "configure" +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +#include +#include + +#if HAVE_SYS_TYPES_H +# include +#endif + +#if HAVE_UNISTD_H +# include +#endif + +#if HAVE_SYS_STAT_H +# include +#endif + +#if HAVE_FCNTL_H +# include +#endif + +#if HAVE_SIGNAL_H +# include +#endif + +#if HAVE_TIME_H +# include +#endif + +#if HAVE_TERMIOS_H +# include +#endif + +#if HAVE_STRING_H +# include +#endif + +#if HAVE_CTYPE_H +# include +#endif + +#if defined(HAVE_GL_GL_H) +# include +#elif defined(HAVE_OPENGL_GL_H) +# include +#endif + +#if defined(HAVE_AL_AL_H) +# include +#elif defined(HAVE_OPENAL_AL_H) +# include +#endif + +#if defined(HAVE_AL_ALC_H) +# include +#elif defined(HAVE_OPENAL_ALC_H) +# include +#endif + +#if HAVE_SYS_RESOURCE_H +# include +#endif + +typedef ALboolean testing; + +main() { + FILE *f=fopen("conftestval", "w"); + if (!f) exit(1); + if (((testing)((int)((testing)1.4))) == ((testing)1.4)) { + fprintf(f, "%s%d\n", + ((testing)(-1) < (testing)0) ? "Int" : "Word", + sizeof(testing)*8); + } else { + fprintf(f,"%s\n", + (sizeof(testing) > sizeof(double)) ? "LDouble" : + (sizeof(testing) == sizeof(double)) ? "Double" : "Float"); + } + fclose(f); + exit(0); +} +_ACEOF +rm -f conftest$ac_exeext +if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5 + (eval $ac_link) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && { ac_try='./conftest$ac_exeext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + fptools_cv_htype_ALboolean=`cat conftestval` +else + echo "$as_me: program exited with status $ac_status" >&5 +echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +( exit $ac_status ) fptools_cv_htype_ALboolean=NotReallyAType; fptools_cv_htype_sup_ALboolean=no fi rm -f core core.* *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext fi +CPPFLAGS="$fp_check_htype_save_cppflags" +fi + if test "$fptools_cv_htype_sup_ALboolean" = yes; then + echo "$as_me:$LINENO: result: $fptools_cv_htype_ALboolean" >&5 +echo "${ECHO_T}$fptools_cv_htype_ALboolean" >&6 + +cat >>confdefs.h <<_ACEOF +#define HTYPE_ALBOOLEAN $fptools_cv_htype_ALboolean +_ACEOF + +else + echo "$as_me:$LINENO: result: not supported" >&5 +echo "${ECHO_T}not supported" >&6 +fi + +echo "$as_me:$LINENO: checking Haskell type for ALchar" >&5 +echo $ECHO_N "checking Haskell type for ALchar... $ECHO_C" >&6 +if test "${fptools_cv_htype_ALchar+set}" = set; then + echo $ECHO_N "(cached) $ECHO_C" >&6 +else + fptools_cv_htype_sup_ALchar=yes +fp_check_htype_save_cppflags="$CPPFLAGS" +CPPFLAGS="$CPPFLAGS $X_CFLAGS" +if test "$cross_compiling" = yes; then + fptools_cv_htype_ALchar=NotReallyATypeCross; fptools_cv_htype_sup_ALchar=no +else + cat >conftest.$ac_ext <<_ACEOF +#line $LINENO "configure" +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +#include +#include + +#if HAVE_SYS_TYPES_H +# include +#endif + +#if HAVE_UNISTD_H +# include +#endif + +#if HAVE_SYS_STAT_H +# include +#endif + +#if HAVE_FCNTL_H +# include +#endif + +#if HAVE_SIGNAL_H +# include +#endif + +#if HAVE_TIME_H +# include +#endif + +#if HAVE_TERMIOS_H +# include +#endif + +#if HAVE_STRING_H +# include +#endif + +#if HAVE_CTYPE_H +# include +#endif + +#if defined(HAVE_GL_GL_H) +# include +#elif defined(HAVE_OPENGL_GL_H) +# include +#endif + +#if defined(HAVE_AL_AL_H) +# include +#elif defined(HAVE_OPENAL_AL_H) +# include +#endif + +#if defined(HAVE_AL_ALC_H) +# include +#elif defined(HAVE_OPENAL_ALC_H) +# include +#endif + +#if HAVE_SYS_RESOURCE_H +# include +#endif + +typedef ALchar testing; + +main() { + FILE *f=fopen("conftestval", "w"); + if (!f) exit(1); + if (((testing)((int)((testing)1.4))) == ((testing)1.4)) { + fprintf(f, "%s%d\n", + ((testing)(-1) < (testing)0) ? "Int" : "Word", + sizeof(testing)*8); + } else { + fprintf(f,"%s\n", + (sizeof(testing) > sizeof(double)) ? "LDouble" : + (sizeof(testing) == sizeof(double)) ? "Double" : "Float"); + } + fclose(f); + exit(0); +} +_ACEOF +rm -f conftest$ac_exeext +if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5 + (eval $ac_link) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && { ac_try='./conftest$ac_exeext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + fptools_cv_htype_ALchar=`cat conftestval` +else + echo "$as_me: program exited with status $ac_status" >&5 +echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +( exit $ac_status ) +fptools_cv_htype_ALchar=Int8 +fi +rm -f core core.* *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext +fi +CPPFLAGS="$fp_check_htype_save_cppflags" +fi + if test "$fptools_cv_htype_sup_ALchar" = yes; then + echo "$as_me:$LINENO: result: $fptools_cv_htype_ALchar" >&5 +echo "${ECHO_T}$fptools_cv_htype_ALchar" >&6 + +cat >>confdefs.h <<_ACEOF +#define HTYPE_ALCHAR $fptools_cv_htype_ALchar +_ACEOF + +else + echo "$as_me:$LINENO: result: not supported" >&5 +echo "${ECHO_T}not supported" >&6 +fi + +echo "$as_me:$LINENO: checking Haskell type for ALbyte" >&5 +echo $ECHO_N "checking Haskell type for ALbyte... $ECHO_C" >&6 +if test "${fptools_cv_htype_ALbyte+set}" = set; then + echo $ECHO_N "(cached) $ECHO_C" >&6 +else + fptools_cv_htype_sup_ALbyte=yes +fp_check_htype_save_cppflags="$CPPFLAGS" +CPPFLAGS="$CPPFLAGS $X_CFLAGS" +if test "$cross_compiling" = yes; then + fptools_cv_htype_ALbyte=NotReallyATypeCross; fptools_cv_htype_sup_ALbyte=no +else + cat >conftest.$ac_ext <<_ACEOF +#line $LINENO "configure" +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +#include +#include + +#if HAVE_SYS_TYPES_H +# include +#endif + +#if HAVE_UNISTD_H +# include +#endif + +#if HAVE_SYS_STAT_H +# include +#endif + +#if HAVE_FCNTL_H +# include +#endif + +#if HAVE_SIGNAL_H +# include +#endif + +#if HAVE_TIME_H +# include +#endif + +#if HAVE_TERMIOS_H +# include +#endif + +#if HAVE_STRING_H +# include +#endif + +#if HAVE_CTYPE_H +# include +#endif + +#if defined(HAVE_GL_GL_H) +# include +#elif defined(HAVE_OPENGL_GL_H) +# include +#endif + +#if defined(HAVE_AL_AL_H) +# include +#elif defined(HAVE_OPENAL_AL_H) +# include +#endif + +#if defined(HAVE_AL_ALC_H) +# include +#elif defined(HAVE_OPENAL_ALC_H) +# include +#endif + +#if HAVE_SYS_RESOURCE_H +# include +#endif + +typedef ALbyte testing; + +main() { + FILE *f=fopen("conftestval", "w"); + if (!f) exit(1); + if (((testing)((int)((testing)1.4))) == ((testing)1.4)) { + fprintf(f, "%s%d\n", + ((testing)(-1) < (testing)0) ? "Int" : "Word", + sizeof(testing)*8); + } else { + fprintf(f,"%s\n", + (sizeof(testing) > sizeof(double)) ? "LDouble" : + (sizeof(testing) == sizeof(double)) ? "Double" : "Float"); + } + fclose(f); + exit(0); +} +_ACEOF +rm -f conftest$ac_exeext +if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5 + (eval $ac_link) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && { ac_try='./conftest$ac_exeext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + fptools_cv_htype_ALbyte=`cat conftestval` +else + echo "$as_me: program exited with status $ac_status" >&5 +echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +( exit $ac_status ) +fptools_cv_htype_ALbyte=NotReallyAType; fptools_cv_htype_sup_ALbyte=no +fi +rm -f core core.* *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext +fi +CPPFLAGS="$fp_check_htype_save_cppflags" +fi + if test "$fptools_cv_htype_sup_ALbyte" = yes; then + echo "$as_me:$LINENO: result: $fptools_cv_htype_ALbyte" >&5 +echo "${ECHO_T}$fptools_cv_htype_ALbyte" >&6 + +cat >>confdefs.h <<_ACEOF +#define HTYPE_ALBYTE $fptools_cv_htype_ALbyte +_ACEOF + +else + echo "$as_me:$LINENO: result: not supported" >&5 +echo "${ECHO_T}not supported" >&6 +fi + +echo "$as_me:$LINENO: checking Haskell type for ALubyte" >&5 +echo $ECHO_N "checking Haskell type for ALubyte... $ECHO_C" >&6 +if test "${fptools_cv_htype_ALubyte+set}" = set; then + echo $ECHO_N "(cached) $ECHO_C" >&6 +else + fptools_cv_htype_sup_ALubyte=yes +fp_check_htype_save_cppflags="$CPPFLAGS" +CPPFLAGS="$CPPFLAGS $X_CFLAGS" +if test "$cross_compiling" = yes; then + fptools_cv_htype_ALubyte=NotReallyATypeCross; fptools_cv_htype_sup_ALubyte=no +else + cat >conftest.$ac_ext <<_ACEOF +#line $LINENO "configure" +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +#include +#include + +#if HAVE_SYS_TYPES_H +# include +#endif + +#if HAVE_UNISTD_H +# include +#endif + +#if HAVE_SYS_STAT_H +# include +#endif + +#if HAVE_FCNTL_H +# include +#endif + +#if HAVE_SIGNAL_H +# include +#endif + +#if HAVE_TIME_H +# include +#endif + +#if HAVE_TERMIOS_H +# include +#endif + +#if HAVE_STRING_H +# include +#endif + +#if HAVE_CTYPE_H +# include +#endif + +#if defined(HAVE_GL_GL_H) +# include +#elif defined(HAVE_OPENGL_GL_H) +# include +#endif + +#if defined(HAVE_AL_AL_H) +# include +#elif defined(HAVE_OPENAL_AL_H) +# include +#endif + +#if defined(HAVE_AL_ALC_H) +# include +#elif defined(HAVE_OPENAL_ALC_H) +# include +#endif + +#if HAVE_SYS_RESOURCE_H +# include +#endif + +typedef ALubyte testing; + +main() { + FILE *f=fopen("conftestval", "w"); + if (!f) exit(1); + if (((testing)((int)((testing)1.4))) == ((testing)1.4)) { + fprintf(f, "%s%d\n", + ((testing)(-1) < (testing)0) ? "Int" : "Word", + sizeof(testing)*8); + } else { + fprintf(f,"%s\n", + (sizeof(testing) > sizeof(double)) ? "LDouble" : + (sizeof(testing) == sizeof(double)) ? "Double" : "Float"); + } + fclose(f); + exit(0); +} +_ACEOF +rm -f conftest$ac_exeext +if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5 + (eval $ac_link) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && { ac_try='./conftest$ac_exeext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + fptools_cv_htype_ALubyte=`cat conftestval` +else + echo "$as_me: program exited with status $ac_status" >&5 +echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +( exit $ac_status ) +fptools_cv_htype_ALubyte=NotReallyAType; fptools_cv_htype_sup_ALubyte=no +fi +rm -f core core.* *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext +fi +CPPFLAGS="$fp_check_htype_save_cppflags" +fi + if test "$fptools_cv_htype_sup_ALubyte" = yes; then + echo "$as_me:$LINENO: result: $fptools_cv_htype_ALubyte" >&5 +echo "${ECHO_T}$fptools_cv_htype_ALubyte" >&6 + +cat >>confdefs.h <<_ACEOF +#define HTYPE_ALUBYTE $fptools_cv_htype_ALubyte +_ACEOF + +else + echo "$as_me:$LINENO: result: not supported" >&5 +echo "${ECHO_T}not supported" >&6 +fi + +echo "$as_me:$LINENO: checking Haskell type for ALshort" >&5 +echo $ECHO_N "checking Haskell type for ALshort... $ECHO_C" >&6 +if test "${fptools_cv_htype_ALshort+set}" = set; then + echo $ECHO_N "(cached) $ECHO_C" >&6 +else + fptools_cv_htype_sup_ALshort=yes +fp_check_htype_save_cppflags="$CPPFLAGS" +CPPFLAGS="$CPPFLAGS $X_CFLAGS" +if test "$cross_compiling" = yes; then + fptools_cv_htype_ALshort=NotReallyATypeCross; fptools_cv_htype_sup_ALshort=no +else + cat >conftest.$ac_ext <<_ACEOF +#line $LINENO "configure" +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +#include +#include + +#if HAVE_SYS_TYPES_H +# include +#endif + +#if HAVE_UNISTD_H +# include +#endif + +#if HAVE_SYS_STAT_H +# include +#endif + +#if HAVE_FCNTL_H +# include +#endif + +#if HAVE_SIGNAL_H +# include +#endif + +#if HAVE_TIME_H +# include +#endif + +#if HAVE_TERMIOS_H +# include +#endif + +#if HAVE_STRING_H +# include +#endif + +#if HAVE_CTYPE_H +# include +#endif + +#if defined(HAVE_GL_GL_H) +# include +#elif defined(HAVE_OPENGL_GL_H) +# include +#endif + +#if defined(HAVE_AL_AL_H) +# include +#elif defined(HAVE_OPENAL_AL_H) +# include +#endif + +#if defined(HAVE_AL_ALC_H) +# include +#elif defined(HAVE_OPENAL_ALC_H) +# include +#endif + +#if HAVE_SYS_RESOURCE_H +# include +#endif + +typedef ALshort testing; + +main() { + FILE *f=fopen("conftestval", "w"); + if (!f) exit(1); + if (((testing)((int)((testing)1.4))) == ((testing)1.4)) { + fprintf(f, "%s%d\n", + ((testing)(-1) < (testing)0) ? "Int" : "Word", + sizeof(testing)*8); + } else { + fprintf(f,"%s\n", + (sizeof(testing) > sizeof(double)) ? "LDouble" : + (sizeof(testing) == sizeof(double)) ? "Double" : "Float"); + } + fclose(f); + exit(0); +} +_ACEOF +rm -f conftest$ac_exeext +if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5 + (eval $ac_link) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && { ac_try='./conftest$ac_exeext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + fptools_cv_htype_ALshort=`cat conftestval` +else + echo "$as_me: program exited with status $ac_status" >&5 +echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +( exit $ac_status ) +fptools_cv_htype_ALshort=NotReallyAType; fptools_cv_htype_sup_ALshort=no +fi +rm -f core core.* *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext +fi +CPPFLAGS="$fp_check_htype_save_cppflags" +fi + if test "$fptools_cv_htype_sup_ALshort" = yes; then + echo "$as_me:$LINENO: result: $fptools_cv_htype_ALshort" >&5 +echo "${ECHO_T}$fptools_cv_htype_ALshort" >&6 + +cat >>confdefs.h <<_ACEOF +#define HTYPE_ALSHORT $fptools_cv_htype_ALshort +_ACEOF + +else + echo "$as_me:$LINENO: result: not supported" >&5 +echo "${ECHO_T}not supported" >&6 +fi + +echo "$as_me:$LINENO: checking Haskell type for ALushort" >&5 +echo $ECHO_N "checking Haskell type for ALushort... $ECHO_C" >&6 +if test "${fptools_cv_htype_ALushort+set}" = set; then + echo $ECHO_N "(cached) $ECHO_C" >&6 +else + fptools_cv_htype_sup_ALushort=yes +fp_check_htype_save_cppflags="$CPPFLAGS" +CPPFLAGS="$CPPFLAGS $X_CFLAGS" +if test "$cross_compiling" = yes; then + fptools_cv_htype_ALushort=NotReallyATypeCross; fptools_cv_htype_sup_ALushort=no +else + cat >conftest.$ac_ext <<_ACEOF +#line $LINENO "configure" +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +#include +#include + +#if HAVE_SYS_TYPES_H +# include +#endif + +#if HAVE_UNISTD_H +# include +#endif + +#if HAVE_SYS_STAT_H +# include +#endif + +#if HAVE_FCNTL_H +# include +#endif + +#if HAVE_SIGNAL_H +# include +#endif + +#if HAVE_TIME_H +# include +#endif + +#if HAVE_TERMIOS_H +# include +#endif + +#if HAVE_STRING_H +# include +#endif + +#if HAVE_CTYPE_H +# include +#endif + +#if defined(HAVE_GL_GL_H) +# include +#elif defined(HAVE_OPENGL_GL_H) +# include +#endif + +#if defined(HAVE_AL_AL_H) +# include +#elif defined(HAVE_OPENAL_AL_H) +# include +#endif + +#if defined(HAVE_AL_ALC_H) +# include +#elif defined(HAVE_OPENAL_ALC_H) +# include +#endif + +#if HAVE_SYS_RESOURCE_H +# include +#endif + +typedef ALushort testing; + +main() { + FILE *f=fopen("conftestval", "w"); + if (!f) exit(1); + if (((testing)((int)((testing)1.4))) == ((testing)1.4)) { + fprintf(f, "%s%d\n", + ((testing)(-1) < (testing)0) ? "Int" : "Word", + sizeof(testing)*8); + } else { + fprintf(f,"%s\n", + (sizeof(testing) > sizeof(double)) ? "LDouble" : + (sizeof(testing) == sizeof(double)) ? "Double" : "Float"); + } + fclose(f); + exit(0); +} +_ACEOF +rm -f conftest$ac_exeext +if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5 + (eval $ac_link) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && { ac_try='./conftest$ac_exeext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + fptools_cv_htype_ALushort=`cat conftestval` +else + echo "$as_me: program exited with status $ac_status" >&5 +echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +( exit $ac_status ) +fptools_cv_htype_ALushort=NotReallyAType; fptools_cv_htype_sup_ALushort=no +fi +rm -f core core.* *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext +fi +CPPFLAGS="$fp_check_htype_save_cppflags" +fi + if test "$fptools_cv_htype_sup_ALushort" = yes; then + echo "$as_me:$LINENO: result: $fptools_cv_htype_ALushort" >&5 +echo "${ECHO_T}$fptools_cv_htype_ALushort" >&6 + +cat >>confdefs.h <<_ACEOF +#define HTYPE_ALUSHORT $fptools_cv_htype_ALushort +_ACEOF + +else + echo "$as_me:$LINENO: result: not supported" >&5 +echo "${ECHO_T}not supported" >&6 +fi + +echo "$as_me:$LINENO: checking Haskell type for ALint" >&5 +echo $ECHO_N "checking Haskell type for ALint... $ECHO_C" >&6 +if test "${fptools_cv_htype_ALint+set}" = set; then + echo $ECHO_N "(cached) $ECHO_C" >&6 +else + fptools_cv_htype_sup_ALint=yes +fp_check_htype_save_cppflags="$CPPFLAGS" +CPPFLAGS="$CPPFLAGS $X_CFLAGS" +if test "$cross_compiling" = yes; then + fptools_cv_htype_ALint=NotReallyATypeCross; fptools_cv_htype_sup_ALint=no +else + cat >conftest.$ac_ext <<_ACEOF +#line $LINENO "configure" +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +#include +#include + +#if HAVE_SYS_TYPES_H +# include +#endif + +#if HAVE_UNISTD_H +# include +#endif + +#if HAVE_SYS_STAT_H +# include +#endif + +#if HAVE_FCNTL_H +# include +#endif + +#if HAVE_SIGNAL_H +# include +#endif + +#if HAVE_TIME_H +# include +#endif + +#if HAVE_TERMIOS_H +# include +#endif + +#if HAVE_STRING_H +# include +#endif + +#if HAVE_CTYPE_H +# include +#endif + +#if defined(HAVE_GL_GL_H) +# include +#elif defined(HAVE_OPENGL_GL_H) +# include +#endif + +#if defined(HAVE_AL_AL_H) +# include +#elif defined(HAVE_OPENAL_AL_H) +# include +#endif + +#if defined(HAVE_AL_ALC_H) +# include +#elif defined(HAVE_OPENAL_ALC_H) +# include +#endif + +#if HAVE_SYS_RESOURCE_H +# include +#endif + +typedef ALint testing; + +main() { + FILE *f=fopen("conftestval", "w"); + if (!f) exit(1); + if (((testing)((int)((testing)1.4))) == ((testing)1.4)) { + fprintf(f, "%s%d\n", + ((testing)(-1) < (testing)0) ? "Int" : "Word", + sizeof(testing)*8); + } else { + fprintf(f,"%s\n", + (sizeof(testing) > sizeof(double)) ? "LDouble" : + (sizeof(testing) == sizeof(double)) ? "Double" : "Float"); + } + fclose(f); + exit(0); +} +_ACEOF +rm -f conftest$ac_exeext +if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5 + (eval $ac_link) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && { ac_try='./conftest$ac_exeext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + fptools_cv_htype_ALint=`cat conftestval` +else + echo "$as_me: program exited with status $ac_status" >&5 +echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +( exit $ac_status ) +fptools_cv_htype_ALint=NotReallyAType; fptools_cv_htype_sup_ALint=no +fi +rm -f core core.* *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext +fi +CPPFLAGS="$fp_check_htype_save_cppflags" +fi + if test "$fptools_cv_htype_sup_ALint" = yes; then + echo "$as_me:$LINENO: result: $fptools_cv_htype_ALint" >&5 +echo "${ECHO_T}$fptools_cv_htype_ALint" >&6 + +cat >>confdefs.h <<_ACEOF +#define HTYPE_ALINT $fptools_cv_htype_ALint +_ACEOF + +else + echo "$as_me:$LINENO: result: not supported" >&5 +echo "${ECHO_T}not supported" >&6 +fi + +echo "$as_me:$LINENO: checking Haskell type for ALuint" >&5 +echo $ECHO_N "checking Haskell type for ALuint... $ECHO_C" >&6 +if test "${fptools_cv_htype_ALuint+set}" = set; then + echo $ECHO_N "(cached) $ECHO_C" >&6 +else + fptools_cv_htype_sup_ALuint=yes +fp_check_htype_save_cppflags="$CPPFLAGS" +CPPFLAGS="$CPPFLAGS $X_CFLAGS" +if test "$cross_compiling" = yes; then + fptools_cv_htype_ALuint=NotReallyATypeCross; fptools_cv_htype_sup_ALuint=no +else + cat >conftest.$ac_ext <<_ACEOF +#line $LINENO "configure" +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +#include +#include + +#if HAVE_SYS_TYPES_H +# include +#endif + +#if HAVE_UNISTD_H +# include +#endif + +#if HAVE_SYS_STAT_H +# include +#endif + +#if HAVE_FCNTL_H +# include +#endif + +#if HAVE_SIGNAL_H +# include +#endif + +#if HAVE_TIME_H +# include +#endif + +#if HAVE_TERMIOS_H +# include +#endif + +#if HAVE_STRING_H +# include +#endif + +#if HAVE_CTYPE_H +# include +#endif + +#if defined(HAVE_GL_GL_H) +# include +#elif defined(HAVE_OPENGL_GL_H) +# include +#endif + +#if defined(HAVE_AL_AL_H) +# include +#elif defined(HAVE_OPENAL_AL_H) +# include +#endif + +#if defined(HAVE_AL_ALC_H) +# include +#elif defined(HAVE_OPENAL_ALC_H) +# include +#endif + +#if HAVE_SYS_RESOURCE_H +# include +#endif + +typedef ALuint testing; + +main() { + FILE *f=fopen("conftestval", "w"); + if (!f) exit(1); + if (((testing)((int)((testing)1.4))) == ((testing)1.4)) { + fprintf(f, "%s%d\n", + ((testing)(-1) < (testing)0) ? "Int" : "Word", + sizeof(testing)*8); + } else { + fprintf(f,"%s\n", + (sizeof(testing) > sizeof(double)) ? "LDouble" : + (sizeof(testing) == sizeof(double)) ? "Double" : "Float"); + } + fclose(f); + exit(0); +} +_ACEOF +rm -f conftest$ac_exeext +if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5 + (eval $ac_link) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && { ac_try='./conftest$ac_exeext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + fptools_cv_htype_ALuint=`cat conftestval` +else + echo "$as_me: program exited with status $ac_status" >&5 +echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +( exit $ac_status ) +fptools_cv_htype_ALuint=NotReallyAType; fptools_cv_htype_sup_ALuint=no +fi +rm -f core core.* *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext +fi +CPPFLAGS="$fp_check_htype_save_cppflags" +fi + if test "$fptools_cv_htype_sup_ALuint" = yes; then + echo "$as_me:$LINENO: result: $fptools_cv_htype_ALuint" >&5 +echo "${ECHO_T}$fptools_cv_htype_ALuint" >&6 + +cat >>confdefs.h <<_ACEOF +#define HTYPE_ALUINT $fptools_cv_htype_ALuint +_ACEOF + +else + echo "$as_me:$LINENO: result: not supported" >&5 +echo "${ECHO_T}not supported" >&6 +fi + +echo "$as_me:$LINENO: checking Haskell type for ALsizei" >&5 +echo $ECHO_N "checking Haskell type for ALsizei... $ECHO_C" >&6 +if test "${fptools_cv_htype_ALsizei+set}" = set; then + echo $ECHO_N "(cached) $ECHO_C" >&6 +else + fptools_cv_htype_sup_ALsizei=yes +fp_check_htype_save_cppflags="$CPPFLAGS" +CPPFLAGS="$CPPFLAGS $X_CFLAGS" +if test "$cross_compiling" = yes; then + fptools_cv_htype_ALsizei=NotReallyATypeCross; fptools_cv_htype_sup_ALsizei=no +else + cat >conftest.$ac_ext <<_ACEOF +#line $LINENO "configure" +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +#include +#include + +#if HAVE_SYS_TYPES_H +# include +#endif + +#if HAVE_UNISTD_H +# include +#endif + +#if HAVE_SYS_STAT_H +# include +#endif + +#if HAVE_FCNTL_H +# include +#endif + +#if HAVE_SIGNAL_H +# include +#endif + +#if HAVE_TIME_H +# include +#endif + +#if HAVE_TERMIOS_H +# include +#endif + +#if HAVE_STRING_H +# include +#endif + +#if HAVE_CTYPE_H +# include +#endif + +#if defined(HAVE_GL_GL_H) +# include +#elif defined(HAVE_OPENGL_GL_H) +# include +#endif + +#if defined(HAVE_AL_AL_H) +# include +#elif defined(HAVE_OPENAL_AL_H) +# include +#endif + +#if defined(HAVE_AL_ALC_H) +# include +#elif defined(HAVE_OPENAL_ALC_H) +# include +#endif + +#if HAVE_SYS_RESOURCE_H +# include +#endif + +typedef ALsizei testing; + +main() { + FILE *f=fopen("conftestval", "w"); + if (!f) exit(1); + if (((testing)((int)((testing)1.4))) == ((testing)1.4)) { + fprintf(f, "%s%d\n", + ((testing)(-1) < (testing)0) ? "Int" : "Word", + sizeof(testing)*8); + } else { + fprintf(f,"%s\n", + (sizeof(testing) > sizeof(double)) ? "LDouble" : + (sizeof(testing) == sizeof(double)) ? "Double" : "Float"); + } + fclose(f); + exit(0); +} +_ACEOF +rm -f conftest$ac_exeext +if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5 + (eval $ac_link) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && { ac_try='./conftest$ac_exeext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + fptools_cv_htype_ALsizei=`cat conftestval` +else + echo "$as_me: program exited with status $ac_status" >&5 +echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +( exit $ac_status ) +fptools_cv_htype_ALsizei=NotReallyAType; fptools_cv_htype_sup_ALsizei=no +fi +rm -f core core.* *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext +fi +CPPFLAGS="$fp_check_htype_save_cppflags" fi - CPPFLAGS="$fp_check_htype_save_cppflags" -if test "$fptools_cv_htype_sup_ALboolean" = yes; then - echo "$as_me:$LINENO: result: $fptools_cv_htype_ALboolean" >&5 -echo "${ECHO_T}$fptools_cv_htype_ALboolean" >&6 + if test "$fptools_cv_htype_sup_ALsizei" = yes; then + echo "$as_me:$LINENO: result: $fptools_cv_htype_ALsizei" >&5 +echo "${ECHO_T}$fptools_cv_htype_ALsizei" >&6 cat >>confdefs.h <<_ACEOF -#define HTYPE_ALBOOLEAN $fptools_cv_htype_ALboolean +#define HTYPE_ALSIZEI $fptools_cv_htype_ALsizei _ACEOF else @@ -3188,16 +4653,150 @@ echo "${ECHO_T}not supported" >&6 fi -echo "$as_me:$LINENO: checking Haskell type for ALbyte" >&5 -echo $ECHO_N "checking Haskell type for ALbyte... $ECHO_C" >&6 -if test "${fptools_cv_htype_ALbyte+set}" = set; then +echo "$as_me:$LINENO: checking Haskell type for ALenum" >&5 +echo $ECHO_N "checking Haskell type for ALenum... $ECHO_C" >&6 +if test "${fptools_cv_htype_ALenum+set}" = set; then + echo $ECHO_N "(cached) $ECHO_C" >&6 +else + fptools_cv_htype_sup_ALenum=yes +fp_check_htype_save_cppflags="$CPPFLAGS" +CPPFLAGS="$CPPFLAGS $X_CFLAGS" +if test "$cross_compiling" = yes; then + fptools_cv_htype_ALenum=NotReallyATypeCross; fptools_cv_htype_sup_ALenum=no +else + cat >conftest.$ac_ext <<_ACEOF +#line $LINENO "configure" +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +#include +#include + +#if HAVE_SYS_TYPES_H +# include +#endif + +#if HAVE_UNISTD_H +# include +#endif + +#if HAVE_SYS_STAT_H +# include +#endif + +#if HAVE_FCNTL_H +# include +#endif + +#if HAVE_SIGNAL_H +# include +#endif + +#if HAVE_TIME_H +# include +#endif + +#if HAVE_TERMIOS_H +# include +#endif + +#if HAVE_STRING_H +# include +#endif + +#if HAVE_CTYPE_H +# include +#endif + +#if defined(HAVE_GL_GL_H) +# include +#elif defined(HAVE_OPENGL_GL_H) +# include +#endif + +#if defined(HAVE_AL_AL_H) +# include +#elif defined(HAVE_OPENAL_AL_H) +# include +#endif + +#if defined(HAVE_AL_ALC_H) +# include +#elif defined(HAVE_OPENAL_ALC_H) +# include +#endif + +#if HAVE_SYS_RESOURCE_H +# include +#endif + +typedef ALenum testing; + +main() { + FILE *f=fopen("conftestval", "w"); + if (!f) exit(1); + if (((testing)((int)((testing)1.4))) == ((testing)1.4)) { + fprintf(f, "%s%d\n", + ((testing)(-1) < (testing)0) ? "Int" : "Word", + sizeof(testing)*8); + } else { + fprintf(f,"%s\n", + (sizeof(testing) > sizeof(double)) ? "LDouble" : + (sizeof(testing) == sizeof(double)) ? "Double" : "Float"); + } + fclose(f); + exit(0); +} +_ACEOF +rm -f conftest$ac_exeext +if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5 + (eval $ac_link) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && { ac_try='./conftest$ac_exeext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + fptools_cv_htype_ALenum=`cat conftestval` +else + echo "$as_me: program exited with status $ac_status" >&5 +echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +( exit $ac_status ) +fptools_cv_htype_ALenum=NotReallyAType; fptools_cv_htype_sup_ALenum=no +fi +rm -f core core.* *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext +fi +CPPFLAGS="$fp_check_htype_save_cppflags" +fi + if test "$fptools_cv_htype_sup_ALenum" = yes; then + echo "$as_me:$LINENO: result: $fptools_cv_htype_ALenum" >&5 +echo "${ECHO_T}$fptools_cv_htype_ALenum" >&6 + +cat >>confdefs.h <<_ACEOF +#define HTYPE_ALENUM $fptools_cv_htype_ALenum +_ACEOF + +else + echo "$as_me:$LINENO: result: not supported" >&5 +echo "${ECHO_T}not supported" >&6 +fi + +echo "$as_me:$LINENO: checking Haskell type for ALfloat" >&5 +echo $ECHO_N "checking Haskell type for ALfloat... $ECHO_C" >&6 +if test "${fptools_cv_htype_ALfloat+set}" = set; then echo $ECHO_N "(cached) $ECHO_C" >&6 else - fptools_cv_htype_sup_ALbyte=yes + fptools_cv_htype_sup_ALfloat=yes fp_check_htype_save_cppflags="$CPPFLAGS" CPPFLAGS="$CPPFLAGS $X_CFLAGS" if test "$cross_compiling" = yes; then - fptools_cv_htype_ALbyte=NotReallyATypeCross; fptools_cv_htype_sup_ALbyte=no + fptools_cv_htype_ALfloat=NotReallyATypeCross; fptools_cv_htype_sup_ALfloat=no else cat >conftest.$ac_ext <<_ACEOF #line $LINENO "configure" @@ -3251,6 +4850,12 @@ # include #endif +#if defined(HAVE_AL_AL_H) +# include +#elif defined(HAVE_OPENAL_AL_H) +# include +#endif + #if defined(HAVE_AL_ALC_H) # include #elif defined(HAVE_OPENAL_ALC_H) @@ -3261,7 +4866,7 @@ # include #endif -typedef ALbyte testing; +typedef ALfloat testing; main() { FILE *f=fopen("conftestval", "w"); @@ -3290,25 +4895,25 @@ ac_status=$? echo "$as_me:$LINENO: \$? = $ac_status" >&5 (exit $ac_status); }; }; then - fptools_cv_htype_ALbyte=`cat conftestval` + fptools_cv_htype_ALfloat=`cat conftestval` else echo "$as_me: program exited with status $ac_status" >&5 echo "$as_me: failed program was:" >&5 sed 's/^/| /' conftest.$ac_ext >&5 ( exit $ac_status ) -fptools_cv_htype_ALbyte=NotReallyAType; fptools_cv_htype_sup_ALbyte=no +fptools_cv_htype_ALfloat=NotReallyAType; fptools_cv_htype_sup_ALfloat=no fi rm -f core core.* *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext fi +CPPFLAGS="$fp_check_htype_save_cppflags" fi - CPPFLAGS="$fp_check_htype_save_cppflags" -if test "$fptools_cv_htype_sup_ALbyte" = yes; then - echo "$as_me:$LINENO: result: $fptools_cv_htype_ALbyte" >&5 -echo "${ECHO_T}$fptools_cv_htype_ALbyte" >&6 + if test "$fptools_cv_htype_sup_ALfloat" = yes; then + echo "$as_me:$LINENO: result: $fptools_cv_htype_ALfloat" >&5 +echo "${ECHO_T}$fptools_cv_htype_ALfloat" >&6 cat >>confdefs.h <<_ACEOF -#define HTYPE_ALBYTE $fptools_cv_htype_ALbyte +#define HTYPE_ALFLOAT $fptools_cv_htype_ALfloat _ACEOF else @@ -3316,16 +4921,16 @@ echo "${ECHO_T}not supported" >&6 fi -echo "$as_me:$LINENO: checking Haskell type for ALubyte" >&5 -echo $ECHO_N "checking Haskell type for ALubyte... $ECHO_C" >&6 -if test "${fptools_cv_htype_ALubyte+set}" = set; then +echo "$as_me:$LINENO: checking Haskell type for ALdouble" >&5 +echo $ECHO_N "checking Haskell type for ALdouble... $ECHO_C" >&6 +if test "${fptools_cv_htype_ALdouble+set}" = set; then echo $ECHO_N "(cached) $ECHO_C" >&6 else - fptools_cv_htype_sup_ALubyte=yes + fptools_cv_htype_sup_ALdouble=yes fp_check_htype_save_cppflags="$CPPFLAGS" CPPFLAGS="$CPPFLAGS $X_CFLAGS" if test "$cross_compiling" = yes; then - fptools_cv_htype_ALubyte=NotReallyATypeCross; fptools_cv_htype_sup_ALubyte=no + fptools_cv_htype_ALdouble=NotReallyATypeCross; fptools_cv_htype_sup_ALdouble=no else cat >conftest.$ac_ext <<_ACEOF #line $LINENO "configure" @@ -3379,6 +4984,12 @@ # include #endif +#if defined(HAVE_AL_AL_H) +# include +#elif defined(HAVE_OPENAL_AL_H) +# include +#endif + #if defined(HAVE_AL_ALC_H) # include #elif defined(HAVE_OPENAL_ALC_H) @@ -3389,7 +5000,7 @@ # include #endif -typedef ALubyte testing; +typedef ALdouble testing; main() { FILE *f=fopen("conftestval", "w"); @@ -3418,25 +5029,25 @@ ac_status=$? echo "$as_me:$LINENO: \$? = $ac_status" >&5 (exit $ac_status); }; }; then - fptools_cv_htype_ALubyte=`cat conftestval` + fptools_cv_htype_ALdouble=`cat conftestval` else echo "$as_me: program exited with status $ac_status" >&5 echo "$as_me: failed program was:" >&5 sed 's/^/| /' conftest.$ac_ext >&5 ( exit $ac_status ) -fptools_cv_htype_ALubyte=NotReallyAType; fptools_cv_htype_sup_ALubyte=no +fptools_cv_htype_ALdouble=NotReallyAType; fptools_cv_htype_sup_ALdouble=no fi rm -f core core.* *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext fi +CPPFLAGS="$fp_check_htype_save_cppflags" fi - CPPFLAGS="$fp_check_htype_save_cppflags" -if test "$fptools_cv_htype_sup_ALubyte" = yes; then - echo "$as_me:$LINENO: result: $fptools_cv_htype_ALubyte" >&5 -echo "${ECHO_T}$fptools_cv_htype_ALubyte" >&6 + if test "$fptools_cv_htype_sup_ALdouble" = yes; then + echo "$as_me:$LINENO: result: $fptools_cv_htype_ALdouble" >&5 +echo "${ECHO_T}$fptools_cv_htype_ALdouble" >&6 cat >>confdefs.h <<_ACEOF -#define HTYPE_ALUBYTE $fptools_cv_htype_ALubyte +#define HTYPE_ALDOUBLE $fptools_cv_htype_ALdouble _ACEOF else @@ -3444,16 +5055,17 @@ echo "${ECHO_T}not supported" >&6 fi -echo "$as_me:$LINENO: checking Haskell type for ALshort" >&5 -echo $ECHO_N "checking Haskell type for ALshort... $ECHO_C" >&6 -if test "${fptools_cv_htype_ALshort+set}" = set; then + +echo "$as_me:$LINENO: checking Haskell type for ALCboolean" >&5 +echo $ECHO_N "checking Haskell type for ALCboolean... $ECHO_C" >&6 +if test "${fptools_cv_htype_ALCboolean+set}" = set; then echo $ECHO_N "(cached) $ECHO_C" >&6 else - fptools_cv_htype_sup_ALshort=yes + fptools_cv_htype_sup_ALCboolean=yes fp_check_htype_save_cppflags="$CPPFLAGS" CPPFLAGS="$CPPFLAGS $X_CFLAGS" if test "$cross_compiling" = yes; then - fptools_cv_htype_ALshort=NotReallyATypeCross; fptools_cv_htype_sup_ALshort=no + fptools_cv_htype_ALCboolean=NotReallyATypeCross; fptools_cv_htype_sup_ALCboolean=no else cat >conftest.$ac_ext <<_ACEOF #line $LINENO "configure" @@ -3507,6 +5119,12 @@ # include #endif +#if defined(HAVE_AL_AL_H) +# include +#elif defined(HAVE_OPENAL_AL_H) +# include +#endif + #if defined(HAVE_AL_ALC_H) # include #elif defined(HAVE_OPENAL_ALC_H) @@ -3517,7 +5135,7 @@ # include #endif -typedef ALshort testing; +typedef ALCboolean testing; main() { FILE *f=fopen("conftestval", "w"); @@ -3546,25 +5164,25 @@ ac_status=$? echo "$as_me:$LINENO: \$? = $ac_status" >&5 (exit $ac_status); }; }; then - fptools_cv_htype_ALshort=`cat conftestval` + fptools_cv_htype_ALCboolean=`cat conftestval` else echo "$as_me: program exited with status $ac_status" >&5 echo "$as_me: failed program was:" >&5 sed 's/^/| /' conftest.$ac_ext >&5 ( exit $ac_status ) -fptools_cv_htype_ALshort=NotReallyAType; fptools_cv_htype_sup_ALshort=no +fptools_cv_htype_ALCboolean=Int8 fi rm -f core core.* *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext fi +CPPFLAGS="$fp_check_htype_save_cppflags" fi - CPPFLAGS="$fp_check_htype_save_cppflags" -if test "$fptools_cv_htype_sup_ALshort" = yes; then - echo "$as_me:$LINENO: result: $fptools_cv_htype_ALshort" >&5 -echo "${ECHO_T}$fptools_cv_htype_ALshort" >&6 + if test "$fptools_cv_htype_sup_ALCboolean" = yes; then + echo "$as_me:$LINENO: result: $fptools_cv_htype_ALCboolean" >&5 +echo "${ECHO_T}$fptools_cv_htype_ALCboolean" >&6 cat >>confdefs.h <<_ACEOF -#define HTYPE_ALSHORT $fptools_cv_htype_ALshort +#define HTYPE_ALCBOOLEAN $fptools_cv_htype_ALCboolean _ACEOF else @@ -3572,16 +5190,16 @@ echo "${ECHO_T}not supported" >&6 fi -echo "$as_me:$LINENO: checking Haskell type for ALushort" >&5 -echo $ECHO_N "checking Haskell type for ALushort... $ECHO_C" >&6 -if test "${fptools_cv_htype_ALushort+set}" = set; then +echo "$as_me:$LINENO: checking Haskell type for ALCchar" >&5 +echo $ECHO_N "checking Haskell type for ALCchar... $ECHO_C" >&6 +if test "${fptools_cv_htype_ALCchar+set}" = set; then echo $ECHO_N "(cached) $ECHO_C" >&6 else - fptools_cv_htype_sup_ALushort=yes + fptools_cv_htype_sup_ALCchar=yes fp_check_htype_save_cppflags="$CPPFLAGS" CPPFLAGS="$CPPFLAGS $X_CFLAGS" if test "$cross_compiling" = yes; then - fptools_cv_htype_ALushort=NotReallyATypeCross; fptools_cv_htype_sup_ALushort=no + fptools_cv_htype_ALCchar=NotReallyATypeCross; fptools_cv_htype_sup_ALCchar=no else cat >conftest.$ac_ext <<_ACEOF #line $LINENO "configure" @@ -3635,6 +5253,12 @@ # include #endif +#if defined(HAVE_AL_AL_H) +# include +#elif defined(HAVE_OPENAL_AL_H) +# include +#endif + #if defined(HAVE_AL_ALC_H) # include #elif defined(HAVE_OPENAL_ALC_H) @@ -3645,7 +5269,7 @@ # include #endif -typedef ALushort testing; +typedef ALCchar testing; main() { FILE *f=fopen("conftestval", "w"); @@ -3674,25 +5298,25 @@ ac_status=$? echo "$as_me:$LINENO: \$? = $ac_status" >&5 (exit $ac_status); }; }; then - fptools_cv_htype_ALushort=`cat conftestval` + fptools_cv_htype_ALCchar=`cat conftestval` else echo "$as_me: program exited with status $ac_status" >&5 echo "$as_me: failed program was:" >&5 sed 's/^/| /' conftest.$ac_ext >&5 ( exit $ac_status ) -fptools_cv_htype_ALushort=NotReallyAType; fptools_cv_htype_sup_ALushort=no +fptools_cv_htype_ALCchar=Int8 fi rm -f core core.* *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext fi +CPPFLAGS="$fp_check_htype_save_cppflags" fi - CPPFLAGS="$fp_check_htype_save_cppflags" -if test "$fptools_cv_htype_sup_ALushort" = yes; then - echo "$as_me:$LINENO: result: $fptools_cv_htype_ALushort" >&5 -echo "${ECHO_T}$fptools_cv_htype_ALushort" >&6 + if test "$fptools_cv_htype_sup_ALCchar" = yes; then + echo "$as_me:$LINENO: result: $fptools_cv_htype_ALCchar" >&5 +echo "${ECHO_T}$fptools_cv_htype_ALCchar" >&6 cat >>confdefs.h <<_ACEOF -#define HTYPE_ALUSHORT $fptools_cv_htype_ALushort +#define HTYPE_ALCCHAR $fptools_cv_htype_ALCchar _ACEOF else @@ -3700,16 +5324,16 @@ echo "${ECHO_T}not supported" >&6 fi -echo "$as_me:$LINENO: checking Haskell type for ALint" >&5 -echo $ECHO_N "checking Haskell type for ALint... $ECHO_C" >&6 -if test "${fptools_cv_htype_ALint+set}" = set; then +echo "$as_me:$LINENO: checking Haskell type for ALCbyte" >&5 +echo $ECHO_N "checking Haskell type for ALCbyte... $ECHO_C" >&6 +if test "${fptools_cv_htype_ALCbyte+set}" = set; then echo $ECHO_N "(cached) $ECHO_C" >&6 else - fptools_cv_htype_sup_ALint=yes + fptools_cv_htype_sup_ALCbyte=yes fp_check_htype_save_cppflags="$CPPFLAGS" CPPFLAGS="$CPPFLAGS $X_CFLAGS" if test "$cross_compiling" = yes; then - fptools_cv_htype_ALint=NotReallyATypeCross; fptools_cv_htype_sup_ALint=no + fptools_cv_htype_ALCbyte=NotReallyATypeCross; fptools_cv_htype_sup_ALCbyte=no else cat >conftest.$ac_ext <<_ACEOF #line $LINENO "configure" @@ -3763,6 +5387,12 @@ # include #endif +#if defined(HAVE_AL_AL_H) +# include +#elif defined(HAVE_OPENAL_AL_H) +# include +#endif + #if defined(HAVE_AL_ALC_H) # include #elif defined(HAVE_OPENAL_ALC_H) @@ -3773,7 +5403,7 @@ # include #endif -typedef ALint testing; +typedef ALCbyte testing; main() { FILE *f=fopen("conftestval", "w"); @@ -3802,25 +5432,25 @@ ac_status=$? echo "$as_me:$LINENO: \$? = $ac_status" >&5 (exit $ac_status); }; }; then - fptools_cv_htype_ALint=`cat conftestval` + fptools_cv_htype_ALCbyte=`cat conftestval` else echo "$as_me: program exited with status $ac_status" >&5 echo "$as_me: failed program was:" >&5 sed 's/^/| /' conftest.$ac_ext >&5 ( exit $ac_status ) -fptools_cv_htype_ALint=NotReallyAType; fptools_cv_htype_sup_ALint=no +fptools_cv_htype_ALCbyte=Int8 fi rm -f core core.* *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext fi +CPPFLAGS="$fp_check_htype_save_cppflags" fi - CPPFLAGS="$fp_check_htype_save_cppflags" -if test "$fptools_cv_htype_sup_ALint" = yes; then - echo "$as_me:$LINENO: result: $fptools_cv_htype_ALint" >&5 -echo "${ECHO_T}$fptools_cv_htype_ALint" >&6 + if test "$fptools_cv_htype_sup_ALCbyte" = yes; then + echo "$as_me:$LINENO: result: $fptools_cv_htype_ALCbyte" >&5 +echo "${ECHO_T}$fptools_cv_htype_ALCbyte" >&6 cat >>confdefs.h <<_ACEOF -#define HTYPE_ALINT $fptools_cv_htype_ALint +#define HTYPE_ALCBYTE $fptools_cv_htype_ALCbyte _ACEOF else @@ -3828,16 +5458,16 @@ echo "${ECHO_T}not supported" >&6 fi -echo "$as_me:$LINENO: checking Haskell type for ALuint" >&5 -echo $ECHO_N "checking Haskell type for ALuint... $ECHO_C" >&6 -if test "${fptools_cv_htype_ALuint+set}" = set; then +echo "$as_me:$LINENO: checking Haskell type for ALCubyte" >&5 +echo $ECHO_N "checking Haskell type for ALCubyte... $ECHO_C" >&6 +if test "${fptools_cv_htype_ALCubyte+set}" = set; then echo $ECHO_N "(cached) $ECHO_C" >&6 else - fptools_cv_htype_sup_ALuint=yes + fptools_cv_htype_sup_ALCubyte=yes fp_check_htype_save_cppflags="$CPPFLAGS" CPPFLAGS="$CPPFLAGS $X_CFLAGS" if test "$cross_compiling" = yes; then - fptools_cv_htype_ALuint=NotReallyATypeCross; fptools_cv_htype_sup_ALuint=no + fptools_cv_htype_ALCubyte=NotReallyATypeCross; fptools_cv_htype_sup_ALCubyte=no else cat >conftest.$ac_ext <<_ACEOF #line $LINENO "configure" @@ -3891,6 +5521,12 @@ # include #endif +#if defined(HAVE_AL_AL_H) +# include +#elif defined(HAVE_OPENAL_AL_H) +# include +#endif + #if defined(HAVE_AL_ALC_H) # include #elif defined(HAVE_OPENAL_ALC_H) @@ -3901,7 +5537,7 @@ # include #endif -typedef ALuint testing; +typedef ALCubyte testing; main() { FILE *f=fopen("conftestval", "w"); @@ -3930,25 +5566,25 @@ ac_status=$? echo "$as_me:$LINENO: \$? = $ac_status" >&5 (exit $ac_status); }; }; then - fptools_cv_htype_ALuint=`cat conftestval` + fptools_cv_htype_ALCubyte=`cat conftestval` else echo "$as_me: program exited with status $ac_status" >&5 echo "$as_me: failed program was:" >&5 sed 's/^/| /' conftest.$ac_ext >&5 ( exit $ac_status ) -fptools_cv_htype_ALuint=NotReallyAType; fptools_cv_htype_sup_ALuint=no +fptools_cv_htype_ALCubyte=Word8 fi rm -f core core.* *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext fi +CPPFLAGS="$fp_check_htype_save_cppflags" fi - CPPFLAGS="$fp_check_htype_save_cppflags" -if test "$fptools_cv_htype_sup_ALuint" = yes; then - echo "$as_me:$LINENO: result: $fptools_cv_htype_ALuint" >&5 -echo "${ECHO_T}$fptools_cv_htype_ALuint" >&6 + if test "$fptools_cv_htype_sup_ALCubyte" = yes; then + echo "$as_me:$LINENO: result: $fptools_cv_htype_ALCubyte" >&5 +echo "${ECHO_T}$fptools_cv_htype_ALCubyte" >&6 cat >>confdefs.h <<_ACEOF -#define HTYPE_ALUINT $fptools_cv_htype_ALuint +#define HTYPE_ALCUBYTE $fptools_cv_htype_ALCubyte _ACEOF else @@ -3956,16 +5592,16 @@ echo "${ECHO_T}not supported" >&6 fi -echo "$as_me:$LINENO: checking Haskell type for ALsizei" >&5 -echo $ECHO_N "checking Haskell type for ALsizei... $ECHO_C" >&6 -if test "${fptools_cv_htype_ALsizei+set}" = set; then +echo "$as_me:$LINENO: checking Haskell type for ALCshort" >&5 +echo $ECHO_N "checking Haskell type for ALCshort... $ECHO_C" >&6 +if test "${fptools_cv_htype_ALCshort+set}" = set; then echo $ECHO_N "(cached) $ECHO_C" >&6 else - fptools_cv_htype_sup_ALsizei=yes + fptools_cv_htype_sup_ALCshort=yes fp_check_htype_save_cppflags="$CPPFLAGS" CPPFLAGS="$CPPFLAGS $X_CFLAGS" if test "$cross_compiling" = yes; then - fptools_cv_htype_ALsizei=NotReallyATypeCross; fptools_cv_htype_sup_ALsizei=no + fptools_cv_htype_ALCshort=NotReallyATypeCross; fptools_cv_htype_sup_ALCshort=no else cat >conftest.$ac_ext <<_ACEOF #line $LINENO "configure" @@ -4019,6 +5655,12 @@ # include #endif +#if defined(HAVE_AL_AL_H) +# include +#elif defined(HAVE_OPENAL_AL_H) +# include +#endif + #if defined(HAVE_AL_ALC_H) # include #elif defined(HAVE_OPENAL_ALC_H) @@ -4029,7 +5671,7 @@ # include #endif -typedef ALsizei testing; +typedef ALCshort testing; main() { FILE *f=fopen("conftestval", "w"); @@ -4058,25 +5700,25 @@ ac_status=$? echo "$as_me:$LINENO: \$? = $ac_status" >&5 (exit $ac_status); }; }; then - fptools_cv_htype_ALsizei=`cat conftestval` + fptools_cv_htype_ALCshort=`cat conftestval` else echo "$as_me: program exited with status $ac_status" >&5 echo "$as_me: failed program was:" >&5 sed 's/^/| /' conftest.$ac_ext >&5 ( exit $ac_status ) -fptools_cv_htype_ALsizei=NotReallyAType; fptools_cv_htype_sup_ALsizei=no +fptools_cv_htype_ALCshort=Int16 fi rm -f core core.* *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext fi +CPPFLAGS="$fp_check_htype_save_cppflags" fi - CPPFLAGS="$fp_check_htype_save_cppflags" -if test "$fptools_cv_htype_sup_ALsizei" = yes; then - echo "$as_me:$LINENO: result: $fptools_cv_htype_ALsizei" >&5 -echo "${ECHO_T}$fptools_cv_htype_ALsizei" >&6 + if test "$fptools_cv_htype_sup_ALCshort" = yes; then + echo "$as_me:$LINENO: result: $fptools_cv_htype_ALCshort" >&5 +echo "${ECHO_T}$fptools_cv_htype_ALCshort" >&6 cat >>confdefs.h <<_ACEOF -#define HTYPE_ALSIZEI $fptools_cv_htype_ALsizei +#define HTYPE_ALCSHORT $fptools_cv_htype_ALCshort _ACEOF else @@ -4084,16 +5726,16 @@ echo "${ECHO_T}not supported" >&6 fi -echo "$as_me:$LINENO: checking Haskell type for ALenum" >&5 -echo $ECHO_N "checking Haskell type for ALenum... $ECHO_C" >&6 -if test "${fptools_cv_htype_ALenum+set}" = set; then +echo "$as_me:$LINENO: checking Haskell type for ALCushort" >&5 +echo $ECHO_N "checking Haskell type for ALCushort... $ECHO_C" >&6 +if test "${fptools_cv_htype_ALCushort+set}" = set; then echo $ECHO_N "(cached) $ECHO_C" >&6 else - fptools_cv_htype_sup_ALenum=yes + fptools_cv_htype_sup_ALCushort=yes fp_check_htype_save_cppflags="$CPPFLAGS" CPPFLAGS="$CPPFLAGS $X_CFLAGS" if test "$cross_compiling" = yes; then - fptools_cv_htype_ALenum=NotReallyATypeCross; fptools_cv_htype_sup_ALenum=no + fptools_cv_htype_ALCushort=NotReallyATypeCross; fptools_cv_htype_sup_ALCushort=no else cat >conftest.$ac_ext <<_ACEOF #line $LINENO "configure" @@ -4147,6 +5789,12 @@ # include #endif +#if defined(HAVE_AL_AL_H) +# include +#elif defined(HAVE_OPENAL_AL_H) +# include +#endif + #if defined(HAVE_AL_ALC_H) # include #elif defined(HAVE_OPENAL_ALC_H) @@ -4157,7 +5805,7 @@ # include #endif -typedef ALenum testing; +typedef ALCushort testing; main() { FILE *f=fopen("conftestval", "w"); @@ -4186,25 +5834,25 @@ ac_status=$? echo "$as_me:$LINENO: \$? = $ac_status" >&5 (exit $ac_status); }; }; then - fptools_cv_htype_ALenum=`cat conftestval` + fptools_cv_htype_ALCushort=`cat conftestval` else echo "$as_me: program exited with status $ac_status" >&5 echo "$as_me: failed program was:" >&5 sed 's/^/| /' conftest.$ac_ext >&5 ( exit $ac_status ) -fptools_cv_htype_ALenum=NotReallyAType; fptools_cv_htype_sup_ALenum=no +fptools_cv_htype_ALCushort=Word16 fi rm -f core core.* *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext fi +CPPFLAGS="$fp_check_htype_save_cppflags" fi - CPPFLAGS="$fp_check_htype_save_cppflags" -if test "$fptools_cv_htype_sup_ALenum" = yes; then - echo "$as_me:$LINENO: result: $fptools_cv_htype_ALenum" >&5 -echo "${ECHO_T}$fptools_cv_htype_ALenum" >&6 + if test "$fptools_cv_htype_sup_ALCushort" = yes; then + echo "$as_me:$LINENO: result: $fptools_cv_htype_ALCushort" >&5 +echo "${ECHO_T}$fptools_cv_htype_ALCushort" >&6 cat >>confdefs.h <<_ACEOF -#define HTYPE_ALENUM $fptools_cv_htype_ALenum +#define HTYPE_ALCUSHORT $fptools_cv_htype_ALCushort _ACEOF else @@ -4212,16 +5860,16 @@ echo "${ECHO_T}not supported" >&6 fi -echo "$as_me:$LINENO: checking Haskell type for ALbitfield" >&5 -echo $ECHO_N "checking Haskell type for ALbitfield... $ECHO_C" >&6 -if test "${fptools_cv_htype_ALbitfield+set}" = set; then +echo "$as_me:$LINENO: checking Haskell type for ALCint" >&5 +echo $ECHO_N "checking Haskell type for ALCint... $ECHO_C" >&6 +if test "${fptools_cv_htype_ALCint+set}" = set; then echo $ECHO_N "(cached) $ECHO_C" >&6 else - fptools_cv_htype_sup_ALbitfield=yes + fptools_cv_htype_sup_ALCint=yes fp_check_htype_save_cppflags="$CPPFLAGS" CPPFLAGS="$CPPFLAGS $X_CFLAGS" if test "$cross_compiling" = yes; then - fptools_cv_htype_ALbitfield=NotReallyATypeCross; fptools_cv_htype_sup_ALbitfield=no + fptools_cv_htype_ALCint=NotReallyATypeCross; fptools_cv_htype_sup_ALCint=no else cat >conftest.$ac_ext <<_ACEOF #line $LINENO "configure" @@ -4275,6 +5923,12 @@ # include #endif +#if defined(HAVE_AL_AL_H) +# include +#elif defined(HAVE_OPENAL_AL_H) +# include +#endif + #if defined(HAVE_AL_ALC_H) # include #elif defined(HAVE_OPENAL_ALC_H) @@ -4285,7 +5939,7 @@ # include #endif -typedef ALbitfield testing; +typedef ALCint testing; main() { FILE *f=fopen("conftestval", "w"); @@ -4314,25 +5968,25 @@ ac_status=$? echo "$as_me:$LINENO: \$? = $ac_status" >&5 (exit $ac_status); }; }; then - fptools_cv_htype_ALbitfield=`cat conftestval` + fptools_cv_htype_ALCint=`cat conftestval` else echo "$as_me: program exited with status $ac_status" >&5 echo "$as_me: failed program was:" >&5 sed 's/^/| /' conftest.$ac_ext >&5 ( exit $ac_status ) -fptools_cv_htype_ALbitfield=NotReallyAType; fptools_cv_htype_sup_ALbitfield=no +fptools_cv_htype_ALCint=Int32 fi rm -f core core.* *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext fi +CPPFLAGS="$fp_check_htype_save_cppflags" fi - CPPFLAGS="$fp_check_htype_save_cppflags" -if test "$fptools_cv_htype_sup_ALbitfield" = yes; then - echo "$as_me:$LINENO: result: $fptools_cv_htype_ALbitfield" >&5 -echo "${ECHO_T}$fptools_cv_htype_ALbitfield" >&6 + if test "$fptools_cv_htype_sup_ALCint" = yes; then + echo "$as_me:$LINENO: result: $fptools_cv_htype_ALCint" >&5 +echo "${ECHO_T}$fptools_cv_htype_ALCint" >&6 cat >>confdefs.h <<_ACEOF -#define HTYPE_ALBITFIELD $fptools_cv_htype_ALbitfield +#define HTYPE_ALCINT $fptools_cv_htype_ALCint _ACEOF else @@ -4340,16 +5994,16 @@ echo "${ECHO_T}not supported" >&6 fi -echo "$as_me:$LINENO: checking Haskell type for ALfloat" >&5 -echo $ECHO_N "checking Haskell type for ALfloat... $ECHO_C" >&6 -if test "${fptools_cv_htype_ALfloat+set}" = set; then +echo "$as_me:$LINENO: checking Haskell type for ALCuint" >&5 +echo $ECHO_N "checking Haskell type for ALCuint... $ECHO_C" >&6 +if test "${fptools_cv_htype_ALCuint+set}" = set; then echo $ECHO_N "(cached) $ECHO_C" >&6 else - fptools_cv_htype_sup_ALfloat=yes + fptools_cv_htype_sup_ALCuint=yes fp_check_htype_save_cppflags="$CPPFLAGS" CPPFLAGS="$CPPFLAGS $X_CFLAGS" if test "$cross_compiling" = yes; then - fptools_cv_htype_ALfloat=NotReallyATypeCross; fptools_cv_htype_sup_ALfloat=no + fptools_cv_htype_ALCuint=NotReallyATypeCross; fptools_cv_htype_sup_ALCuint=no else cat >conftest.$ac_ext <<_ACEOF #line $LINENO "configure" @@ -4403,6 +6057,12 @@ # include #endif +#if defined(HAVE_AL_AL_H) +# include +#elif defined(HAVE_OPENAL_AL_H) +# include +#endif + #if defined(HAVE_AL_ALC_H) # include #elif defined(HAVE_OPENAL_ALC_H) @@ -4413,7 +6073,7 @@ # include #endif -typedef ALfloat testing; +typedef ALCuint testing; main() { FILE *f=fopen("conftestval", "w"); @@ -4442,25 +6102,25 @@ ac_status=$? echo "$as_me:$LINENO: \$? = $ac_status" >&5 (exit $ac_status); }; }; then - fptools_cv_htype_ALfloat=`cat conftestval` + fptools_cv_htype_ALCuint=`cat conftestval` else echo "$as_me: program exited with status $ac_status" >&5 echo "$as_me: failed program was:" >&5 sed 's/^/| /' conftest.$ac_ext >&5 ( exit $ac_status ) -fptools_cv_htype_ALfloat=NotReallyAType; fptools_cv_htype_sup_ALfloat=no +fptools_cv_htype_ALCuint=Word32 fi rm -f core core.* *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext fi +CPPFLAGS="$fp_check_htype_save_cppflags" fi - CPPFLAGS="$fp_check_htype_save_cppflags" -if test "$fptools_cv_htype_sup_ALfloat" = yes; then - echo "$as_me:$LINENO: result: $fptools_cv_htype_ALfloat" >&5 -echo "${ECHO_T}$fptools_cv_htype_ALfloat" >&6 + if test "$fptools_cv_htype_sup_ALCuint" = yes; then + echo "$as_me:$LINENO: result: $fptools_cv_htype_ALCuint" >&5 +echo "${ECHO_T}$fptools_cv_htype_ALCuint" >&6 cat >>confdefs.h <<_ACEOF -#define HTYPE_ALFLOAT $fptools_cv_htype_ALfloat +#define HTYPE_ALCUINT $fptools_cv_htype_ALCuint _ACEOF else @@ -4468,16 +6128,16 @@ echo "${ECHO_T}not supported" >&6 fi -echo "$as_me:$LINENO: checking Haskell type for ALclampf" >&5 -echo $ECHO_N "checking Haskell type for ALclampf... $ECHO_C" >&6 -if test "${fptools_cv_htype_ALclampf+set}" = set; then +echo "$as_me:$LINENO: checking Haskell type for ALCsizei" >&5 +echo $ECHO_N "checking Haskell type for ALCsizei... $ECHO_C" >&6 +if test "${fptools_cv_htype_ALCsizei+set}" = set; then echo $ECHO_N "(cached) $ECHO_C" >&6 else - fptools_cv_htype_sup_ALclampf=yes + fptools_cv_htype_sup_ALCsizei=yes fp_check_htype_save_cppflags="$CPPFLAGS" CPPFLAGS="$CPPFLAGS $X_CFLAGS" if test "$cross_compiling" = yes; then - fptools_cv_htype_ALclampf=NotReallyATypeCross; fptools_cv_htype_sup_ALclampf=no + fptools_cv_htype_ALCsizei=NotReallyATypeCross; fptools_cv_htype_sup_ALCsizei=no else cat >conftest.$ac_ext <<_ACEOF #line $LINENO "configure" @@ -4531,6 +6191,12 @@ # include #endif +#if defined(HAVE_AL_AL_H) +# include +#elif defined(HAVE_OPENAL_AL_H) +# include +#endif + #if defined(HAVE_AL_ALC_H) # include #elif defined(HAVE_OPENAL_ALC_H) @@ -4541,7 +6207,7 @@ # include #endif -typedef ALclampf testing; +typedef ALCsizei testing; main() { FILE *f=fopen("conftestval", "w"); @@ -4570,25 +6236,25 @@ ac_status=$? echo "$as_me:$LINENO: \$? = $ac_status" >&5 (exit $ac_status); }; }; then - fptools_cv_htype_ALclampf=`cat conftestval` + fptools_cv_htype_ALCsizei=`cat conftestval` else echo "$as_me: program exited with status $ac_status" >&5 echo "$as_me: failed program was:" >&5 sed 's/^/| /' conftest.$ac_ext >&5 ( exit $ac_status ) -fptools_cv_htype_ALclampf=NotReallyAType; fptools_cv_htype_sup_ALclampf=no +fptools_cv_htype_ALCsizei=Int32 fi rm -f core core.* *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext fi +CPPFLAGS="$fp_check_htype_save_cppflags" fi - CPPFLAGS="$fp_check_htype_save_cppflags" -if test "$fptools_cv_htype_sup_ALclampf" = yes; then - echo "$as_me:$LINENO: result: $fptools_cv_htype_ALclampf" >&5 -echo "${ECHO_T}$fptools_cv_htype_ALclampf" >&6 + if test "$fptools_cv_htype_sup_ALCsizei" = yes; then + echo "$as_me:$LINENO: result: $fptools_cv_htype_ALCsizei" >&5 +echo "${ECHO_T}$fptools_cv_htype_ALCsizei" >&6 cat >>confdefs.h <<_ACEOF -#define HTYPE_ALCLAMPF $fptools_cv_htype_ALclampf +#define HTYPE_ALCSIZEI $fptools_cv_htype_ALCsizei _ACEOF else @@ -4596,16 +6262,16 @@ echo "${ECHO_T}not supported" >&6 fi -echo "$as_me:$LINENO: checking Haskell type for ALdouble" >&5 -echo $ECHO_N "checking Haskell type for ALdouble... $ECHO_C" >&6 -if test "${fptools_cv_htype_ALdouble+set}" = set; then +echo "$as_me:$LINENO: checking Haskell type for ALCenum" >&5 +echo $ECHO_N "checking Haskell type for ALCenum... $ECHO_C" >&6 +if test "${fptools_cv_htype_ALCenum+set}" = set; then echo $ECHO_N "(cached) $ECHO_C" >&6 else - fptools_cv_htype_sup_ALdouble=yes + fptools_cv_htype_sup_ALCenum=yes fp_check_htype_save_cppflags="$CPPFLAGS" CPPFLAGS="$CPPFLAGS $X_CFLAGS" if test "$cross_compiling" = yes; then - fptools_cv_htype_ALdouble=NotReallyATypeCross; fptools_cv_htype_sup_ALdouble=no + fptools_cv_htype_ALCenum=NotReallyATypeCross; fptools_cv_htype_sup_ALCenum=no else cat >conftest.$ac_ext <<_ACEOF #line $LINENO "configure" @@ -4659,6 +6325,12 @@ # include #endif +#if defined(HAVE_AL_AL_H) +# include +#elif defined(HAVE_OPENAL_AL_H) +# include +#endif + #if defined(HAVE_AL_ALC_H) # include #elif defined(HAVE_OPENAL_ALC_H) @@ -4669,7 +6341,7 @@ # include #endif -typedef ALdouble testing; +typedef ALCenum testing; main() { FILE *f=fopen("conftestval", "w"); @@ -4698,25 +6370,25 @@ ac_status=$? echo "$as_me:$LINENO: \$? = $ac_status" >&5 (exit $ac_status); }; }; then - fptools_cv_htype_ALdouble=`cat conftestval` + fptools_cv_htype_ALCenum=`cat conftestval` else echo "$as_me: program exited with status $ac_status" >&5 echo "$as_me: failed program was:" >&5 sed 's/^/| /' conftest.$ac_ext >&5 ( exit $ac_status ) -fptools_cv_htype_ALdouble=NotReallyAType; fptools_cv_htype_sup_ALdouble=no +fptools_cv_htype_ALCenum=Int32 fi rm -f core core.* *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext fi +CPPFLAGS="$fp_check_htype_save_cppflags" fi - CPPFLAGS="$fp_check_htype_save_cppflags" -if test "$fptools_cv_htype_sup_ALdouble" = yes; then - echo "$as_me:$LINENO: result: $fptools_cv_htype_ALdouble" >&5 -echo "${ECHO_T}$fptools_cv_htype_ALdouble" >&6 + if test "$fptools_cv_htype_sup_ALCenum" = yes; then + echo "$as_me:$LINENO: result: $fptools_cv_htype_ALCenum" >&5 +echo "${ECHO_T}$fptools_cv_htype_ALCenum" >&6 cat >>confdefs.h <<_ACEOF -#define HTYPE_ALDOUBLE $fptools_cv_htype_ALdouble +#define HTYPE_ALCENUM $fptools_cv_htype_ALCenum _ACEOF else @@ -4724,16 +6396,16 @@ echo "${ECHO_T}not supported" >&6 fi -echo "$as_me:$LINENO: checking Haskell type for ALclampd" >&5 -echo $ECHO_N "checking Haskell type for ALclampd... $ECHO_C" >&6 -if test "${fptools_cv_htype_ALclampd+set}" = set; then +echo "$as_me:$LINENO: checking Haskell type for ALCfloat" >&5 +echo $ECHO_N "checking Haskell type for ALCfloat... $ECHO_C" >&6 +if test "${fptools_cv_htype_ALCfloat+set}" = set; then echo $ECHO_N "(cached) $ECHO_C" >&6 else - fptools_cv_htype_sup_ALclampd=yes + fptools_cv_htype_sup_ALCfloat=yes fp_check_htype_save_cppflags="$CPPFLAGS" CPPFLAGS="$CPPFLAGS $X_CFLAGS" if test "$cross_compiling" = yes; then - fptools_cv_htype_ALclampd=NotReallyATypeCross; fptools_cv_htype_sup_ALclampd=no + fptools_cv_htype_ALCfloat=NotReallyATypeCross; fptools_cv_htype_sup_ALCfloat=no else cat >conftest.$ac_ext <<_ACEOF #line $LINENO "configure" @@ -4787,6 +6459,12 @@ # include #endif +#if defined(HAVE_AL_AL_H) +# include +#elif defined(HAVE_OPENAL_AL_H) +# include +#endif + #if defined(HAVE_AL_ALC_H) # include #elif defined(HAVE_OPENAL_ALC_H) @@ -4797,7 +6475,7 @@ # include #endif -typedef ALclampd testing; +typedef ALCfloat testing; main() { FILE *f=fopen("conftestval", "w"); @@ -4826,25 +6504,25 @@ ac_status=$? echo "$as_me:$LINENO: \$? = $ac_status" >&5 (exit $ac_status); }; }; then - fptools_cv_htype_ALclampd=`cat conftestval` + fptools_cv_htype_ALCfloat=`cat conftestval` else echo "$as_me: program exited with status $ac_status" >&5 echo "$as_me: failed program was:" >&5 sed 's/^/| /' conftest.$ac_ext >&5 ( exit $ac_status ) -fptools_cv_htype_ALclampd=NotReallyAType; fptools_cv_htype_sup_ALclampd=no +fptools_cv_htype_ALCfloat=Float fi rm -f core core.* *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext fi +CPPFLAGS="$fp_check_htype_save_cppflags" fi - CPPFLAGS="$fp_check_htype_save_cppflags" -if test "$fptools_cv_htype_sup_ALclampd" = yes; then - echo "$as_me:$LINENO: result: $fptools_cv_htype_ALclampd" >&5 -echo "${ECHO_T}$fptools_cv_htype_ALclampd" >&6 + if test "$fptools_cv_htype_sup_ALCfloat" = yes; then + echo "$as_me:$LINENO: result: $fptools_cv_htype_ALCfloat" >&5 +echo "${ECHO_T}$fptools_cv_htype_ALCfloat" >&6 cat >>confdefs.h <<_ACEOF -#define HTYPE_ALCLAMPD $fptools_cv_htype_ALclampd +#define HTYPE_ALCFLOAT $fptools_cv_htype_ALCfloat _ACEOF else @@ -4852,16 +6530,16 @@ echo "${ECHO_T}not supported" >&6 fi -echo "$as_me:$LINENO: checking Haskell type for ALCenum" >&5 -echo $ECHO_N "checking Haskell type for ALCenum... $ECHO_C" >&6 -if test "${fptools_cv_htype_ALCenum+set}" = set; then +echo "$as_me:$LINENO: checking Haskell type for ALCdouble" >&5 +echo $ECHO_N "checking Haskell type for ALCdouble... $ECHO_C" >&6 +if test "${fptools_cv_htype_ALCdouble+set}" = set; then echo $ECHO_N "(cached) $ECHO_C" >&6 else - fptools_cv_htype_sup_ALCenum=yes + fptools_cv_htype_sup_ALCdouble=yes fp_check_htype_save_cppflags="$CPPFLAGS" CPPFLAGS="$CPPFLAGS $X_CFLAGS" if test "$cross_compiling" = yes; then - fptools_cv_htype_ALCenum=NotReallyATypeCross; fptools_cv_htype_sup_ALCenum=no + fptools_cv_htype_ALCdouble=NotReallyATypeCross; fptools_cv_htype_sup_ALCdouble=no else cat >conftest.$ac_ext <<_ACEOF #line $LINENO "configure" @@ -4915,6 +6593,12 @@ # include #endif +#if defined(HAVE_AL_AL_H) +# include +#elif defined(HAVE_OPENAL_AL_H) +# include +#endif + #if defined(HAVE_AL_ALC_H) # include #elif defined(HAVE_OPENAL_ALC_H) @@ -4925,7 +6609,7 @@ # include #endif -typedef ALCenum testing; +typedef ALCdouble testing; main() { FILE *f=fopen("conftestval", "w"); @@ -4954,31 +6638,99 @@ ac_status=$? echo "$as_me:$LINENO: \$? = $ac_status" >&5 (exit $ac_status); }; }; then - fptools_cv_htype_ALCenum=`cat conftestval` + fptools_cv_htype_ALCdouble=`cat conftestval` else echo "$as_me: program exited with status $ac_status" >&5 echo "$as_me: failed program was:" >&5 sed 's/^/| /' conftest.$ac_ext >&5 -( exit $ac_status ) -fptools_cv_htype_ALCenum=NotReallyAType; fptools_cv_htype_sup_ALCenum=no -fi -rm -f core core.* *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext -fi -fi - CPPFLAGS="$fp_check_htype_save_cppflags" -if test "$fptools_cv_htype_sup_ALCenum" = yes; then - echo "$as_me:$LINENO: result: $fptools_cv_htype_ALCenum" >&5 -echo "${ECHO_T}$fptools_cv_htype_ALCenum" >&6 +( exit $ac_status ) +fptools_cv_htype_ALCdouble=Double +fi +rm -f core core.* *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext +fi +CPPFLAGS="$fp_check_htype_save_cppflags" +fi + if test "$fptools_cv_htype_sup_ALCdouble" = yes; then + echo "$as_me:$LINENO: result: $fptools_cv_htype_ALCdouble" >&5 +echo "${ECHO_T}$fptools_cv_htype_ALCdouble" >&6 + +cat >>confdefs.h <<_ACEOF +#define HTYPE_ALCDOUBLE $fptools_cv_htype_ALCdouble +_ACEOF + +else + echo "$as_me:$LINENO: result: not supported" >&5 +echo "${ECHO_T}not supported" >&6 +fi + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + -cat >>confdefs.h <<_ACEOF -#define HTYPE_ALCENUM $fptools_cv_htype_ALCenum -_ACEOF -else - echo "$as_me:$LINENO: result: not supported" >&5 -echo "${ECHO_T}not supported" >&6 -fi @@ -4998,7 +6750,7 @@ -for fp_const_name in AL_FORMAT_VORBIS_EXT ALC_FREQUENCY ALC_REFRESH ALC_SYNC ALC_NO_ERROR ALC_INVALID_DEVICE ALC_INVALID_CONTEXT ALC_INVALID_ENUM ALC_INVALID_VALUE ALC_OUT_OF_MEMORY ALC_DEFAULT_DEVICE_SPECIFIER ALC_DEVICE_SPECIFIER ALC_EXTENSIONS ALC_MAJOR_VERSION ALC_MINOR_VERSION ALC_ATTRIBUTES_SIZE ALC_ALL_ATTRIBUTES +for fp_const_name in AL_FALSE AL_TRUE AL_NO_ERROR AL_INVALID_NAME AL_INVALID_ENUM AL_INVALID_VALUE AL_INVALID_OPERATION AL_OUT_OF_MEMORY AL_DOPPLER_FACTOR AL_SPEED_OF_SOUND AL_DISTANCE_MODEL AL_VERSION AL_RENDERER AL_VENDOR AL_EXTENSIONS AL_NONE AL_INVERSE_DISTANCE AL_INVERSE_DISTANCE_CLAMPED AL_LINEAR_DISTANCE AL_LINEAR_DISTANCE_CLAMPED AL_EXPONENT_DISTANCE AL_EXPONENT_DISTANCE_CLAMPED AL_POSITION AL_VELOCITY AL_GAIN AL_ORIENTATION AL_SOURCE_RELATIVE AL_SOURCE_TYPE AL_LOOPING AL_BUFFER AL_BUFFERS_QUEUED AL_BUFFERS_PROCESSED AL_MIN_GAIN AL_MAX_GAIN AL_REFERENCE_DISTANCE AL_ROLLOFF_FACTOR AL_MAX_DISTANCE AL_PITCH AL_DIRECTION AL_CONE_INNER_ANGLE AL_CONE_OUTER_ANGLE AL_CONE_OUTER_GAIN AL_SEC_OFFSET AL_SAMPLE_OFFSET AL_BYTE_OFFSET AL_SOURCE_STATE AL_UNDETERMINED AL_STATIC AL_STREAMING AL_INITIAL AL_PLAYING AL_PAUSED AL_STOPPED AL_FREQUENCY AL_SIZE AL_BITS AL_CHANNELS AL_FORMAT_MONO8 AL_FORMAT_MONO16 AL_FORMAT_STEREO8 AL_FORMAT_STEREO16 ALC_FALSE ALC_TRUE ALC_FREQUENCY ALC_REFRESH ALC_SYNC ALC_MONO_SOURCES ALC_STEREO_SOURCES ALC_NO_ERROR ALC_INVALID_DEVICE ALC_INVALID_CONTEXT ALC_INVALID_ENUM ALC_INVALID_VALUE ALC_INVALID_OPERATION ALC_OUT_OF_MEMORY ALC_DEFAULT_DEVICE_SPECIFIER ALC_DEVICE_SPECIFIER ALC_EXTENSIONS ALC_CAPTURE_DEFAULT_DEVICE_SPECIFIER ALC_CAPTURE_DEVICE_SPECIFIER ALC_ATTRIBUTES_SIZE ALC_ALL_ATTRIBUTES ALC_MAJOR_VERSION ALC_MINOR_VERSION ALC_CAPTURE_SAMPLES do as_fp_Cache=`echo "fp_cv_const_$fp_const_name" | $as_tr_sh` echo "$as_me:$LINENO: checking value of $fp_const_name" >&5 @@ -5028,6 +6780,87 @@ #include #endif +#ifndef AL_SPEED_OF_SOUND +#define AL_SPEED_OF_SOUND 0xC003 +#endif + +#ifndef AL_LINEAR_DISTANCE +#define AL_LINEAR_DISTANCE 0xD003 +#endif + +#ifndef AL_LINEAR_DISTANCE_CLAMPED +#define AL_LINEAR_DISTANCE_CLAMPED 0xD004 +#endif + +#ifndef AL_EXPONENT_DISTANCE +#define AL_EXPONENT_DISTANCE 0xD005 +#endif + +#ifndef AL_EXPONENT_DISTANCE_CLAMPED +#define AL_EXPONENT_DISTANCE_CLAMPED 0xD006 +#endif + +#ifndef AL_SEC_OFFSET +#define AL_SEC_OFFSET 0x1024 +#endif + +#ifndef AL_SAMPLE_OFFSET +#define AL_SAMPLE_OFFSET 0x1025 +#endif + +#ifndef AL_BYTE_OFFSET +#define AL_BYTE_OFFSET 0x1026 +#endif + +#ifndef AL_UNDETERMINED +#define AL_UNDETERMINED 0x1030 +#endif + +#ifndef AL_STATIC +#define AL_STATIC 0x1028 +#endif + +#ifndef ALC_MONO_SOURCES +#define ALC_MONO_SOURCES 0x1010 +#endif + +#ifndef ALC_STEREO_SOURCES +#define ALC_STEREO_SOURCES 0x1011 +#endif + +#ifndef AL_INVALID_ENUM +#ifdef AL_ILLEGAL_ENUM +#define AL_INVALID_ENUM AL_ILLEGAL_ENUM +#else +#define AL_INVALID_ENUM 0xA002 +#endif +#endif + +#ifndef AL_INVALID_OPERATION +#ifdef AL_ILLEGAL_COMMAND +#define AL_INVALID_OPERATION AL_ILLEGAL_COMMAND +#else +#define AL_INVALID_OPERATION 0xA004 +#endif +#endif + +/* NOTE: THIS IS NOT IN ANY HEADER */ +#ifndef ALC_INVALID_OPERATION +#define ALC_INVALID_OPERATION 0xA006 +#endif + +#ifndef ALC_CAPTURE_DEFAULT_DEVICE_SPECIFIER +#define ALC_CAPTURE_DEFAULT_DEVICE_SPECIFIER 0x311 +#endif + +#ifndef ALC_CAPTURE_DEVICE_SPECIFIER +#define ALC_CAPTURE_DEVICE_SPECIFIER 0x310 +#endif + +#ifndef ALC_CAPTURE_SAMPLES +#define ALC_CAPTURE_SAMPLES 0x312 +#endif + int main () @@ -5073,6 +6906,87 @@ #include #endif +#ifndef AL_SPEED_OF_SOUND +#define AL_SPEED_OF_SOUND 0xC003 +#endif + +#ifndef AL_LINEAR_DISTANCE +#define AL_LINEAR_DISTANCE 0xD003 +#endif + +#ifndef AL_LINEAR_DISTANCE_CLAMPED +#define AL_LINEAR_DISTANCE_CLAMPED 0xD004 +#endif + +#ifndef AL_EXPONENT_DISTANCE +#define AL_EXPONENT_DISTANCE 0xD005 +#endif + +#ifndef AL_EXPONENT_DISTANCE_CLAMPED +#define AL_EXPONENT_DISTANCE_CLAMPED 0xD006 +#endif + +#ifndef AL_SEC_OFFSET +#define AL_SEC_OFFSET 0x1024 +#endif + +#ifndef AL_SAMPLE_OFFSET +#define AL_SAMPLE_OFFSET 0x1025 +#endif + +#ifndef AL_BYTE_OFFSET +#define AL_BYTE_OFFSET 0x1026 +#endif + +#ifndef AL_UNDETERMINED +#define AL_UNDETERMINED 0x1030 +#endif + +#ifndef AL_STATIC +#define AL_STATIC 0x1028 +#endif + +#ifndef ALC_MONO_SOURCES +#define ALC_MONO_SOURCES 0x1010 +#endif + +#ifndef ALC_STEREO_SOURCES +#define ALC_STEREO_SOURCES 0x1011 +#endif + +#ifndef AL_INVALID_ENUM +#ifdef AL_ILLEGAL_ENUM +#define AL_INVALID_ENUM AL_ILLEGAL_ENUM +#else +#define AL_INVALID_ENUM 0xA002 +#endif +#endif + +#ifndef AL_INVALID_OPERATION +#ifdef AL_ILLEGAL_COMMAND +#define AL_INVALID_OPERATION AL_ILLEGAL_COMMAND +#else +#define AL_INVALID_OPERATION 0xA004 +#endif +#endif + +/* NOTE: THIS IS NOT IN ANY HEADER */ +#ifndef ALC_INVALID_OPERATION +#define ALC_INVALID_OPERATION 0xA006 +#endif + +#ifndef ALC_CAPTURE_DEFAULT_DEVICE_SPECIFIER +#define ALC_CAPTURE_DEFAULT_DEVICE_SPECIFIER 0x311 +#endif + +#ifndef ALC_CAPTURE_DEVICE_SPECIFIER +#define ALC_CAPTURE_DEVICE_SPECIFIER 0x310 +#endif + +#ifndef ALC_CAPTURE_SAMPLES +#define ALC_CAPTURE_SAMPLES 0x312 +#endif + int main () @@ -5134,6 +7048,87 @@ #include #endif +#ifndef AL_SPEED_OF_SOUND +#define AL_SPEED_OF_SOUND 0xC003 +#endif + +#ifndef AL_LINEAR_DISTANCE +#define AL_LINEAR_DISTANCE 0xD003 +#endif + +#ifndef AL_LINEAR_DISTANCE_CLAMPED +#define AL_LINEAR_DISTANCE_CLAMPED 0xD004 +#endif + +#ifndef AL_EXPONENT_DISTANCE +#define AL_EXPONENT_DISTANCE 0xD005 +#endif + +#ifndef AL_EXPONENT_DISTANCE_CLAMPED +#define AL_EXPONENT_DISTANCE_CLAMPED 0xD006 +#endif + +#ifndef AL_SEC_OFFSET +#define AL_SEC_OFFSET 0x1024 +#endif + +#ifndef AL_SAMPLE_OFFSET +#define AL_SAMPLE_OFFSET 0x1025 +#endif + +#ifndef AL_BYTE_OFFSET +#define AL_BYTE_OFFSET 0x1026 +#endif + +#ifndef AL_UNDETERMINED +#define AL_UNDETERMINED 0x1030 +#endif + +#ifndef AL_STATIC +#define AL_STATIC 0x1028 +#endif + +#ifndef ALC_MONO_SOURCES +#define ALC_MONO_SOURCES 0x1010 +#endif + +#ifndef ALC_STEREO_SOURCES +#define ALC_STEREO_SOURCES 0x1011 +#endif + +#ifndef AL_INVALID_ENUM +#ifdef AL_ILLEGAL_ENUM +#define AL_INVALID_ENUM AL_ILLEGAL_ENUM +#else +#define AL_INVALID_ENUM 0xA002 +#endif +#endif + +#ifndef AL_INVALID_OPERATION +#ifdef AL_ILLEGAL_COMMAND +#define AL_INVALID_OPERATION AL_ILLEGAL_COMMAND +#else +#define AL_INVALID_OPERATION 0xA004 +#endif +#endif + +/* NOTE: THIS IS NOT IN ANY HEADER */ +#ifndef ALC_INVALID_OPERATION +#define ALC_INVALID_OPERATION 0xA006 +#endif + +#ifndef ALC_CAPTURE_DEFAULT_DEVICE_SPECIFIER +#define ALC_CAPTURE_DEFAULT_DEVICE_SPECIFIER 0x311 +#endif + +#ifndef ALC_CAPTURE_DEVICE_SPECIFIER +#define ALC_CAPTURE_DEVICE_SPECIFIER 0x310 +#endif + +#ifndef ALC_CAPTURE_SAMPLES +#define ALC_CAPTURE_SAMPLES 0x312 +#endif + int main () @@ -5179,6 +7174,87 @@ #include #endif +#ifndef AL_SPEED_OF_SOUND +#define AL_SPEED_OF_SOUND 0xC003 +#endif + +#ifndef AL_LINEAR_DISTANCE +#define AL_LINEAR_DISTANCE 0xD003 +#endif + +#ifndef AL_LINEAR_DISTANCE_CLAMPED +#define AL_LINEAR_DISTANCE_CLAMPED 0xD004 +#endif + +#ifndef AL_EXPONENT_DISTANCE +#define AL_EXPONENT_DISTANCE 0xD005 +#endif + +#ifndef AL_EXPONENT_DISTANCE_CLAMPED +#define AL_EXPONENT_DISTANCE_CLAMPED 0xD006 +#endif + +#ifndef AL_SEC_OFFSET +#define AL_SEC_OFFSET 0x1024 +#endif + +#ifndef AL_SAMPLE_OFFSET +#define AL_SAMPLE_OFFSET 0x1025 +#endif + +#ifndef AL_BYTE_OFFSET +#define AL_BYTE_OFFSET 0x1026 +#endif + +#ifndef AL_UNDETERMINED +#define AL_UNDETERMINED 0x1030 +#endif + +#ifndef AL_STATIC +#define AL_STATIC 0x1028 +#endif + +#ifndef ALC_MONO_SOURCES +#define ALC_MONO_SOURCES 0x1010 +#endif + +#ifndef ALC_STEREO_SOURCES +#define ALC_STEREO_SOURCES 0x1011 +#endif + +#ifndef AL_INVALID_ENUM +#ifdef AL_ILLEGAL_ENUM +#define AL_INVALID_ENUM AL_ILLEGAL_ENUM +#else +#define AL_INVALID_ENUM 0xA002 +#endif +#endif + +#ifndef AL_INVALID_OPERATION +#ifdef AL_ILLEGAL_COMMAND +#define AL_INVALID_OPERATION AL_ILLEGAL_COMMAND +#else +#define AL_INVALID_OPERATION 0xA004 +#endif +#endif + +/* NOTE: THIS IS NOT IN ANY HEADER */ +#ifndef ALC_INVALID_OPERATION +#define ALC_INVALID_OPERATION 0xA006 +#endif + +#ifndef ALC_CAPTURE_DEFAULT_DEVICE_SPECIFIER +#define ALC_CAPTURE_DEFAULT_DEVICE_SPECIFIER 0x311 +#endif + +#ifndef ALC_CAPTURE_DEVICE_SPECIFIER +#define ALC_CAPTURE_DEVICE_SPECIFIER 0x310 +#endif + +#ifndef ALC_CAPTURE_SAMPLES +#define ALC_CAPTURE_SAMPLES 0x312 +#endif + int main () @@ -5248,6 +7324,87 @@ #include #endif +#ifndef AL_SPEED_OF_SOUND +#define AL_SPEED_OF_SOUND 0xC003 +#endif + +#ifndef AL_LINEAR_DISTANCE +#define AL_LINEAR_DISTANCE 0xD003 +#endif + +#ifndef AL_LINEAR_DISTANCE_CLAMPED +#define AL_LINEAR_DISTANCE_CLAMPED 0xD004 +#endif + +#ifndef AL_EXPONENT_DISTANCE +#define AL_EXPONENT_DISTANCE 0xD005 +#endif + +#ifndef AL_EXPONENT_DISTANCE_CLAMPED +#define AL_EXPONENT_DISTANCE_CLAMPED 0xD006 +#endif + +#ifndef AL_SEC_OFFSET +#define AL_SEC_OFFSET 0x1024 +#endif + +#ifndef AL_SAMPLE_OFFSET +#define AL_SAMPLE_OFFSET 0x1025 +#endif + +#ifndef AL_BYTE_OFFSET +#define AL_BYTE_OFFSET 0x1026 +#endif + +#ifndef AL_UNDETERMINED +#define AL_UNDETERMINED 0x1030 +#endif + +#ifndef AL_STATIC +#define AL_STATIC 0x1028 +#endif + +#ifndef ALC_MONO_SOURCES +#define ALC_MONO_SOURCES 0x1010 +#endif + +#ifndef ALC_STEREO_SOURCES +#define ALC_STEREO_SOURCES 0x1011 +#endif + +#ifndef AL_INVALID_ENUM +#ifdef AL_ILLEGAL_ENUM +#define AL_INVALID_ENUM AL_ILLEGAL_ENUM +#else +#define AL_INVALID_ENUM 0xA002 +#endif +#endif + +#ifndef AL_INVALID_OPERATION +#ifdef AL_ILLEGAL_COMMAND +#define AL_INVALID_OPERATION AL_ILLEGAL_COMMAND +#else +#define AL_INVALID_OPERATION 0xA004 +#endif +#endif + +/* NOTE: THIS IS NOT IN ANY HEADER */ +#ifndef ALC_INVALID_OPERATION +#define ALC_INVALID_OPERATION 0xA006 +#endif + +#ifndef ALC_CAPTURE_DEFAULT_DEVICE_SPECIFIER +#define ALC_CAPTURE_DEFAULT_DEVICE_SPECIFIER 0x311 +#endif + +#ifndef ALC_CAPTURE_DEVICE_SPECIFIER +#define ALC_CAPTURE_DEVICE_SPECIFIER 0x310 +#endif + +#ifndef ALC_CAPTURE_SAMPLES +#define ALC_CAPTURE_SAMPLES 0x312 +#endif + int main () @@ -5312,6 +7469,87 @@ #include #endif +#ifndef AL_SPEED_OF_SOUND +#define AL_SPEED_OF_SOUND 0xC003 +#endif + +#ifndef AL_LINEAR_DISTANCE +#define AL_LINEAR_DISTANCE 0xD003 +#endif + +#ifndef AL_LINEAR_DISTANCE_CLAMPED +#define AL_LINEAR_DISTANCE_CLAMPED 0xD004 +#endif + +#ifndef AL_EXPONENT_DISTANCE +#define AL_EXPONENT_DISTANCE 0xD005 +#endif + +#ifndef AL_EXPONENT_DISTANCE_CLAMPED +#define AL_EXPONENT_DISTANCE_CLAMPED 0xD006 +#endif + +#ifndef AL_SEC_OFFSET +#define AL_SEC_OFFSET 0x1024 +#endif + +#ifndef AL_SAMPLE_OFFSET +#define AL_SAMPLE_OFFSET 0x1025 +#endif + +#ifndef AL_BYTE_OFFSET +#define AL_BYTE_OFFSET 0x1026 +#endif + +#ifndef AL_UNDETERMINED +#define AL_UNDETERMINED 0x1030 +#endif + +#ifndef AL_STATIC +#define AL_STATIC 0x1028 +#endif + +#ifndef ALC_MONO_SOURCES +#define ALC_MONO_SOURCES 0x1010 +#endif + +#ifndef ALC_STEREO_SOURCES +#define ALC_STEREO_SOURCES 0x1011 +#endif + +#ifndef AL_INVALID_ENUM +#ifdef AL_ILLEGAL_ENUM +#define AL_INVALID_ENUM AL_ILLEGAL_ENUM +#else +#define AL_INVALID_ENUM 0xA002 +#endif +#endif + +#ifndef AL_INVALID_OPERATION +#ifdef AL_ILLEGAL_COMMAND +#define AL_INVALID_OPERATION AL_ILLEGAL_COMMAND +#else +#define AL_INVALID_OPERATION 0xA004 +#endif +#endif + +/* NOTE: THIS IS NOT IN ANY HEADER */ +#ifndef ALC_INVALID_OPERATION +#define ALC_INVALID_OPERATION 0xA006 +#endif + +#ifndef ALC_CAPTURE_DEFAULT_DEVICE_SPECIFIER +#define ALC_CAPTURE_DEFAULT_DEVICE_SPECIFIER 0x311 +#endif + +#ifndef ALC_CAPTURE_DEVICE_SPECIFIER +#define ALC_CAPTURE_DEVICE_SPECIFIER 0x310 +#endif + +#ifndef ALC_CAPTURE_SAMPLES +#define ALC_CAPTURE_SAMPLES 0x312 +#endif + long longval () { return $fp_const_name; } unsigned long ulongval () { return $fp_const_name; } @@ -5402,7 +7640,7 @@ fi -case "$target" in +case "$host" in *-mingw32) CALLCONV=stdcall ;; *) CALLCONV=ccall ;; esac @@ -5770,7 +8008,7 @@ } >&5 cat >&5 <<_CSEOF -This file was extended by Haskell HOpenAL package $as_me 1.0, which was +This file was extended by Haskell HOpenAL package $as_me 1.2, which was generated by GNU Autoconf 2.57. Invocation command line was CONFIG_FILES = $CONFIG_FILES @@ -5830,7 +8068,7 @@ cat >>$CONFIG_STATUS <<_ACEOF ac_cs_version="\\ -Haskell HOpenAL package config.status 1.0 +Haskell HOpenAL package config.status 1.2 configured by $0, generated by GNU Autoconf 2.57, with options \\"`echo "$ac_configure_args" | sed 's/[\\""\`\$]/\\\\&/g'`\\" @@ -6030,9 +8268,9 @@ s,@EXEEXT@,$EXEEXT,;t t s,@OBJEXT@,$OBJEXT,;t t s,@AL_LIBS@,$AL_LIBS,;t t +s,@AL_FRAMEWORKS@,$AL_FRAMEWORKS,;t t s,@CPP@,$CPP,;t t s,@EGREP@,$EGREP,;t t -s,@AL_FRAMEWORKS@,$AL_FRAMEWORKS,;t t s,@BUILD_PACKAGE_BOOL@,$BUILD_PACKAGE_BOOL,;t t s,@CALLCONV@,$CALLCONV,;t t s,@LIBOBJS@,$LIBOBJS,;t t diff -uNr --exclude=autom4te.cache --exclude=.cvsignore hugs98-Mar2005-patched/fptools/libraries/OpenAL/configure.ac ghc-6.4.2/libraries/OpenAL/configure.ac --- hugs98-Mar2005-patched/fptools/libraries/OpenAL/configure.ac 2005-02-04 18:16:28.000000000 +0900 +++ ghc-6.4.2/libraries/OpenAL/configure.ac 2006-03-22 00:58:03.000000000 +0900 @@ -1,4 +1,4 @@ -AC_INIT([Haskell HOpenAL package], [1.0], [sven.panne@aedion.de], [OpenAL]) +AC_INIT([Haskell HOpenAL package], [1.2], [sven.panne@aedion.de], [OpenAL]) # Safety check: Ensure that we are in the correct source directory. AC_CONFIG_SRCDIR([include/HsOpenAL.h.in]) @@ -19,7 +19,7 @@ # The following test for the OpenAL library is a bit of a hack, but gives nice # feedback even for the case when no additional library is needed. (Mac OS X?) AL_LIBS=no -AC_SEARCH_LIBS([alGenSources], [openal], [AL_LIBS="$ac_cv_search_alGenSources"]) +AC_SEARCH_LIBS([alGenSources], [openal openal32], [AL_LIBS="$ac_cv_search_alGenSources"]) test x"$AL_LIBS" = x"none required" && AL_LIBS= AC_SUBST([AL_LIBS]) @@ -27,42 +27,57 @@ AC_MSG_WARN([no OpenAL library found, so this package will not be built]) else -al_found_header=no -AC_CHECK_HEADERS([AL/alc.h OpenAL/alc.h], [al_found_header=yes; break]) -if test "$al_found_header" = no; then - AC_MSG_WARN([no OpenAL header found, so this package will not be built]) -else - -AL_BUILD_PACKAGE=yes - # Ugly... AL_FRAMEWORKS= -case $target_os in +case $host_os in darwin*) AL_FRAMEWORKS=OpenAL ;; esac AC_SUBST([AL_FRAMEWORKS]) +FP_HEADER_AL +FP_HEADER_ALC +if test -z "$AL_FRAMEWORKS" && test x"$fp_found_al_header$fp_found_alc_header" != xyesyes; then + AC_MSG_WARN([no OpenAL headers found, so this package will not be built]) +else + +AL_BUILD_PACKAGE=yes + AC_CHECK_HEADERS([AL/alext.h OpenAL/alext.h], [break]) -FPTOOLS_CHECK_HTYPE(ALboolean) -FPTOOLS_CHECK_HTYPE(ALbyte) -FPTOOLS_CHECK_HTYPE(ALubyte) -FPTOOLS_CHECK_HTYPE(ALshort) -FPTOOLS_CHECK_HTYPE(ALushort) -FPTOOLS_CHECK_HTYPE(ALint) -FPTOOLS_CHECK_HTYPE(ALuint) -FPTOOLS_CHECK_HTYPE(ALsizei) -FPTOOLS_CHECK_HTYPE(ALenum) -FPTOOLS_CHECK_HTYPE(ALbitfield) -FPTOOLS_CHECK_HTYPE(ALfloat) -FPTOOLS_CHECK_HTYPE(ALclampf) -FPTOOLS_CHECK_HTYPE(ALdouble) -FPTOOLS_CHECK_HTYPE(ALclampd) -FPTOOLS_CHECK_HTYPE(ALCenum) +FP_FUNC_ALCCLOSEDEVICE_VOID +FP_FUNC_ALCMAKECONTEXTCURRENT_VOID +FP_FUNC_ALCPROCESSCONTEXT_VOID +FP_FUNC_ALCDESTROYCONTEXT_VOID + +FPTOOLS_CHECK_HTYPE([ALboolean]) +FPTOOLS_CHECK_HTYPE([ALchar], [Int8]) +FPTOOLS_CHECK_HTYPE([ALbyte]) +FPTOOLS_CHECK_HTYPE([ALubyte]) +FPTOOLS_CHECK_HTYPE([ALshort]) +FPTOOLS_CHECK_HTYPE([ALushort]) +FPTOOLS_CHECK_HTYPE([ALint]) +FPTOOLS_CHECK_HTYPE([ALuint]) +FPTOOLS_CHECK_HTYPE([ALsizei]) +FPTOOLS_CHECK_HTYPE([ALenum]) +FPTOOLS_CHECK_HTYPE([ALfloat]) +FPTOOLS_CHECK_HTYPE([ALdouble]) + +FPTOOLS_CHECK_HTYPE([ALCboolean], [Int8]) +FPTOOLS_CHECK_HTYPE([ALCchar], [Int8]) +FPTOOLS_CHECK_HTYPE([ALCbyte], [Int8]) +FPTOOLS_CHECK_HTYPE([ALCubyte], [Word8]) +FPTOOLS_CHECK_HTYPE([ALCshort], [Int16]) +FPTOOLS_CHECK_HTYPE([ALCushort], [Word16]) +FPTOOLS_CHECK_HTYPE([ALCint], [Int32]) +FPTOOLS_CHECK_HTYPE([ALCuint], [Word32]) +FPTOOLS_CHECK_HTYPE([ALCsizei], [Int32]) +FPTOOLS_CHECK_HTYPE([ALCenum], [Int32]) +FPTOOLS_CHECK_HTYPE([ALCfloat], [Float]) +FPTOOLS_CHECK_HTYPE([ALCdouble], [Double]) -FP_CHECK_CONSTS([AL_FORMAT_VORBIS_EXT ALC_FREQUENCY ALC_REFRESH ALC_SYNC ALC_NO_ERROR ALC_INVALID_DEVICE ALC_INVALID_CONTEXT ALC_INVALID_ENUM ALC_INVALID_VALUE ALC_OUT_OF_MEMORY ALC_DEFAULT_DEVICE_SPECIFIER ALC_DEVICE_SPECIFIER ALC_EXTENSIONS ALC_MAJOR_VERSION ALC_MINOR_VERSION ALC_ATTRIBUTES_SIZE ALC_ALL_ATTRIBUTES], [#include +FP_CHECK_CONSTS([AL_FALSE AL_TRUE AL_NO_ERROR AL_INVALID_NAME AL_INVALID_ENUM AL_INVALID_VALUE AL_INVALID_OPERATION AL_OUT_OF_MEMORY AL_DOPPLER_FACTOR AL_SPEED_OF_SOUND AL_DISTANCE_MODEL AL_VERSION AL_RENDERER AL_VENDOR AL_EXTENSIONS AL_NONE AL_INVERSE_DISTANCE AL_INVERSE_DISTANCE_CLAMPED AL_LINEAR_DISTANCE AL_LINEAR_DISTANCE_CLAMPED AL_EXPONENT_DISTANCE AL_EXPONENT_DISTANCE_CLAMPED AL_POSITION AL_VELOCITY AL_GAIN AL_ORIENTATION AL_SOURCE_RELATIVE AL_SOURCE_TYPE AL_LOOPING AL_BUFFER AL_BUFFERS_QUEUED AL_BUFFERS_PROCESSED AL_MIN_GAIN AL_MAX_GAIN AL_REFERENCE_DISTANCE AL_ROLLOFF_FACTOR AL_MAX_DISTANCE AL_PITCH AL_DIRECTION AL_CONE_INNER_ANGLE AL_CONE_OUTER_ANGLE AL_CONE_OUTER_GAIN AL_SEC_OFFSET AL_SAMPLE_OFFSET AL_BYTE_OFFSET AL_SOURCE_STATE AL_UNDETERMINED AL_STATIC AL_STREAMING AL_INITIAL AL_PLAYING AL_PAUSED AL_STOPPED AL_FREQUENCY AL_SIZE AL_BITS AL_CHANNELS AL_FORMAT_MONO8 AL_FORMAT_MONO16 AL_FORMAT_STEREO8 AL_FORMAT_STEREO16 ALC_FALSE ALC_TRUE ALC_FREQUENCY ALC_REFRESH ALC_SYNC ALC_MONO_SOURCES ALC_STEREO_SOURCES ALC_NO_ERROR ALC_INVALID_DEVICE ALC_INVALID_CONTEXT ALC_INVALID_ENUM ALC_INVALID_VALUE ALC_INVALID_OPERATION ALC_OUT_OF_MEMORY ALC_DEFAULT_DEVICE_SPECIFIER ALC_DEVICE_SPECIFIER ALC_EXTENSIONS ALC_CAPTURE_DEFAULT_DEVICE_SPECIFIER ALC_CAPTURE_DEVICE_SPECIFIER ALC_ATTRIBUTES_SIZE ALC_ALL_ATTRIBUTES ALC_MAJOR_VERSION ALC_MINOR_VERSION ALC_CAPTURE_SAMPLES], [#include #if defined(HAVE_AL_ALC_H) #include #elif defined(HAVE_OPENAL_ALC_H) @@ -74,6 +89,87 @@ #elif defined(HAVE_OPENAL_ALEXT_H) #include #endif + +#ifndef AL_SPEED_OF_SOUND +#define AL_SPEED_OF_SOUND 0xC003 +#endif + +#ifndef AL_LINEAR_DISTANCE +#define AL_LINEAR_DISTANCE 0xD003 +#endif + +#ifndef AL_LINEAR_DISTANCE_CLAMPED +#define AL_LINEAR_DISTANCE_CLAMPED 0xD004 +#endif + +#ifndef AL_EXPONENT_DISTANCE +#define AL_EXPONENT_DISTANCE 0xD005 +#endif + +#ifndef AL_EXPONENT_DISTANCE_CLAMPED +#define AL_EXPONENT_DISTANCE_CLAMPED 0xD006 +#endif + +#ifndef AL_SEC_OFFSET +#define AL_SEC_OFFSET 0x1024 +#endif + +#ifndef AL_SAMPLE_OFFSET +#define AL_SAMPLE_OFFSET 0x1025 +#endif + +#ifndef AL_BYTE_OFFSET +#define AL_BYTE_OFFSET 0x1026 +#endif + +#ifndef AL_UNDETERMINED +#define AL_UNDETERMINED 0x1030 +#endif + +#ifndef AL_STATIC +#define AL_STATIC 0x1028 +#endif + +#ifndef ALC_MONO_SOURCES +#define ALC_MONO_SOURCES 0x1010 +#endif + +#ifndef ALC_STEREO_SOURCES +#define ALC_STEREO_SOURCES 0x1011 +#endif + +#ifndef AL_INVALID_ENUM +#ifdef AL_ILLEGAL_ENUM +#define AL_INVALID_ENUM AL_ILLEGAL_ENUM +#else +#define AL_INVALID_ENUM 0xA002 +#endif +#endif + +#ifndef AL_INVALID_OPERATION +#ifdef AL_ILLEGAL_COMMAND +#define AL_INVALID_OPERATION AL_ILLEGAL_COMMAND +#else +#define AL_INVALID_OPERATION 0xA004 +#endif +#endif + +/* NOTE: THIS IS NOT IN ANY HEADER */ +#ifndef ALC_INVALID_OPERATION +#define ALC_INVALID_OPERATION 0xA006 +#endif + +#ifndef ALC_CAPTURE_DEFAULT_DEVICE_SPECIFIER +#define ALC_CAPTURE_DEFAULT_DEVICE_SPECIFIER 0x311 +#endif + +#ifndef ALC_CAPTURE_DEVICE_SPECIFIER +#define ALC_CAPTURE_DEVICE_SPECIFIER 0x310 +#endif + +#ifndef ALC_CAPTURE_SAMPLES +#define ALC_CAPTURE_SAMPLES 0x312 +#endif ]) AC_DEFINE_UNQUOTED([AL_LIBS], @@ -95,7 +191,7 @@ fi AC_SUBST([BUILD_PACKAGE_BOOL]) -case "$target" in +case "$host" in *-mingw32) CALLCONV=stdcall ;; *) CALLCONV=ccall ;; esac diff -uNr --exclude=autom4te.cache --exclude=.cvsignore hugs98-Mar2005-patched/fptools/libraries/OpenAL/examples/test/TestDevice.hs ghc-6.4.2/libraries/OpenAL/examples/test/TestDevice.hs --- hugs98-Mar2005-patched/fptools/libraries/OpenAL/examples/test/TestDevice.hs 2004-04-05 23:15:54.000000000 +0900 +++ ghc-6.4.2/libraries/OpenAL/examples/test/TestDevice.hs 2006-03-22 00:58:04.000000000 +0900 @@ -1,8 +1,15 @@ -import Sound.OpenAL +import Control.Monad ( unless ) +import System.IO ( hPutStrLn, stderr ) import System.Posix.Unistd ( sleep ) +import Sound.OpenAL main :: IO () main = do - dev <- openDevice (Just "'( ( devices '( native null ) ) )") - sleep 1 - closeDevice dev + maybeDevice <- openDevice (Just "'( ( devices '( native null ) ) )") + case maybeDevice of + Nothing -> hPutStrLn stderr "openDevice failed" + Just device -> do + sleep 1 + ok <- closeDevice device + unless ok $ + hPutStrLn stderr "closeDevice failed" diff -uNr --exclude=autom4te.cache --exclude=.cvsignore hugs98-Mar2005-patched/fptools/libraries/OpenAL/include/HsOpenAL.h.in ghc-6.4.2/libraries/OpenAL/include/HsOpenAL.h.in --- hugs98-Mar2005-patched/fptools/libraries/OpenAL/include/HsOpenAL.h.in 2004-01-03 04:03:10.000000000 +0900 +++ ghc-6.4.2/libraries/OpenAL/include/HsOpenAL.h.in 2006-03-22 00:58:04.000000000 +0900 @@ -1,7 +1,7 @@ /* ----------------------------------------------------------------------------- * * Module : C support for Sound.OpenAL - * Copyright : (c) Sven Panne 2003-2004 + * Copyright : (c) Sven Panne 2003-2005 * License : BSD-style (see the file libraries/OpenAL/LICENSE) * * Maintainer : sven.panne@aedion.de @@ -22,11 +22,9 @@ #if defined(HAVE_AL_ALC_H) #include #include -#include #elif defined(HAVE_OPENAL_ALC_H) #include #include -#include #endif #endif diff -uNr --exclude=autom4te.cache --exclude=.cvsignore hugs98-Mar2005-patched/fptools/libraries/OpenAL/include/HsOpenALConfig.h.in ghc-6.4.2/libraries/OpenAL/include/HsOpenALConfig.h.in --- hugs98-Mar2005-patched/fptools/libraries/OpenAL/include/HsOpenALConfig.h.in 2005-03-12 08:13:22.000000000 +0900 +++ ghc-6.4.2/libraries/OpenAL/include/HsOpenALConfig.h.in 2006-04-19 04:36:53.000000000 +0900 @@ -1,5 +1,17 @@ /* include/HsOpenALConfig.h.in. Generated from configure.ac by autoheader. */ +/* Define to 1 if `alcCloseDevice' returns void. */ +#undef ALCCLOSEDEVICE_VOID + +/* Define to 1 if `alcDestroyContext' returns void. */ +#undef ALCDESTROYCONTEXT_VOID + +/* Define to 1 if `alcMakeContextCurrent' returns void. */ +#undef ALCMAKECONTEXTCURRENT_VOID + +/* Define to 1 if `alcProcessContext' returns void. */ +#undef ALCPROCESSCONTEXT_VOID + /* Framework flags for AL, as a list of string literals. */ #undef AL_FRAMEWORKS @@ -12,6 +24,15 @@ /* The value of ALC_ATTRIBUTES_SIZE. */ #undef CONST_ALC_ATTRIBUTES_SIZE +/* The value of ALC_CAPTURE_DEFAULT_DEVICE_SPECIFIER. */ +#undef CONST_ALC_CAPTURE_DEFAULT_DEVICE_SPECIFIER + +/* The value of ALC_CAPTURE_DEVICE_SPECIFIER. */ +#undef CONST_ALC_CAPTURE_DEVICE_SPECIFIER + +/* The value of ALC_CAPTURE_SAMPLES. */ +#undef CONST_ALC_CAPTURE_SAMPLES + /* The value of ALC_DEFAULT_DEVICE_SPECIFIER. */ #undef CONST_ALC_DEFAULT_DEVICE_SPECIFIER @@ -21,6 +42,9 @@ /* The value of ALC_EXTENSIONS. */ #undef CONST_ALC_EXTENSIONS +/* The value of ALC_FALSE. */ +#undef CONST_ALC_FALSE + /* The value of ALC_FREQUENCY. */ #undef CONST_ALC_FREQUENCY @@ -33,6 +57,9 @@ /* The value of ALC_INVALID_ENUM. */ #undef CONST_ALC_INVALID_ENUM +/* The value of ALC_INVALID_OPERATION. */ +#undef CONST_ALC_INVALID_OPERATION + /* The value of ALC_INVALID_VALUE. */ #undef CONST_ALC_INVALID_VALUE @@ -42,6 +69,9 @@ /* The value of ALC_MINOR_VERSION. */ #undef CONST_ALC_MINOR_VERSION +/* The value of ALC_MONO_SOURCES. */ +#undef CONST_ALC_MONO_SOURCES + /* The value of ALC_NO_ERROR. */ #undef CONST_ALC_NO_ERROR @@ -51,11 +81,197 @@ /* The value of ALC_REFRESH. */ #undef CONST_ALC_REFRESH +/* The value of ALC_STEREO_SOURCES. */ +#undef CONST_ALC_STEREO_SOURCES + /* The value of ALC_SYNC. */ #undef CONST_ALC_SYNC -/* The value of AL_FORMAT_VORBIS_EXT. */ -#undef CONST_AL_FORMAT_VORBIS_EXT +/* The value of ALC_TRUE. */ +#undef CONST_ALC_TRUE + +/* The value of AL_BITS. */ +#undef CONST_AL_BITS + +/* The value of AL_BUFFER. */ +#undef CONST_AL_BUFFER + +/* The value of AL_BUFFERS_PROCESSED. */ +#undef CONST_AL_BUFFERS_PROCESSED + +/* The value of AL_BUFFERS_QUEUED. */ +#undef CONST_AL_BUFFERS_QUEUED + +/* The value of AL_BYTE_OFFSET. */ +#undef CONST_AL_BYTE_OFFSET + +/* The value of AL_CHANNELS. */ +#undef CONST_AL_CHANNELS + +/* The value of AL_CONE_INNER_ANGLE. */ +#undef CONST_AL_CONE_INNER_ANGLE + +/* The value of AL_CONE_OUTER_ANGLE. */ +#undef CONST_AL_CONE_OUTER_ANGLE + +/* The value of AL_CONE_OUTER_GAIN. */ +#undef CONST_AL_CONE_OUTER_GAIN + +/* The value of AL_DIRECTION. */ +#undef CONST_AL_DIRECTION + +/* The value of AL_DISTANCE_MODEL. */ +#undef CONST_AL_DISTANCE_MODEL + +/* The value of AL_DOPPLER_FACTOR. */ +#undef CONST_AL_DOPPLER_FACTOR + +/* The value of AL_EXPONENT_DISTANCE. */ +#undef CONST_AL_EXPONENT_DISTANCE + +/* The value of AL_EXPONENT_DISTANCE_CLAMPED. */ +#undef CONST_AL_EXPONENT_DISTANCE_CLAMPED + +/* The value of AL_EXTENSIONS. */ +#undef CONST_AL_EXTENSIONS + +/* The value of AL_FALSE. */ +#undef CONST_AL_FALSE + +/* The value of AL_FORMAT_MONO16. */ +#undef CONST_AL_FORMAT_MONO16 + +/* The value of AL_FORMAT_MONO8. */ +#undef CONST_AL_FORMAT_MONO8 + +/* The value of AL_FORMAT_STEREO16. */ +#undef CONST_AL_FORMAT_STEREO16 + +/* The value of AL_FORMAT_STEREO8. */ +#undef CONST_AL_FORMAT_STEREO8 + +/* The value of AL_FREQUENCY. */ +#undef CONST_AL_FREQUENCY + +/* The value of AL_GAIN. */ +#undef CONST_AL_GAIN + +/* The value of AL_INITIAL. */ +#undef CONST_AL_INITIAL + +/* The value of AL_INVALID_ENUM. */ +#undef CONST_AL_INVALID_ENUM + +/* The value of AL_INVALID_NAME. */ +#undef CONST_AL_INVALID_NAME + +/* The value of AL_INVALID_OPERATION. */ +#undef CONST_AL_INVALID_OPERATION + +/* The value of AL_INVALID_VALUE. */ +#undef CONST_AL_INVALID_VALUE + +/* The value of AL_INVERSE_DISTANCE. */ +#undef CONST_AL_INVERSE_DISTANCE + +/* The value of AL_INVERSE_DISTANCE_CLAMPED. */ +#undef CONST_AL_INVERSE_DISTANCE_CLAMPED + +/* The value of AL_LINEAR_DISTANCE. */ +#undef CONST_AL_LINEAR_DISTANCE + +/* The value of AL_LINEAR_DISTANCE_CLAMPED. */ +#undef CONST_AL_LINEAR_DISTANCE_CLAMPED + +/* The value of AL_LOOPING. */ +#undef CONST_AL_LOOPING + +/* The value of AL_MAX_DISTANCE. */ +#undef CONST_AL_MAX_DISTANCE + +/* The value of AL_MAX_GAIN. */ +#undef CONST_AL_MAX_GAIN + +/* The value of AL_MIN_GAIN. */ +#undef CONST_AL_MIN_GAIN + +/* The value of AL_NONE. */ +#undef CONST_AL_NONE + +/* The value of AL_NO_ERROR. */ +#undef CONST_AL_NO_ERROR + +/* The value of AL_ORIENTATION. */ +#undef CONST_AL_ORIENTATION + +/* The value of AL_OUT_OF_MEMORY. */ +#undef CONST_AL_OUT_OF_MEMORY + +/* The value of AL_PAUSED. */ +#undef CONST_AL_PAUSED + +/* The value of AL_PITCH. */ +#undef CONST_AL_PITCH + +/* The value of AL_PLAYING. */ +#undef CONST_AL_PLAYING + +/* The value of AL_POSITION. */ +#undef CONST_AL_POSITION + +/* The value of AL_REFERENCE_DISTANCE. */ +#undef CONST_AL_REFERENCE_DISTANCE + +/* The value of AL_RENDERER. */ +#undef CONST_AL_RENDERER + +/* The value of AL_ROLLOFF_FACTOR. */ +#undef CONST_AL_ROLLOFF_FACTOR + +/* The value of AL_SAMPLE_OFFSET. */ +#undef CONST_AL_SAMPLE_OFFSET + +/* The value of AL_SEC_OFFSET. */ +#undef CONST_AL_SEC_OFFSET + +/* The value of AL_SIZE. */ +#undef CONST_AL_SIZE + +/* The value of AL_SOURCE_RELATIVE. */ +#undef CONST_AL_SOURCE_RELATIVE + +/* The value of AL_SOURCE_STATE. */ +#undef CONST_AL_SOURCE_STATE + +/* The value of AL_SOURCE_TYPE. */ +#undef CONST_AL_SOURCE_TYPE + +/* The value of AL_SPEED_OF_SOUND. */ +#undef CONST_AL_SPEED_OF_SOUND + +/* The value of AL_STATIC. */ +#undef CONST_AL_STATIC + +/* The value of AL_STOPPED. */ +#undef CONST_AL_STOPPED + +/* The value of AL_STREAMING. */ +#undef CONST_AL_STREAMING + +/* The value of AL_TRUE. */ +#undef CONST_AL_TRUE + +/* The value of AL_UNDETERMINED. */ +#undef CONST_AL_UNDETERMINED + +/* The value of AL_VELOCITY. */ +#undef CONST_AL_VELOCITY + +/* The value of AL_VENDOR. */ +#undef CONST_AL_VENDOR + +/* The value of AL_VERSION. */ +#undef CONST_AL_VERSION /* Define to 1 if you have the header file. */ #undef HAVE_AL_ALC_H @@ -63,6 +279,9 @@ /* Define to 1 if you have the header file. */ #undef HAVE_AL_ALEXT_H +/* Define to 1 if you have the header file. */ +#undef HAVE_AL_AL_H + /* Define to 1 if you have the header file. */ #undef HAVE_INTTYPES_H @@ -75,6 +294,9 @@ /* Define to 1 if you have the header file. */ #undef HAVE_OPENAL_ALEXT_H +/* Define to 1 if you have the header file. */ +#undef HAVE_OPENAL_AL_H + /* Define to 1 if you have the header file. */ #undef HAVE_STDINT_H @@ -96,23 +318,50 @@ /* Define to 1 if you have the header file. */ #undef HAVE_UNISTD_H -/* Define to Haskell type for ALbitfield */ -#undef HTYPE_ALBITFIELD - /* Define to Haskell type for ALboolean */ #undef HTYPE_ALBOOLEAN /* Define to Haskell type for ALbyte */ #undef HTYPE_ALBYTE +/* Define to Haskell type for ALCboolean */ +#undef HTYPE_ALCBOOLEAN + +/* Define to Haskell type for ALCbyte */ +#undef HTYPE_ALCBYTE + +/* Define to Haskell type for ALCchar */ +#undef HTYPE_ALCCHAR + +/* Define to Haskell type for ALCdouble */ +#undef HTYPE_ALCDOUBLE + /* Define to Haskell type for ALCenum */ #undef HTYPE_ALCENUM -/* Define to Haskell type for ALclampd */ -#undef HTYPE_ALCLAMPD +/* Define to Haskell type for ALCfloat */ +#undef HTYPE_ALCFLOAT + +/* Define to Haskell type for ALchar */ +#undef HTYPE_ALCHAR + +/* Define to Haskell type for ALCint */ +#undef HTYPE_ALCINT + +/* Define to Haskell type for ALCshort */ +#undef HTYPE_ALCSHORT + +/* Define to Haskell type for ALCsizei */ +#undef HTYPE_ALCSIZEI + +/* Define to Haskell type for ALCubyte */ +#undef HTYPE_ALCUBYTE + +/* Define to Haskell type for ALCuint */ +#undef HTYPE_ALCUINT -/* Define to Haskell type for ALclampf */ -#undef HTYPE_ALCLAMPF +/* Define to Haskell type for ALCushort */ +#undef HTYPE_ALCUSHORT /* Define to Haskell type for ALdouble */ #undef HTYPE_ALDOUBLE diff -uNr --exclude=autom4te.cache --exclude=.cvsignore hugs98-Mar2005-patched/fptools/libraries/OpenAL/package.conf.in ghc-6.4.2/libraries/OpenAL/package.conf.in --- hugs98-Mar2005-patched/fptools/libraries/OpenAL/package.conf.in 2005-02-19 00:06:43.000000000 +0900 +++ ghc-6.4.2/libraries/OpenAL/package.conf.in 2006-03-22 00:58:03.000000000 +0900 @@ -9,27 +9,36 @@ exposed-modules: Sound.OpenAL, Sound.OpenAL.AL, + Sound.OpenAL.AL.ALboolean, + Sound.OpenAL.AL.Attenuation, Sound.OpenAL.AL.BasicTypes, Sound.OpenAL.AL.Buffer, + Sound.OpenAL.AL.BufferInternal, + Sound.OpenAL.AL.Doppler, + Sound.OpenAL.AL.Errors, + Sound.OpenAL.AL.Extensions, + Sound.OpenAL.AL.Format, Sound.OpenAL.AL.Listener, Sound.OpenAL.AL.Source, + Sound.OpenAL.AL.StringQueries, Sound.OpenAL.ALC, + Sound.OpenAL.ALC.BasicTypes, + Sound.OpenAL.ALC.Capture, Sound.OpenAL.ALC.Context, Sound.OpenAL.ALC.Device, Sound.OpenAL.ALC.Errors, - Sound.OpenAL.ALC.Extensions, - Sound.OpenAL.ALUT, - Sound.OpenAL.ALUT.Initialization, - Sound.OpenAL.ALUT.WAV + Sound.OpenAL.ALC.Extensions hidden-modules: - Sound.OpenAL.AL.ALboolean, - Sound.OpenAL.AL.Format, Sound.OpenAL.AL.PeekPoke, Sound.OpenAL.AL.QueryUtils, - Sound.OpenAL.ALC.BasicTypes, - Sound.OpenAL.ALC.Queries, - Sound.OpenAL.ALUT.Exception + Sound.OpenAL.AL.SourceState, + Sound.OpenAL.AL.String, + Sound.OpenAL.ALC.ALCboolean, + Sound.OpenAL.ALC.QueryUtils, + Sound.OpenAL.ALC.String, + Sound.OpenAL.Config, + Sound.OpenAL.Constants import-dirs: IMPORT_DIR