rpms
/
hugs98
2
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
hugs98/openal-1.0_1.2.patch

9430 lines
328 KiB
Diff
Raw Blame History

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 <sven.panne@aedion.de>
@@ -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 @\"/\<spec major number\>/./\<spec
+-- minor number\>/ /\<optional vendor version information\>/\"@.
+
+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
+-- <http://www.openal.org/titles.html>).
+
+--------------------------------------------------------------------------------
+-- $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 <http://www.opengl.org/> 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
+-- <http://www.iasig.org/wg/closed/3dwg/3dwg.shtml>.
+--
+-- 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 <http://www.openal.org/documentation.html>)
+-- 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(<<AC_TYPE_NAME>>, translit(htype_$1, [a-z *], [A-Z_P]))dnl
@@ -59,6 +59,12 @@
# include <OpenGL/gl.h>
#endif
+#if defined(HAVE_AL_AL_H)
+# include <AL/al.h>
+#elif defined(HAVE_OPENAL_AL_H)
+# include <OpenAL/al.h>
+#endif
+
#if defined(HAVE_AL_ALC_H)
# include <AL/alc.h>
#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 <AL/alc.h>
+#elif defined(HAVE_OPENAL_ALC_H)
+#include <OpenAL/alc.h>
+#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 <AL/alc.h>
+#elif defined(HAVE_OPENAL_ALC_H)
+#include <OpenAL/alc.h>
+#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 <AL/alc.h>
+#elif defined(HAVE_OPENAL_ALC_H)
+#include <OpenAL/alc.h>
+#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 <AL/alc.h>
+#elif defined(HAVE_OPENAL_ALC_H)
+#include <OpenAL/alc.h>
+#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 <sven.panne@aedion.de>.
#
@@ -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 <unistd.h>
#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 <stdio.h>
-#include <stddef.h>
-
-#if HAVE_SYS_TYPES_H
-# include <sys/types.h>
-#endif
-
-#if HAVE_UNISTD_H
-# include <unistd.h>
-#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 <sys/stat.h>
-#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 <fcntl.h>
-#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 <signal.h>
-#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 <time.h>
-#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 <termios.h>
-#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 <string.h>
-#endif
+done
-#if HAVE_CTYPE_H
-# include <ctype.h>
-#endif
-#if defined(HAVE_GL_GL_H)
-# include <GL/gl.h>
-#elif defined(HAVE_OPENGL_GL_H)
-# include <OpenGL/gl.h>
-#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 <AL/alc.h>
+#include <AL/alc.h>
#elif defined(HAVE_OPENAL_ALC_H)
-# include <OpenAL/alc.h>
-#endif
-
-#if HAVE_SYS_RESOURCE_H
-# include <sys/resource.h>
+#include <OpenAL/alc.h>
#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 <AL/alc.h>
+#elif defined(HAVE_OPENAL_ALC_H)
+#include <OpenAL/alc.h>
+#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 <AL/alc.h>
+#elif defined(HAVE_OPENAL_ALC_H)
+#include <OpenAL/alc.h>
+#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 <AL/alc.h>
+#elif defined(HAVE_OPENAL_ALC_H)
+#include <OpenAL/alc.h>
+#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 <stdio.h>
+#include <stddef.h>
+
+#if HAVE_SYS_TYPES_H
+# include <sys/types.h>
+#endif
+
+#if HAVE_UNISTD_H
+# include <unistd.h>
+#endif
+
+#if HAVE_SYS_STAT_H
+# include <sys/stat.h>
+#endif
+
+#if HAVE_FCNTL_H
+# include <fcntl.h>
+#endif
+
+#if HAVE_SIGNAL_H
+# include <signal.h>
+#endif
+
+#if HAVE_TIME_H
+# include <time.h>
+#endif
+
+#if HAVE_TERMIOS_H
+# include <termios.h>
+#endif
+
+#if HAVE_STRING_H
+# include <string.h>
+#endif
+
+#if HAVE_CTYPE_H
+# include <ctype.h>
+#endif
+
+#if defined(HAVE_GL_GL_H)
+# include <GL/gl.h>
+#elif defined(HAVE_OPENGL_GL_H)
+# include <OpenGL/gl.h>
+#endif
+
+#if defined(HAVE_AL_AL_H)
+# include <AL/al.h>
+#elif defined(HAVE_OPENAL_AL_H)
+# include <OpenAL/al.h>
+#endif
+
+#if defined(HAVE_AL_ALC_H)
+# include <AL/alc.h>
+#elif defined(HAVE_OPENAL_ALC_H)
+# include <OpenAL/alc.h>
+#endif
+
+#if HAVE_SYS_RESOURCE_H
+# include <sys/resource.h>
+#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 <stdio.h>
+#include <stddef.h>
+
+#if HAVE_SYS_TYPES_H
+# include <sys/types.h>
+#endif
+
+#if HAVE_UNISTD_H
+# include <unistd.h>
+#endif
+
+#if HAVE_SYS_STAT_H
+# include <sys/stat.h>
+#endif
+
+#if HAVE_FCNTL_H
+# include <fcntl.h>
+#endif
+
+#if HAVE_SIGNAL_H
+# include <signal.h>
+#endif
+
+#if HAVE_TIME_H
+# include <time.h>
+#endif
+
+#if HAVE_TERMIOS_H
+# include <termios.h>
+#endif
+
+#if HAVE_STRING_H
+# include <string.h>
+#endif
+
+#if HAVE_CTYPE_H
+# include <ctype.h>
+#endif
+
+#if defined(HAVE_GL_GL_H)
+# include <GL/gl.h>
+#elif defined(HAVE_OPENGL_GL_H)
+# include <OpenGL/gl.h>
+#endif
+
+#if defined(HAVE_AL_AL_H)
+# include <AL/al.h>
+#elif defined(HAVE_OPENAL_AL_H)
+# include <OpenAL/al.h>
+#endif
+
+#if defined(HAVE_AL_ALC_H)
+# include <AL/alc.h>
+#elif defined(HAVE_OPENAL_ALC_H)
+# include <OpenAL/alc.h>
+#endif
+
+#if HAVE_SYS_RESOURCE_H
+# include <sys/resource.h>
+#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 <stdio.h>
+#include <stddef.h>
+
+#if HAVE_SYS_TYPES_H
+# include <sys/types.h>
+#endif
+
+#if HAVE_UNISTD_H
+# include <unistd.h>
+#endif
+
+#if HAVE_SYS_STAT_H
+# include <sys/stat.h>
+#endif
+
+#if HAVE_FCNTL_H
+# include <fcntl.h>
+#endif
+
+#if HAVE_SIGNAL_H
+# include <signal.h>
+#endif
+
+#if HAVE_TIME_H
+# include <time.h>
+#endif
+
+#if HAVE_TERMIOS_H
+# include <termios.h>
+#endif
+
+#if HAVE_STRING_H
+# include <string.h>
+#endif
+
+#if HAVE_CTYPE_H
+# include <ctype.h>
+#endif
+
+#if defined(HAVE_GL_GL_H)
+# include <GL/gl.h>
+#elif defined(HAVE_OPENGL_GL_H)
+# include <OpenGL/gl.h>
+#endif
+
+#if defined(HAVE_AL_AL_H)
+# include <AL/al.h>
+#elif defined(HAVE_OPENAL_AL_H)
+# include <OpenAL/al.h>
+#endif
+
+#if defined(HAVE_AL_ALC_H)
+# include <AL/alc.h>
+#elif defined(HAVE_OPENAL_ALC_H)
+# include <OpenAL/alc.h>
+#endif
+
+#if HAVE_SYS_RESOURCE_H
+# include <sys/resource.h>
+#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 <stdio.h>
+#include <stddef.h>
+
+#if HAVE_SYS_TYPES_H
+# include <sys/types.h>
+#endif
+
+#if HAVE_UNISTD_H
+# include <unistd.h>
+#endif
+
+#if HAVE_SYS_STAT_H
+# include <sys/stat.h>
+#endif
+
+#if HAVE_FCNTL_H
+# include <fcntl.h>
+#endif
+
+#if HAVE_SIGNAL_H
+# include <signal.h>
+#endif
+
+#if HAVE_TIME_H
+# include <time.h>
+#endif
+
+#if HAVE_TERMIOS_H
+# include <termios.h>
+#endif
+
+#if HAVE_STRING_H
+# include <string.h>
+#endif
+
+#if HAVE_CTYPE_H
+# include <ctype.h>
+#endif
+
+#if defined(HAVE_GL_GL_H)
+# include <GL/gl.h>
+#elif defined(HAVE_OPENGL_GL_H)
+# include <OpenGL/gl.h>
+#endif
+
+#if defined(HAVE_AL_AL_H)
+# include <AL/al.h>
+#elif defined(HAVE_OPENAL_AL_H)
+# include <OpenAL/al.h>
+#endif
+
+#if defined(HAVE_AL_ALC_H)
+# include <AL/alc.h>
+#elif defined(HAVE_OPENAL_ALC_H)
+# include <OpenAL/alc.h>
+#endif
+
+#if HAVE_SYS_RESOURCE_H
+# include <sys/resource.h>
+#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 <stdio.h>
+#include <stddef.h>
+
+#if HAVE_SYS_TYPES_H
+# include <sys/types.h>
+#endif
+
+#if HAVE_UNISTD_H
+# include <unistd.h>
+#endif
+
+#if HAVE_SYS_STAT_H
+# include <sys/stat.h>
+#endif
+
+#if HAVE_FCNTL_H
+# include <fcntl.h>
+#endif
+
+#if HAVE_SIGNAL_H
+# include <signal.h>
+#endif
+
+#if HAVE_TIME_H
+# include <time.h>
+#endif
+
+#if HAVE_TERMIOS_H
+# include <termios.h>
+#endif
+
+#if HAVE_STRING_H
+# include <string.h>
+#endif
+
+#if HAVE_CTYPE_H
+# include <ctype.h>
+#endif
+
+#if defined(HAVE_GL_GL_H)
+# include <GL/gl.h>
+#elif defined(HAVE_OPENGL_GL_H)
+# include <OpenGL/gl.h>
+#endif
+
+#if defined(HAVE_AL_AL_H)
+# include <AL/al.h>
+#elif defined(HAVE_OPENAL_AL_H)
+# include <OpenAL/al.h>
+#endif
+
+#if defined(HAVE_AL_ALC_H)
+# include <AL/alc.h>
+#elif defined(HAVE_OPENAL_ALC_H)
+# include <OpenAL/alc.h>
+#endif
+
+#if HAVE_SYS_RESOURCE_H
+# include <sys/resource.h>
+#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 <stdio.h>
+#include <stddef.h>
+
+#if HAVE_SYS_TYPES_H
+# include <sys/types.h>
+#endif
+
+#if HAVE_UNISTD_H
+# include <unistd.h>
+#endif
+
+#if HAVE_SYS_STAT_H
+# include <sys/stat.h>
+#endif
+
+#if HAVE_FCNTL_H
+# include <fcntl.h>
+#endif
+
+#if HAVE_SIGNAL_H
+# include <signal.h>
+#endif
+
+#if HAVE_TIME_H
+# include <time.h>
+#endif
+
+#if HAVE_TERMIOS_H
+# include <termios.h>
+#endif
+
+#if HAVE_STRING_H
+# include <string.h>
+#endif
+
+#if HAVE_CTYPE_H
+# include <ctype.h>
+#endif
+
+#if defined(HAVE_GL_GL_H)
+# include <GL/gl.h>
+#elif defined(HAVE_OPENGL_GL_H)
+# include <OpenGL/gl.h>
+#endif
+
+#if defined(HAVE_AL_AL_H)
+# include <AL/al.h>
+#elif defined(HAVE_OPENAL_AL_H)
+# include <OpenAL/al.h>
+#endif
+
+#if defined(HAVE_AL_ALC_H)
+# include <AL/alc.h>
+#elif defined(HAVE_OPENAL_ALC_H)
+# include <OpenAL/alc.h>
+#endif
+
+#if HAVE_SYS_RESOURCE_H
+# include <sys/resource.h>
+#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 <stdio.h>
+#include <stddef.h>
+
+#if HAVE_SYS_TYPES_H
+# include <sys/types.h>
+#endif
+
+#if HAVE_UNISTD_H
+# include <unistd.h>
+#endif
+
+#if HAVE_SYS_STAT_H
+# include <sys/stat.h>
+#endif
+
+#if HAVE_FCNTL_H
+# include <fcntl.h>
+#endif
+
+#if HAVE_SIGNAL_H
+# include <signal.h>
+#endif
+
+#if HAVE_TIME_H
+# include <time.h>
+#endif
+
+#if HAVE_TERMIOS_H
+# include <termios.h>
+#endif
+
+#if HAVE_STRING_H
+# include <string.h>
+#endif
+
+#if HAVE_CTYPE_H
+# include <ctype.h>
+#endif
+
+#if defined(HAVE_GL_GL_H)
+# include <GL/gl.h>
+#elif defined(HAVE_OPENGL_GL_H)
+# include <OpenGL/gl.h>
+#endif
+
+#if defined(HAVE_AL_AL_H)
+# include <AL/al.h>
+#elif defined(HAVE_OPENAL_AL_H)
+# include <OpenAL/al.h>
+#endif
+
+#if defined(HAVE_AL_ALC_H)
+# include <AL/alc.h>
+#elif defined(HAVE_OPENAL_ALC_H)
+# include <OpenAL/alc.h>
+#endif
+
+#if HAVE_SYS_RESOURCE_H
+# include <sys/resource.h>
+#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 <stdio.h>
+#include <stddef.h>
+
+#if HAVE_SYS_TYPES_H
+# include <sys/types.h>
+#endif
+
+#if HAVE_UNISTD_H
+# include <unistd.h>
+#endif
+
+#if HAVE_SYS_STAT_H
+# include <sys/stat.h>
+#endif
+
+#if HAVE_FCNTL_H
+# include <fcntl.h>
+#endif
+
+#if HAVE_SIGNAL_H
+# include <signal.h>
+#endif
+
+#if HAVE_TIME_H
+# include <time.h>
+#endif
+
+#if HAVE_TERMIOS_H
+# include <termios.h>
+#endif
+
+#if HAVE_STRING_H
+# include <string.h>
+#endif
+
+#if HAVE_CTYPE_H
+# include <ctype.h>
+#endif
+
+#if defined(HAVE_GL_GL_H)
+# include <GL/gl.h>
+#elif defined(HAVE_OPENGL_GL_H)
+# include <OpenGL/gl.h>
+#endif
+
+#if defined(HAVE_AL_AL_H)
+# include <AL/al.h>
+#elif defined(HAVE_OPENAL_AL_H)
+# include <OpenAL/al.h>
+#endif
+
+#if defined(HAVE_AL_ALC_H)
+# include <AL/alc.h>
+#elif defined(HAVE_OPENAL_ALC_H)
+# include <OpenAL/alc.h>
+#endif
+
+#if HAVE_SYS_RESOURCE_H
+# include <sys/resource.h>
+#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 <stdio.h>
+#include <stddef.h>
+
+#if HAVE_SYS_TYPES_H
+# include <sys/types.h>
+#endif
+
+#if HAVE_UNISTD_H
+# include <unistd.h>
+#endif
+
+#if HAVE_SYS_STAT_H
+# include <sys/stat.h>
+#endif
+
+#if HAVE_FCNTL_H
+# include <fcntl.h>
+#endif
+
+#if HAVE_SIGNAL_H
+# include <signal.h>
+#endif
+
+#if HAVE_TIME_H
+# include <time.h>
+#endif
+
+#if HAVE_TERMIOS_H
+# include <termios.h>
+#endif
+
+#if HAVE_STRING_H
+# include <string.h>
+#endif
+
+#if HAVE_CTYPE_H
+# include <ctype.h>
+#endif
+
+#if defined(HAVE_GL_GL_H)
+# include <GL/gl.h>
+#elif defined(HAVE_OPENGL_GL_H)
+# include <OpenGL/gl.h>
+#endif
+
+#if defined(HAVE_AL_AL_H)
+# include <AL/al.h>
+#elif defined(HAVE_OPENAL_AL_H)
+# include <OpenAL/al.h>
+#endif
+
+#if defined(HAVE_AL_ALC_H)
+# include <AL/alc.h>
+#elif defined(HAVE_OPENAL_ALC_H)
+# include <OpenAL/alc.h>
+#endif
+
+#if HAVE_SYS_RESOURCE_H
+# include <sys/resource.h>
+#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 <stdio.h>
+#include <stddef.h>
+
+#if HAVE_SYS_TYPES_H
+# include <sys/types.h>
+#endif
+
+#if HAVE_UNISTD_H
+# include <unistd.h>
+#endif
+
+#if HAVE_SYS_STAT_H
+# include <sys/stat.h>
+#endif
+
+#if HAVE_FCNTL_H
+# include <fcntl.h>
+#endif
+
+#if HAVE_SIGNAL_H
+# include <signal.h>
+#endif
+
+#if HAVE_TIME_H
+# include <time.h>
+#endif
+
+#if HAVE_TERMIOS_H
+# include <termios.h>
+#endif
+
+#if HAVE_STRING_H
+# include <string.h>
+#endif
+
+#if HAVE_CTYPE_H
+# include <ctype.h>
+#endif
+
+#if defined(HAVE_GL_GL_H)
+# include <GL/gl.h>
+#elif defined(HAVE_OPENGL_GL_H)
+# include <OpenGL/gl.h>
+#endif
+
+#if defined(HAVE_AL_AL_H)
+# include <AL/al.h>
+#elif defined(HAVE_OPENAL_AL_H)
+# include <OpenAL/al.h>
+#endif
+
+#if defined(HAVE_AL_ALC_H)
+# include <AL/alc.h>
+#elif defined(HAVE_OPENAL_ALC_H)
+# include <OpenAL/alc.h>
+#endif
+
+#if HAVE_SYS_RESOURCE_H
+# include <sys/resource.h>
+#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 <OpenGL/gl.h>
#endif
+#if defined(HAVE_AL_AL_H)
+# include <AL/al.h>
+#elif defined(HAVE_OPENAL_AL_H)
+# include <OpenAL/al.h>
+#endif
+
#if defined(HAVE_AL_ALC_H)
# include <AL/alc.h>
#elif defined(HAVE_OPENAL_ALC_H)
@@ -3261,7 +4866,7 @@
# include <sys/resource.h>
#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 <OpenGL/gl.h>
#endif
+#if defined(HAVE_AL_AL_H)
+# include <AL/al.h>
+#elif defined(HAVE_OPENAL_AL_H)
+# include <OpenAL/al.h>
+#endif
+
#if defined(HAVE_AL_ALC_H)
# include <AL/alc.h>
#elif defined(HAVE_OPENAL_ALC_H)
@@ -3389,7 +5000,7 @@
# include <sys/resource.h>
#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 <OpenGL/gl.h>
#endif
+#if defined(HAVE_AL_AL_H)
+# include <AL/al.h>
+#elif defined(HAVE_OPENAL_AL_H)
+# include <OpenAL/al.h>
+#endif
+
#if defined(HAVE_AL_ALC_H)
# include <AL/alc.h>
#elif defined(HAVE_OPENAL_ALC_H)
@@ -3517,7 +5135,7 @@
# include <sys/resource.h>
#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 <OpenGL/gl.h>
#endif
+#if defined(HAVE_AL_AL_H)
+# include <AL/al.h>
+#elif defined(HAVE_OPENAL_AL_H)
+# include <OpenAL/al.h>
+#endif
+
#if defined(HAVE_AL_ALC_H)
# include <AL/alc.h>
#elif defined(HAVE_OPENAL_ALC_H)
@@ -3645,7 +5269,7 @@
# include <sys/resource.h>
#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 <OpenGL/gl.h>
#endif
+#if defined(HAVE_AL_AL_H)
+# include <AL/al.h>
+#elif defined(HAVE_OPENAL_AL_H)
+# include <OpenAL/al.h>
+#endif
+
#if defined(HAVE_AL_ALC_H)
# include <AL/alc.h>
#elif defined(HAVE_OPENAL_ALC_H)
@@ -3773,7 +5403,7 @@
# include <sys/resource.h>
#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 <OpenGL/gl.h>
#endif
+#if defined(HAVE_AL_AL_H)
+# include <AL/al.h>
+#elif defined(HAVE_OPENAL_AL_H)
+# include <OpenAL/al.h>
+#endif
+
#if defined(HAVE_AL_ALC_H)
# include <AL/alc.h>
#elif defined(HAVE_OPENAL_ALC_H)
@@ -3901,7 +5537,7 @@
# include <sys/resource.h>
#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 <OpenGL/gl.h>
#endif
+#if defined(HAVE_AL_AL_H)
+# include <AL/al.h>
+#elif defined(HAVE_OPENAL_AL_H)
+# include <OpenAL/al.h>
+#endif
+
#if defined(HAVE_AL_ALC_H)
# include <AL/alc.h>
#elif defined(HAVE_OPENAL_ALC_H)
@@ -4029,7 +5671,7 @@
# include <sys/resource.h>
#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 <OpenGL/gl.h>
#endif
+#if defined(HAVE_AL_AL_H)
+# include <AL/al.h>
+#elif defined(HAVE_OPENAL_AL_H)
+# include <OpenAL/al.h>
+#endif
+
#if defined(HAVE_AL_ALC_H)
# include <AL/alc.h>
#elif defined(HAVE_OPENAL_ALC_H)
@@ -4157,7 +5805,7 @@
# include <sys/resource.h>
#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 <OpenGL/gl.h>
#endif
+#if defined(HAVE_AL_AL_H)
+# include <AL/al.h>
+#elif defined(HAVE_OPENAL_AL_H)
+# include <OpenAL/al.h>
+#endif
+
#if defined(HAVE_AL_ALC_H)
# include <AL/alc.h>
#elif defined(HAVE_OPENAL_ALC_H)
@@ -4285,7 +5939,7 @@
# include <sys/resource.h>
#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 <OpenGL/gl.h>
#endif
+#if defined(HAVE_AL_AL_H)
+# include <AL/al.h>
+#elif defined(HAVE_OPENAL_AL_H)
+# include <OpenAL/al.h>
+#endif
+
#if defined(HAVE_AL_ALC_H)
# include <AL/alc.h>
#elif defined(HAVE_OPENAL_ALC_H)
@@ -4413,7 +6073,7 @@
# include <sys/resource.h>
#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 <OpenGL/gl.h>
#endif
+#if defined(HAVE_AL_AL_H)
+# include <AL/al.h>
+#elif defined(HAVE_OPENAL_AL_H)
+# include <OpenAL/al.h>
+#endif
+
#if defined(HAVE_AL_ALC_H)
# include <AL/alc.h>
#elif defined(HAVE_OPENAL_ALC_H)
@@ -4541,7 +6207,7 @@
# include <sys/resource.h>
#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 <OpenGL/gl.h>
#endif
+#if defined(HAVE_AL_AL_H)
+# include <AL/al.h>
+#elif defined(HAVE_OPENAL_AL_H)
+# include <OpenAL/al.h>
+#endif
+
#if defined(HAVE_AL_ALC_H)
# include <AL/alc.h>
#elif defined(HAVE_OPENAL_ALC_H)
@@ -4669,7 +6341,7 @@
# include <sys/resource.h>
#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 <OpenGL/gl.h>
#endif
+#if defined(HAVE_AL_AL_H)
+# include <AL/al.h>
+#elif defined(HAVE_OPENAL_AL_H)
+# include <OpenAL/al.h>
+#endif
+
#if defined(HAVE_AL_ALC_H)
# include <AL/alc.h>
#elif defined(HAVE_OPENAL_ALC_H)
@@ -4797,7 +6475,7 @@
# include <sys/resource.h>
#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 <OpenGL/gl.h>
#endif
+#if defined(HAVE_AL_AL_H)
+# include <AL/al.h>
+#elif defined(HAVE_OPENAL_AL_H)
+# include <OpenAL/al.h>
+#endif
+
#if defined(HAVE_AL_ALC_H)
# include <AL/alc.h>
#elif defined(HAVE_OPENAL_ALC_H)
@@ -4925,7 +6609,7 @@
# include <sys/resource.h>
#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 <OpenAL/alext.h>
#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 <OpenAL/alext.h>
#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 <OpenAL/alext.h>
#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 <OpenAL/alext.h>
#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 <OpenAL/alext.h>
#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 <OpenAL/alext.h>
#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 <stdio.h>
+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 <stdio.h>
#if defined(HAVE_AL_ALC_H)
#include <AL/alc.h>
#elif defined(HAVE_OPENAL_ALC_H)
@@ -74,6 +89,87 @@
#elif defined(HAVE_OPENAL_ALEXT_H)
#include <OpenAL/alext.h>
#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 <AL/al.h>
#include <AL/alc.h>
-#include <AL/alut.h>
#elif defined(HAVE_OPENAL_ALC_H)
#include <OpenAL/al.h>
#include <OpenAL/alc.h>
-#include <OpenAL/alut.h>
#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 <AL/alc.h> header file. */
#undef HAVE_AL_ALC_H
@@ -63,6 +279,9 @@
/* Define to 1 if you have the <AL/alext.h> header file. */
#undef HAVE_AL_ALEXT_H
+/* Define to 1 if you have the <AL/al.h> header file. */
+#undef HAVE_AL_AL_H
+
/* Define to 1 if you have the <inttypes.h> header file. */
#undef HAVE_INTTYPES_H
@@ -75,6 +294,9 @@
/* Define to 1 if you have the <OpenAL/alext.h> header file. */
#undef HAVE_OPENAL_ALEXT_H
+/* Define to 1 if you have the <OpenAL/al.h> header file. */
+#undef HAVE_OPENAL_AL_H
+
/* Define to 1 if you have the <stdint.h> header file. */
#undef HAVE_STDINT_H
@@ -96,23 +318,50 @@
/* Define to 1 if you have the <unistd.h> 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
Reference in New Issue View Git Blame Copy Permalink