diff --git a/openal-1.0_1.2.patch b/openal-1.0_1.2.patch deleted file mode 100644 index 5d7aeea..0000000 --- a/openal-1.0_1.2.patch +++ /dev/null @@ -1,9429 +0,0 @@ -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 -