From 1d7b1314571dfcedbc65545c2077a0cd8636b91f Mon Sep 17 00:00:00 2001 From: Gérard Milmeister Date: Apr 24 2006 11:08:51 +0000 Subject: added openal support --- diff --git a/hugs98.spec b/hugs98.spec index aa49345..e1e682c 100644 --- a/hugs98.spec +++ b/hugs98.spec @@ -2,13 +2,14 @@ Name: hugs98 Version: 2005.03 -Release: 1%{?dist} +Release: 4%{?dist} Summary: Haskell Interpreter Group: Development/Languages License: BSD URL: http://www.haskell.org/hugs Source0: http://cvs.haskell.org/Hugs/downloads/Mar2005/%{name}-%{hugs_ver}.tar.gz +Patch0: openal-1.0_1.2.patch BuildRoot: %{_tmppath}/%{name}-%{version}-%{release}-root-%(%{__id_u} -n) BuildRequires: docbook-utils @@ -23,7 +24,7 @@ BuildRequires: libXmu-devel BuildRequires: libXt-devel BuildRequires: readline-devel BuildRequires: xorg-x11-proto-devel -#BuildRequires: openal-devel +BuildRequires: openal-devel %description Hugs 98 is a functional programming system based on Haskell 98, the de @@ -31,6 +32,15 @@ facto standard for non-strict functional programming languages. Hugs 98 provides an almost complete implementation of Haskell 98. +%package openal +Summary: OpenAL package for Hugs98 +Group: Development/Languages +Requires: %{name} = %{version}-%{release} + +%description openal +OpenAL package for Hugs98. + + %package x11 Summary: X11 package for Hugs98 Group: Development/Languages @@ -82,6 +92,7 @@ Demo files for Hugs98. %prep %setup -q -n %{name}-%{hugs_ver} +%patch0 -p1 %build @@ -116,6 +127,7 @@ rm -rf $RPM_BUILD_ROOT %doc docs/users_guide/users_guide %{_bindir}/* %{_libdir}/hugs +%exclude %{_libdir}/hugs/packages/OpenAL %exclude %{_libdir}/hugs/packages/X11 %exclude %{_libdir}/hugs/packages/OpenGL %exclude %{_libdir}/hugs/packages/GLUT @@ -128,6 +140,11 @@ rm -rf $RPM_BUILD_ROOT %doc installed-demos/* +%files openal +%defattr(-,root,root,-) +%{_libdir}/hugs/packages/OpenAL + + %files x11 %defattr(-,root,root,-) %{_libdir}/hugs/packages/X11 @@ -149,6 +166,9 @@ rm -rf $RPM_BUILD_ROOT %changelog +* Mon Apr 24 2006 Gerard Milmeister - 2005.03-3 +- added patch provided by Jens Petersen to build OpenAL package + * Tue Apr 18 2006 Gerard Milmeister - 2005.03-1 - changed version numbering scheme - split off demos package diff --git a/openal-1.0_1.2.patch b/openal-1.0_1.2.patch new file mode 100644 index 0000000..5d7aeea --- /dev/null +++ b/openal-1.0_1.2.patch @@ -0,0 +1,9429 @@ +diff -uNr --exclude=autom4te.cache --exclude=.cvsignore hugs98-Mar2005-patched/fptools/libraries/OpenAL/LICENSE ghc-6.4.2/libraries/OpenAL/LICENSE +--- hugs98-Mar2005-patched/fptools/libraries/OpenAL/LICENSE 2004-01-03 04:03:07.000000000 +0900 ++++ ghc-6.4.2/libraries/OpenAL/LICENSE 2006-03-22 00:58:03.000000000 +0900 +@@ -1,4 +1,4 @@ +-Copyright (c) 2003-2004, Sven Panne ++Copyright (c) 2003-2005, Sven Panne + All rights reserved. + + Redistribution and use in source and binary forms, with or without +diff -uNr --exclude=autom4te.cache --exclude=.cvsignore hugs98-Mar2005-patched/fptools/libraries/OpenAL/Makefile ghc-6.4.2/libraries/OpenAL/Makefile +--- hugs98-Mar2005-patched/fptools/libraries/OpenAL/Makefile 2005-03-03 01:39:55.000000000 +0900 ++++ ghc-6.4.2/libraries/OpenAL/Makefile 2006-03-22 00:58:03.000000000 +0900 +@@ -4,6 +4,12 @@ + include $(TOP)/mk/boilerplate.mk + -include config.mk + ++ifneq "$(findstring clean, $(MAKECMDGOALS))" "" ++# if we're cleaning, then config.mk might have been cleaned already ++AL_BUILD_PACKAGE=yes ++PACKAGE=OpenAL ++endif ++ + ifneq "$(AL_BUILD_PACKAGE)" "no" + + # ----------------------------------------------------------------------------- +@@ -18,19 +24,17 @@ + Sound \ + Sound/OpenAL \ + Sound/OpenAL/AL \ +- Sound/OpenAL/ALC \ +- Sound/OpenAL/ALUT ++ Sound/OpenAL/ALC + + PACKAGE_DEPS = base OpenGL + + SRC_HC_OPTS += -Wall -fffi -Iinclude '-\#include "HsOpenAL.h"' -cpp + + # WinDoze DLL hell ++# NOTE: For some obscure/unknown reason, OpenAL uses ccall, even on WinDoze... ++SRC_HC_OPTS += -DCALLCONV=ccall + ifeq "$(TARGETPLATFORM)" "i386-unknown-mingw32" +-SRC_HC_OPTS += -DCALLCONV=stdcall + SRC_HC_OPTS := $(subst -mno-cygwin,,$(SRC_HC_OPTS)) +-else +-SRC_HC_OPTS += -DCALLCONV=ccall + endif + + PACKAGE_CPP_OPTS += -DMAINTAINER=$(MAINTAINER) +@@ -41,18 +45,14 @@ + + package.conf.inplace \ + package.conf.installed \ +-Sound/OpenAL/AL/BasicTypes.$(way_)o \ +-Sound/OpenAL/AL/Format.$(way_)o \ +-Sound/OpenAL/ALC/BasicTypes.$(way_)o \ +-Sound/OpenAL/ALC/Errors.$(way_)o \ +-Sound/OpenAL/ALC/Queries.$(way_)o : include/HsOpenALConfig.h ++Sound/OpenAL/Config.$(way_)o \ ++Sound/OpenAL/Constants.$(way_)o : include/HsOpenALConfig.h + + endif + + # ----------------------------------------------------------------------------- + +-DIST_CLEAN_FILES += OpenAL.buildinfo config.cache config.status +-LATE_DIST_CLEAN_FILES += config.mk ++DIST_CLEAN_FILES += OpenAL.buildinfo config.cache config.status config.mk + + extraclean:: + $(RM) -rf autom4te.cache +diff -uNr --exclude=autom4te.cache --exclude=.cvsignore hugs98-Mar2005-patched/fptools/libraries/OpenAL/OpenAL.buildinfo.in ghc-6.4.2/libraries/OpenAL/OpenAL.buildinfo.in +--- hugs98-Mar2005-patched/fptools/libraries/OpenAL/OpenAL.buildinfo.in 2005-01-16 22:13:05.000000000 +0900 ++++ ghc-6.4.2/libraries/OpenAL/OpenAL.buildinfo.in 2006-03-22 00:58:03.000000000 +0900 +@@ -2,6 +2,7 @@ + -- System-dependent values used by Distribution.Simple.defaultUserHooks + -- + buildable: @BUILD_PACKAGE_BOOL@ ++ghc-options: -DCALLCONV=@CALLCONV@ + cc-options: -DCALLCONV=@CALLCONV@ + ld-options: @AL_LIBS@ + frameworks: @AL_FRAMEWORKS@ +diff -uNr --exclude=autom4te.cache --exclude=.cvsignore hugs98-Mar2005-patched/fptools/libraries/OpenAL/OpenAL.cabal ghc-6.4.2/libraries/OpenAL/OpenAL.cabal +--- hugs98-Mar2005-patched/fptools/libraries/OpenAL/OpenAL.cabal 2005-02-11 10:55:55.000000000 +0900 ++++ ghc-6.4.2/libraries/OpenAL/OpenAL.cabal 2006-03-22 00:58:03.000000000 +0900 +@@ -1,5 +1,5 @@ + name: OpenAL +-version: 1.0 ++version: 1.2 + license: BSD3 + license-file: LICENSE + maintainer: Sven Panne +@@ -10,27 +10,36 @@ + exposed-modules: + Sound.OpenAL, + Sound.OpenAL.AL, ++ Sound.OpenAL.AL.ALboolean, ++ Sound.OpenAL.AL.Attenuation, + Sound.OpenAL.AL.BasicTypes, + Sound.OpenAL.AL.Buffer, ++ Sound.OpenAL.AL.BufferInternal, ++ Sound.OpenAL.AL.Doppler, ++ Sound.OpenAL.AL.Errors, ++ Sound.OpenAL.AL.Extensions, ++ Sound.OpenAL.AL.Format, + Sound.OpenAL.AL.Listener, + Sound.OpenAL.AL.Source, ++ Sound.OpenAL.AL.StringQueries, + Sound.OpenAL.ALC, ++ Sound.OpenAL.ALC.BasicTypes, ++ Sound.OpenAL.ALC.Capture, + Sound.OpenAL.ALC.Context, + Sound.OpenAL.ALC.Device, + Sound.OpenAL.ALC.Errors, +- Sound.OpenAL.ALC.Extensions, +- Sound.OpenAL.ALUT, +- Sound.OpenAL.ALUT.Initialization, +- Sound.OpenAL.ALUT.WAV ++ Sound.OpenAL.ALC.Extensions + other-modules: +- Sound.OpenAL.AL.ALboolean, +- Sound.OpenAL.AL.Format, + Sound.OpenAL.AL.PeekPoke, + Sound.OpenAL.AL.QueryUtils, +- Sound.OpenAL.ALC.BasicTypes, +- Sound.OpenAL.ALC.Queries, +- Sound.OpenAL.ALUT.Exception ++ Sound.OpenAL.AL.SourceState, ++ Sound.OpenAL.AL.String, ++ Sound.OpenAL.ALC.ALCboolean, ++ Sound.OpenAL.ALC.QueryUtils, ++ Sound.OpenAL.ALC.String, ++ Sound.OpenAL.Config, ++ Sound.OpenAL.Constants + include-dirs: include + includes: "HsOpenAL.h" + build-depends: base, OpenGL +-extensions: CPP ++extensions: CPP, ForeignFunctionInterface +diff -uNr --exclude=autom4te.cache --exclude=.cvsignore hugs98-Mar2005-patched/fptools/libraries/OpenAL/Sound/OpenAL/AL/ALboolean.hs ghc-6.4.2/libraries/OpenAL/Sound/OpenAL/AL/ALboolean.hs +--- hugs98-Mar2005-patched/fptools/libraries/OpenAL/Sound/OpenAL/AL/ALboolean.hs 2004-01-03 04:03:08.000000000 +0900 ++++ ghc-6.4.2/libraries/OpenAL/Sound/OpenAL/AL/ALboolean.hs 2006-03-22 00:58:03.000000000 +0900 +@@ -2,7 +2,7 @@ + -------------------------------------------------------------------------------- + -- | + -- Module : Sound.OpenAL.AL.ALboolean +--- Copyright : (c) Sven Panne 2003-2004 ++-- Copyright : (c) Sven Panne 2003-2005 + -- License : BSD-style (see the file libraries/OpenAL/LICENSE) + -- + -- Maintainer : sven.panne@aedion.de +@@ -14,16 +14,17 @@ + -------------------------------------------------------------------------------- + + module Sound.OpenAL.AL.ALboolean ( +- ALboolean, marshalALboolean, unmarshalALboolean ++ marshalALboolean, unmarshalALboolean + ) where + + import Sound.OpenAL.AL.BasicTypes ( ALboolean ) ++import Sound.OpenAL.Constants ( al_FALSE, al_TRUE ) + + -------------------------------------------------------------------------------- + + marshalALboolean :: Bool -> ALboolean +-marshalALboolean False = 0 +-marshalALboolean True = 1 ++marshalALboolean False = al_FALSE ++marshalALboolean True = al_TRUE + + unmarshalALboolean :: ALboolean -> Bool +-unmarshalALboolean = (/= 0) ++unmarshalALboolean = (/= al_FALSE) +diff -uNr --exclude=autom4te.cache --exclude=.cvsignore hugs98-Mar2005-patched/fptools/libraries/OpenAL/Sound/OpenAL/AL/Attenuation.hs ghc-6.4.2/libraries/OpenAL/Sound/OpenAL/AL/Attenuation.hs +--- hugs98-Mar2005-patched/fptools/libraries/OpenAL/Sound/OpenAL/AL/Attenuation.hs 1970-01-01 09:00:00.000000000 +0900 ++++ ghc-6.4.2/libraries/OpenAL/Sound/OpenAL/AL/Attenuation.hs 2006-03-22 00:58:03.000000000 +0900 +@@ -0,0 +1,211 @@ ++-------------------------------------------------------------------------------- ++-- | ++-- Module : Sound.OpenAL.AL.Attenuation ++-- Copyright : (c) Sven Panne 2005 ++-- License : BSD-style (see the file libraries/OpenAL/LICENSE) ++-- ++-- Maintainer : sven.panne@aedion.de ++-- Stability : provisional ++-- Portability : portable ++-- ++-- This module corresponds to section 3.4 (Attenuation By Distance) of the ++-- OpenAL Specification and Reference (version 1.1). ++-- ++-------------------------------------------------------------------------------- ++ ++module Sound.OpenAL.AL.Attenuation ( ++ -- * Introduction ++ -- $Introduction ++ ++ -- * Handling the Distance Model ++ DistanceModel(..), distanceModel ++ ++ -- * Evaluation of Gain\/Attenuation Related State ++ -- $EvaluationOfGainAttenuationRelatedState ++ ++ -- * No Culling By Distance ++ -- $NoCullingByDistance ++) where ++ ++import Foreign.Marshal.Alloc ( alloca ) ++import Foreign.Ptr ( Ptr ) ++import Graphics.Rendering.OpenGL.GL.StateVar ( StateVar, makeStateVar ) ++import Sound.OpenAL.AL.BasicTypes ( ALint, ALenum ) ++import Sound.OpenAL.AL.PeekPoke ( peek1 ) ++import Sound.OpenAL.AL.QueryUtils ( ++ GetPName(GetDistanceModel), marshalGetPName ) ++import Sound.OpenAL.Constants ( ++ al_NONE, al_INVERSE_DISTANCE, al_INVERSE_DISTANCE_CLAMPED, ++ al_LINEAR_DISTANCE, al_LINEAR_DISTANCE_CLAMPED, al_EXPONENT_DISTANCE, ++ al_EXPONENT_DISTANCE_CLAMPED ) ++ ++#ifdef __HADDOCK__ ++import Sound.OpenAL.AL.Source ( ++ sourceGain, gainBounds, coneAngles, coneOuterGain, referenceDistance, ++ rolloffFactor, maxDistance ) ++#endif ++ ++-------------------------------------------------------------------------------- ++-- $Introduction ++-- Samples usually use the entire dynamic range of the chosen format\/encoding, ++-- independent of their real world intensity. In other words, a jet engine and a ++-- clockwork both will have samples with full amplitude. The application will ++-- then have to adjust source gain accordingly to account for relative ++-- differences. ++-- ++-- Source gain is then attenuated by distance. The effective attenuation of a ++-- source depends on many factors, among which distance attenuation and source ++-- and listener gain are only some of the contributing factors. Even if the ++-- source and listener gain exceed 1 (amplification beyond the guaranteed ++-- dynamic range), distance and other attenuation might ultimately limit the ++-- overall gain to a value below 1. ++ ++-------------------------------------------------------------------------------- ++-- $EvaluationOfGainAttenuationRelatedState ++-- While amplification\/attenuation commute (multiplication of scaling factors), ++-- clamping operations do not. The order in which various gain related ++-- operations are applied is: ++-- ++-- 1. Distance attenuation is calculated first, including minimum ++-- ('referenceDistance') and maximum ('maxDistance') thresholds. ++-- ++-- 2. The result is then multiplied by source gain. ++-- ++-- 3. If the source is directional (the inner cone angle is less than the outer ++-- cone angle, see 'coneAngles'), an angle-dependent attenuation is calculated ++-- depending on 'coneOuterGain', and multiplied with the distance-dependent ++-- attenuation. The resulting attenuation factor for the given angle and ++-- distance between listener and source is multiplied with 'sourceGain'. ++-- ++-- 4. The effective gain computed this way is compared against 'gainBounds'. ++-- ++-- 5. The result is guaranteed to be clamped to 'gainBounds', and subsequently ++-- multiplied by listener gain which serves as an overall volume control. ++-- ++-- The implementation is free to clamp listener gain if necessary due to ++-- hardware or implementation constraints. ++ ++-------------------------------------------------------------------------------- ++-- $NoCullingByDistance ++-- With the DS3D compatible inverse clamped distance model, OpenAL provides a ++-- per-source 'maxDistance' attribute that can be used to define a distance ++-- beyond which the source will not be further attenuated by distance. The DS3D ++-- distance attenuation model and its clamping of volume is also extended by a ++-- mechanism to cull (mute) sources from processing, based on distance. However, ++-- the OpenAL does not support culling a source from processing based on a ++-- distance threshold. ++-- ++-- At this time OpenAL is not meant to support culling at all. Culling based on ++-- distance, or bounding volumes, or other criteria, is best left to the ++-- application. For example, the application might employ sophisticated ++-- techniques to determine whether sources are audible that are beyond the scope ++-- of OpenAL. In particular, rule based culling inevitably introduces acoustic ++-- artifacts. E.g. if the listener-source distance is nearly equal to the culling ++-- threshold distance, but varies above and below, there will be popping ++-- artifacts in the absence of hysteresis. ++ ++-------------------------------------------------------------------------------- ++ ++-- | OpenAL currently supports six modes of operation with respect to distance ++-- attenuation, including one that is similar to the IASIG I3DL2 model. The ++-- application chooses one of these models (or chooses to disable ++-- distance-dependent attenuation) on a per-context basis. ++-- ++-- The distance used in the formulas for the \"clamped\" modes below is clamped ++-- to be in the range between 'referenceDistance' and 'maxDistance': ++-- ++-- /clamped distance/ = ++-- max('referenceDistance', min(/distance/, 'maxDistance')) ++-- ++-- The linear models are not physically realistic, but do allow full attenuation ++-- of a source beyond a specified distance. The OpenAL implementation is still ++-- free to apply any range clamping as necessary. ++-- ++-- With all the distance models, if the formula can not be evaluated then the ++-- source will not be attenuated. For example, if a linear model is being used ++-- with 'referenceDistance' equal to 'maxDistance', then the gain equation will ++-- have a divide-by-zero error in it. In this case, there is no attenuation for ++-- that source. ++ ++data DistanceModel = ++ NoAttenuation ++ -- ^ Bypass all distance attenuation calculation for all sources. The ++ -- implementation is expected to optimize this situation. ++ | InverseDistance ++ -- ^ Inverse distance rolloff model, which is equivalent to the IASIG I3DL2 ++ -- model with the exception that 'referenceDistance' does not imply any ++ -- clamping. ++ -- ++ -- /gain/ = 'referenceDistance' \/ ('referenceDistance' + ++ -- 'rolloffFactor' \* (/distance/ - 'referenceDistance')) ++ -- ++ -- The 'referenceDistance' parameter used here is a per-source attribute ++ -- which is the distance at which the listener will experience gain ++ -- (unless the implementation had to clamp effective gain to the available ++ -- dynamic range). 'rolloffFactor' is per-source parameter the application ++ -- can use to increase or decrease the range of a source by decreasing or ++ -- increasing the attenuation, respectively. The default value is 1. The ++ -- implementation is free to optimize for a 'rolloffFactor' value of 0, ++ -- which indicates that the application does not wish any distance ++ -- attenuation on the respective source. ++ | InverseDistanceClamped ++ -- ^ Inverse Distance clamped model, which is essentially the inverse ++ -- distance rolloff model, extended to guarantee that for distances below ++ -- 'referenceDistance', gain is clamped. This mode is equivalent to the ++ -- IASIG I3DL2 distance model. ++ | LinearDistance ++ -- ^ Linear distance rolloff model, modeling a linear dropoff in gain as ++ -- distance increases between the source and listener. ++ -- ++ -- /gain/ = (1 - 'rolloffFactor' \* (/distance/ - 'referenceDistance') \/ ++ -- ('maxDistance' - 'referenceDistance')) ++ | LinearDistanceClamped ++ -- ^ Linear Distance clamped model, which is the linear model, extended to ++ -- guarantee that for distances below 'referenceDistance', gain is clamped. ++ | ExponentDistance ++ -- ^ Exponential distance rolloff model, modeling an exponential dropoff in ++ -- gain as distance increases between the source and listener. ++ -- ++ -- /gain/ = (/distance/ \/ 'referenceDistance') \*\* (- 'rolloffFactor') ++ | ExponentDistanceClamped ++ -- ^ Exponential Distance clamped model, which is the exponential model, ++ -- extended to guarantee that for distances below 'referenceDistance', ++ -- gain is clamped. ++ deriving ( Eq, Ord, Show ) ++ ++marshalDistanceModel :: DistanceModel -> ALenum ++marshalDistanceModel x = case x of ++ NoAttenuation -> al_NONE ++ InverseDistance -> al_INVERSE_DISTANCE ++ InverseDistanceClamped -> al_INVERSE_DISTANCE_CLAMPED ++ LinearDistance -> al_LINEAR_DISTANCE ++ LinearDistanceClamped -> al_LINEAR_DISTANCE_CLAMPED ++ ExponentDistance -> al_EXPONENT_DISTANCE ++ ExponentDistanceClamped -> al_EXPONENT_DISTANCE_CLAMPED ++ ++unmarshalDistanceModel :: ALenum -> DistanceModel ++unmarshalDistanceModel x ++ | x == al_NONE = NoAttenuation ++ | x == al_INVERSE_DISTANCE = InverseDistance ++ | x == al_INVERSE_DISTANCE_CLAMPED = InverseDistanceClamped ++ | x == al_LINEAR_DISTANCE = LinearDistance ++ | x == al_LINEAR_DISTANCE_CLAMPED = LinearDistanceClamped ++ | x == al_EXPONENT_DISTANCE = ExponentDistance ++ | x == al_EXPONENT_DISTANCE_CLAMPED = ExponentDistanceClamped ++ | otherwise = error ("unmarshalDistanceModel: illegal value " ++ show x) ++ ++-- | Contains the current per-context distance model. ++ ++distanceModel :: StateVar DistanceModel ++distanceModel = ++ makeStateVar ++ (alloca $ \buf -> do ++ alGetIntegerv (marshalGetPName GetDistanceModel) buf ++ peek1 (unmarshalDistanceModel . fromIntegral) buf) ++ (alDistanceModel . marshalDistanceModel) ++ ++foreign import CALLCONV unsafe "alGetIntegerv" ++ alGetIntegerv :: ALenum -> Ptr ALint -> IO () ++ ++foreign import CALLCONV unsafe "alDistanceModel" ++ alDistanceModel :: ALenum -> IO () +diff -uNr --exclude=autom4te.cache --exclude=.cvsignore hugs98-Mar2005-patched/fptools/libraries/OpenAL/Sound/OpenAL/AL/BasicTypes.hs ghc-6.4.2/libraries/OpenAL/Sound/OpenAL/AL/BasicTypes.hs +--- hugs98-Mar2005-patched/fptools/libraries/OpenAL/Sound/OpenAL/AL/BasicTypes.hs 2004-01-03 04:03:08.000000000 +0900 ++++ ghc-6.4.2/libraries/OpenAL/Sound/OpenAL/AL/BasicTypes.hs 2006-03-22 00:58:03.000000000 +0900 +@@ -1,72 +1,49 @@ + -------------------------------------------------------------------------------- + -- | + -- Module : Sound.OpenAL.AL.BasicTypes +--- Copyright : (c) Sven Panne 2003-2004 ++-- Copyright : (c) Sven Panne 2003-2005 + -- License : BSD-style (see the file libraries/OpenAL/LICENSE) + -- + -- Maintainer : sven.panne@aedion.de + -- Stability : provisional + -- Portability : portable + -- +--- This module corresponds to section 2.1.1 (Primitive Types) of the OpenAL +--- Specification and Reference (version 1.0). ++-- This module corresponds to section 2.2 (Primitive Types) of the OpenAL ++-- Specification and Reference (version 1.1). + -- + -------------------------------------------------------------------------------- + + module Sound.OpenAL.AL.BasicTypes ( +- ALboolean, ALbyte, ALshort, ALint, ALubyte, ALushort, ALuint, ALsizei, +- ALenum, ALbitfield, ALfloat, ALclampf, ALdouble, ALclampd +-) where +- +--------------------------------------------------------------------------------- ++ -- * Primitive Types ++ -- $PrimitiveTypes + +-import Data.Int +-import Data.Word ++ -- * Floating-Point Computation ++ -- $FloatingPointComputation + +--------------------------------------------------------------------------------- ++ ALboolean, ALchar, ALbyte, ALubyte, ALshort, ALushort, ALint, ALuint, ++ ALsizei, ALenum, ALfloat, ALdouble ++) where + +-#include "HsOpenALConfig.h" ++import Sound.OpenAL.Config + + -------------------------------------------------------------------------------- +- +--- | Boolean (min. 1 bit) +-type ALboolean = HTYPE_ALBOOLEAN +- +--- | Signed 2\'s complement binary integer (min. 8 bits) +-type ALbyte = HTYPE_ALBYTE +- +--- | Unsigned binary integer (min. 8 bits) +-type ALubyte = HTYPE_ALUBYTE +- +--- | Signed 2\'s complement binary integer (min. 16 bits) +-type ALshort = HTYPE_ALSHORT +- +--- | Unsigned binary integer (min. 16 bits) +-type ALushort = HTYPE_ALUSHORT +- +--- | Signed 2\'s complement binary integer (min. 32 bits) +-type ALint = HTYPE_ALINT +- +--- | Unsigned binary integer (min. 32 bits) +-type ALuint = HTYPE_ALUINT +- +--- | Non-negatitve binary integer size (min. 32 bits) +-type ALsizei = HTYPE_ALSIZEI +- +--- | Enumerated binary integer value (min. 32 bits) +-type ALenum = HTYPE_ALENUM +- +--- | Bit field (min. 32 bits) +-type ALbitfield = HTYPE_ALBITFIELD +- +--- | Floating-point value (min. 32 bits) +-type ALfloat = HTYPE_ALFLOAT +- +--- | Floating-point value clamped to [0,1] (min. 32 bits) +-type ALclampf = HTYPE_ALCLAMPF +- +--- | Floating-point value (min. 64 bits) +-type ALdouble = HTYPE_ALDOUBLE +- +--- | Floating-point value clamped to [0,1] (min. 64 bits) +-type ALclampd = HTYPE_ALCLAMPD ++-- $PrimitiveTypes ++-- As OpenAL is meant to allow for seamless integration with OpenGL code if ++-- needed, the OpenAL library primitive (scalar) data types mimic the OpenGL ++-- data types. Guaranteed minimum sizes are stated for OpenGL data types, but ++-- the actual choice of C data type is left to the implementation. All ++-- implementations on a given binary architecture, however, must use a common ++-- definition of these data types. ++ ++-------------------------------------------------------------------------------- ++-- $FloatingPointComputation ++-- Any representable floating-point value is legal as input to an OpenAL command ++-- that requires floating point data. The result of providing a value that is ++-- not a floating point number to such a command is unspecified, but must not ++-- lead to OpenAL being interrupted or terminated. In IEEE arithmetic, for ++-- example, providing a negative zero or a denormalized number to an OpenAL ++-- command yields predictable results, while providing a NaN or infinity yields ++-- unspecified results. Some calculations require division. In such cases ++-- (including implied divisions required by vector normalizations), a division ++-- by zero produces an unspecified result but must not lead to OpenAL ++-- interruption or termination. +diff -uNr --exclude=autom4te.cache --exclude=.cvsignore hugs98-Mar2005-patched/fptools/libraries/OpenAL/Sound/OpenAL/AL/Buffer.hs ghc-6.4.2/libraries/OpenAL/Sound/OpenAL/AL/Buffer.hs +--- hugs98-Mar2005-patched/fptools/libraries/OpenAL/Sound/OpenAL/AL/Buffer.hs 2004-05-12 04:31:01.000000000 +0900 ++++ ghc-6.4.2/libraries/OpenAL/Sound/OpenAL/AL/Buffer.hs 2006-03-22 00:58:03.000000000 +0900 +@@ -1,34 +1,101 @@ + -------------------------------------------------------------------------------- + -- | + -- Module : Sound.OpenAL.AL.Buffer +--- Copyright : (c) Sven Panne 2003-2004 ++-- Copyright : (c) Sven Panne 2003-2005 + -- License : BSD-style (see the file libraries/OpenAL/LICENSE) + -- + -- Maintainer : sven.panne@aedion.de + -- Stability : provisional + -- Portability : portable + -- ++-- This module corresponds to chapter 6 (Buffers) of the OpenAL Specification ++-- and Reference (version 1.1). ++-- ++-- A buffer encapsulates OpenAL state related to storing sample data. The ++-- application can request and release buffer objects, and fill them with ++-- data. Data can be supplied compressed and encoded as long as the format is ++-- supported. Buffers can, internally, contain waveform data as uncompressed or ++-- compressed samples. ++-- ++-- Unlike source (see "Sound.OpenAL.AL.Source") and listener (see ++-- "Sound.OpenAL.AL.Listener") objects, buffer objects can be shared among AL ++-- contexts. Buffers are referenced by sources. A single buffer can be referred ++-- to by multiple sources. This separation allows drivers and hardware to ++-- optimize storage and processing where applicable. ++-- ++-- The simplest supported format for buffer data is PCM. PCM data is assumed to ++-- use the processor\'s native byte order. Other formats use the byte order ++-- native to that format. ++-- ++-- At this time, buffer states are defined for purposes of discussion. The ++-- states described in this section are not exposed through the API (can not be ++-- queried, or be set directly), and the state description used in the ++-- implementation might differ from this. ++-- ++-- A buffer is considered to be in one of the following states, with respect to ++-- all sources: ++-- ++-- [/unused/] The buffer is not included in any queue for any source. In ++-- particular, the buffer is neither pending nor current for any source. The ++-- buffer name can be deleted at this time. ++-- ++-- [/processed/] The buffer is listed in the queue of at least one source, but ++-- is neither pending nor current for any source. The buffer can be deleted as ++-- soon as it has been unqueued for all sources it is queued with. ++-- ++-- [/pending/] There is at least one source for which the buffer has been queued, ++-- for which the buffer data has not yet been dereferenced. The buffer can only ++-- be unqueued for those sources that have dereferenced the data in the buffer ++-- in its entirety, and cannot be deleted or changed. ++-- ++-- The buffer state is dependent on the state of all sources that is has been ++-- queued for. A single queue occurrence of a buffer propagates the buffer state ++-- (over all sources) from /unused/ to /processed/ or higher. Sources that are ++-- in the 'Stopped' or 'Initial' states still have queue entries that cause ++-- buffers to be /processed/. ++-- ++-- A single queue entry with a single source for which the buffer is not yet ++-- /processed/ propagates the buffer\'s queuing state to /pending/. ++-- ++-- Buffers that are /processed/ for a given source can be unqueued from that ++-- source\'s queue. Buffers that have been unqueued from all sources are ++-- /unused/. Buffers that are /unused/ can be deleted, or changed by writing ++-- 'bufferData'. ++-- + -------------------------------------------------------------------------------- + + module Sound.OpenAL.AL.Buffer ( +- Format(..), BufferSize, Frequency, BufferData(..), +- Buffer, bufferData ++ Buffer, MemoryRegion(..), Format(..), BufferData(..), bufferData + ) where + +-import Control.Monad ( liftM ) + import Foreign.Marshal.Alloc ( alloca ) +-import Foreign.Marshal.Array ( withArrayLen, peekArray, allocaArray ) + import Foreign.Ptr ( Ptr, nullPtr ) +-import Foreign.Storable ( Storable(peek) ) +-import Graphics.Rendering.OpenGL.GL.BufferObjects ( ObjectName(..) ) + import Graphics.Rendering.OpenGL.GL.StateVar ( StateVar, makeStateVar ) +-import Sound.OpenAL.AL.BasicTypes ++import Sound.OpenAL.AL.BufferInternal ( Buffer ) ++import Sound.OpenAL.AL.BasicTypes ( ALint, ALsizei, ALenum ) + import Sound.OpenAL.AL.Format ( Format(..), marshalFormat ) +-import Sound.OpenAL.AL.ALboolean ( unmarshalALboolean ) ++import Sound.OpenAL.AL.PeekPoke ( peek1 ) ++import Sound.OpenAL.ALC.Context ( Frequency ) ++import Sound.OpenAL.Constants ( al_FREQUENCY, al_SIZE, al_BITS, al_CHANNELS ) ++ ++#ifdef __HADDOCK__ ++import Sound.OpenAL.AL.SourceState ( SourceState(..) ) ++import Sound.OpenAL.AL.Errors ( ALErrorCategory(..) ) ++#endif + + -------------------------------------------------------------------------------- + +-data BufferData a = BufferData Format (Ptr a) BufferSize Frequency ++data MemoryRegion a = MemoryRegion (Ptr a) ALsizei ++#ifdef __HADDOCK__ ++-- Help Haddock a bit, because it doesn't do any instance inference. ++instance Eq (MemoryRegion a) ++instance Ord (MemoryRegion a) ++instance Show (MemoryRegion a) ++#else ++ deriving ( Eq, Ord, Show ) ++#endif ++ ++data BufferData a = BufferData (MemoryRegion a) Format Frequency + #ifdef __HADDOCK__ + -- Help Haddock a bit, because it doesn't do any instance inference. + instance Eq (BufferData a) +@@ -38,37 +105,25 @@ + deriving ( Eq, Ord, Show ) + #endif + +-type BufferSize = ALsizei +- +-type Frequency = ALsizei -- or Float??? +- + -------------------------------------------------------------------------------- + +-newtype Buffer = Buffer { bufferID :: ALuint } +- deriving ( Eq, Ord, Show ) +- +-instance ObjectName Buffer where +- genObjectNames n = +- allocaArray n $ \buf -> do +- alGenBuffers (fromIntegral n) buf +- liftM (map Buffer) $ peekArray n buf +- +- deleteObjectNames buffers = +- withArrayLen (map bufferID buffers) $ +- alDeleteBuffers . fromIntegral +- +- isObjectName = liftM unmarshalALboolean . alIsBuffer . bufferID +- +-foreign import CALLCONV unsafe "alGenBuffers" +- alGenBuffers :: ALsizei -> Ptr ALuint -> IO () +- +-foreign import CALLCONV unsafe "alDeleteBuffers" +- alDeleteBuffers :: ALsizei -> Ptr ALuint -> IO () +- +-foreign import CALLCONV unsafe "alIsBuffer" +- alIsBuffer :: ALuint -> IO ALboolean +- +--------------------------------------------------------------------------------- ++-- | A special case of buffer state is the actual sound sample data stored in ++-- association with the buffer. Applications can specify sample data using ++-- 'bufferData'. ++-- ++-- The data specified is copied to an internal software, or if possible, ++-- hardware buffer. The implementation is free to apply decompression, ++-- conversion, resampling, and filtering as needed. The internal format of the ++-- buffer is not exposed to the application, and not accessible. ++-- ++-- Buffers containing audio data with more than one channel will be played ++-- without 3D spatialization features, these formats are normally used for ++-- background music. Applications should always check for an error condition ++-- after attempting to specify buffer data in case an implementation has to ++-- generate an 'ALOutOfMemory' or a conversion related 'ALInvalidValue' error. ++-- The application is free to reuse the memory specified by the data pointer ++-- once 'bufferData' is set. The implementation has to dereference, e.g. copy, ++-- the data while accessing 'bufferData' execution. + + bufferData :: Buffer -> StateVar (BufferData a) + bufferData buffer = makeStateVar (getBufferData buffer) (setBufferData buffer) +@@ -80,11 +135,11 @@ + raw <- return nullPtr -- ToDo: AL_DATA query missing!!! + size <- getBufferi buffer Size + frequency <- getBufferi buffer Frequency +- return $ BufferData (makeFormat channels bits) raw size frequency ++ return $ BufferData (MemoryRegion raw size) (makeFormat channels bits) frequency + + setBufferData :: Buffer -> BufferData a -> IO () +-setBufferData buffer (BufferData format raw size frequency) = +- alBufferData buffer (marshalFormat format) raw size frequency ++setBufferData buffer (BufferData (MemoryRegion raw size) format frequency) = ++ alBufferData buffer (marshalFormat format) raw size (round frequency) + + foreign import CALLCONV unsafe "alBufferData" + alBufferData :: Buffer -> ALenum -> Ptr a -> ALsizei -> ALsizei -> IO () +@@ -95,10 +150,8 @@ + makeFormat :: ALint -> ALint -> Format + makeFormat 1 8 = Mono8 + makeFormat 2 8 = Stereo8 +-makeFormat 4 8 = Quad8 + makeFormat 1 16 = Mono16 + makeFormat 2 16 = Stereo16 +-makeFormat 4 16 = Quad16 + makeFormat channels bits = + error ("makeFormat: illegal values " ++ show (channels, bits)) + +@@ -106,17 +159,16 @@ + + data BufferQuery = + Frequency ++ | Size + | Bits + | Channels +- | Size +- -- AL_DATA ??? + + marshalBufferQuery :: BufferQuery -> ALenum + marshalBufferQuery x = case x of +- Frequency -> 0x2001 +- Bits -> 0x2002 +- Channels -> 0x2003 +- Size -> 0x2004 ++ Frequency -> al_FREQUENCY ++ Size -> al_SIZE ++ Bits -> al_BITS ++ Channels -> al_CHANNELS + + -------------------------------------------------------------------------------- + +@@ -124,7 +176,7 @@ + getBufferi buffer query = + alloca $ \buf -> do + alGetBufferi buffer (marshalBufferQuery query) buf +- liftM fromIntegral $ peek buf ++ peek1 fromIntegral buf + + foreign import CALLCONV unsafe "alGetBufferi" + alGetBufferi :: Buffer -> ALenum -> Ptr ALint -> IO () +diff -uNr --exclude=autom4te.cache --exclude=.cvsignore hugs98-Mar2005-patched/fptools/libraries/OpenAL/Sound/OpenAL/AL/BufferInternal.hs ghc-6.4.2/libraries/OpenAL/Sound/OpenAL/AL/BufferInternal.hs +--- hugs98-Mar2005-patched/fptools/libraries/OpenAL/Sound/OpenAL/AL/BufferInternal.hs 1970-01-01 09:00:00.000000000 +0900 ++++ ghc-6.4.2/libraries/OpenAL/Sound/OpenAL/AL/BufferInternal.hs 2006-03-22 00:58:03.000000000 +0900 +@@ -0,0 +1,75 @@ ++-- #hide ++-------------------------------------------------------------------------------- ++-- | ++-- Module : Sound.OpenAL.AL.BufferInternal ++-- Copyright : (c) Sven Panne 2003-2005 ++-- License : BSD-style (see the file libraries/OpenAL/LICENSE) ++-- ++-- Maintainer : sven.panne@aedion.de ++-- Stability : provisional ++-- Portability : portable ++-- ++-- This is a purely internal module for (un-)marshaling Buffer. ++-- ++-------------------------------------------------------------------------------- ++ ++module Sound.OpenAL.AL.BufferInternal ( ++ Buffer, marshalBuffer, unmarshalBuffer ++) where ++ ++import Foreign.Marshal.Array ( withArrayLen, peekArray, allocaArray ) ++import Foreign.Ptr ( Ptr, castPtr ) ++import Foreign.Storable ( Storable(..) ) ++import Graphics.Rendering.OpenGL.GL.BufferObjects ( ObjectName(..) ) ++import Sound.OpenAL.AL.ALboolean ( unmarshalALboolean ) ++import Sound.OpenAL.AL.BasicTypes ( ALboolean, ALuint, ALsizei ) ++import Sound.OpenAL.AL.PeekPoke ( peek1, poke1 ) ++ ++-------------------------------------------------------------------------------- ++ ++-- | The abstract buffer type. ++ ++newtype Buffer = Buffer { bufferID :: ALuint } ++ deriving ( Eq, Ord, Show ) ++ ++-- | A dummy buffer. ++ ++nullBuffer :: Buffer ++nullBuffer = Buffer 0 ++ ++marshalBuffer :: Maybe Buffer -> ALuint ++marshalBuffer = bufferID . maybe nullBuffer id ++ ++unmarshalBuffer :: ALuint -> Maybe Buffer ++unmarshalBuffer b = ++ if b == bufferID nullBuffer then Nothing else Just (Buffer b) ++ ++instance Storable Buffer where ++ sizeOf ~(Buffer b) = sizeOf b ++ alignment ~(Buffer b) = alignment b ++ peek = peek1 Buffer . castPtr ++ poke ptr (Buffer b) = poke1 (castPtr ptr) b ++ ++-------------------------------------------------------------------------------- ++-- This should really be in Sound.OpenAL.AL.Buffer, but we have it here to ++-- avoid an orphan module. ++ ++instance ObjectName Buffer where ++ genObjectNames n = ++ allocaArray n $ \buf -> do ++ alGenBuffers (fromIntegral n) buf ++ peekArray n buf ++ ++ deleteObjectNames buffers = ++ withArrayLen buffers $ alDeleteBuffers . fromIntegral ++ ++ isObjectName = fmap unmarshalALboolean . alIsBuffer ++ ++foreign import CALLCONV unsafe "alGenBuffers" ++ alGenBuffers :: ALsizei -> Ptr Buffer -> IO () ++ ++foreign import CALLCONV unsafe "alDeleteBuffers" ++ alDeleteBuffers :: ALsizei -> Ptr Buffer -> IO () ++ ++foreign import CALLCONV unsafe "alIsBuffer" ++ alIsBuffer :: Buffer -> IO ALboolean +diff -uNr --exclude=autom4te.cache --exclude=.cvsignore hugs98-Mar2005-patched/fptools/libraries/OpenAL/Sound/OpenAL/AL/Doppler.hs ghc-6.4.2/libraries/OpenAL/Sound/OpenAL/AL/Doppler.hs +--- hugs98-Mar2005-patched/fptools/libraries/OpenAL/Sound/OpenAL/AL/Doppler.hs 1970-01-01 09:00:00.000000000 +0900 ++++ ghc-6.4.2/libraries/OpenAL/Sound/OpenAL/AL/Doppler.hs 2006-03-22 00:58:03.000000000 +0900 +@@ -0,0 +1,92 @@ ++-------------------------------------------------------------------------------- ++-- | ++-- Module : Sound.OpenAL.AL.Doppler ++-- Copyright : (c) Sven Panne 2005 ++-- License : BSD-style (see the file libraries/OpenAL/LICENSE) ++-- ++-- Maintainer : sven.panne@aedion.de ++-- Stability : provisional ++-- Portability : portable ++-- ++-- This module corresponds to section 3.5.2. (Velocity Dependent Doppler Effect) ++-- of the OpenAL Specification and Reference (version 1.1). ++-- ++-------------------------------------------------------------------------------- ++ ++module Sound.OpenAL.AL.Doppler ( ++ -- * Introduction ++ -- $Introduction ++ dopplerFactor, speedOfSound ++) where ++ ++import Foreign.Ptr ( FunPtr ) ++import Graphics.Rendering.OpenGL.GL.StateVar ( ++ HasGetter(get), StateVar, makeStateVar ) ++import Sound.OpenAL.AL.BasicTypes ( ALenum, ALfloat ) ++import Sound.OpenAL.AL.Extensions ( alProcAddress ) ++import Sound.OpenAL.AL.QueryUtils ( ++ GetPName(GetDopplerFactor,GetSpeedOfSound), marshalGetPName ) ++ ++#ifdef __HADDOCK__ ++import Sound.OpenAL.AL.Errors ( ALError(ALInvalidValue) ) ++#endif ++ ++-------------------------------------------------------------------------------- ++ ++-- | 'dopplerFactor' is a simple scaling of source and listener velocities to ++-- exaggerate or deemphasize the Doppler (pitch) shift resulting from the ++-- calculation. Setting 'dopplerFactor' to a negative value will result in an ++-- 'ALInvalidValue' error, the command is then ignored. The default value is 1. ++-- The implementation is free to optimize the case of 'dopplerFactor' containing ++-- zero, as this effectively disables the effect. ++ ++dopplerFactor :: StateVar ALfloat ++dopplerFactor = makeDopplerVar GetDopplerFactor "alDopplerFactor" ++ ++-------------------------------------------------------------------------------- ++ ++-- | 'speedOfSound' allows the application to change the reference (propagation) ++-- speed used in the Doppler calculation. The source and listener velocities ++-- should be expressed in the same units as the speed of sound. Setting ++-- 'speedOfSound' to a negative or zero value will result in an 'ALInvalidValue' ++-- error, the command is ignored then. The default value is 343.3 (appropriate ++-- for velocity units of meters and air as the propagation medium). ++ ++speedOfSound :: StateVar ALfloat ++speedOfSound = makeDopplerVar GetSpeedOfSound "alSpeedOfSound" ++ ++-------------------------------------------------------------------------------- ++ ++makeDopplerVar :: GetPName -> String -> StateVar ALfloat ++makeDopplerVar p apiEntryName = ++ makeStateVar ++ (alGetFloat (marshalGetPName p)) ++ (\value -> do ++ -- ToDo: Should we check alcVersion or alIsExtensionPresent here? ++ funPtr <- get (alProcAddress apiEntryName) ++ invokeWithFloat funPtr value) ++ ++foreign import CALLCONV unsafe "alGetFloat" ++ alGetFloat :: ALenum -> IO ALfloat ++ ++type Invoker a = FunPtr a -> a ++ ++foreign import CALLCONV unsafe "dynamic" ++ invokeWithFloat :: Invoker (ALfloat -> IO ()) ++ ++-------------------------------------------------------------------------------- ++-- $Introduction ++-- The Doppler Effect depends on the velocities of source and listener relative ++-- to the medium, and the propagation speed of sound in that medium. The ++-- application might want to emphasize or de-emphasize the Doppler Effect as ++-- physically accurate calculation might not give the desired results. ++-- The amount of frequency shift (pitch change) is proportional to the speed of ++-- listener and source along their line of sight. ++-- ++-- The Doppler Effect as implemented by OpenAL is described in detail in section ++-- 3.5.2 of the OpenAL 1.1 specification. Note that effects of the medium (air, ++-- water) moving with respect to listener and source are ignored. There are two ++-- API calls global to the current context that provide control of the Doppler ++-- factor and the speed of sound. Distance and velocity units are completely ++-- independent of one another (so you could use different units for each if ++-- desired). +diff -uNr --exclude=autom4te.cache --exclude=.cvsignore hugs98-Mar2005-patched/fptools/libraries/OpenAL/Sound/OpenAL/AL/Errors.hs ghc-6.4.2/libraries/OpenAL/Sound/OpenAL/AL/Errors.hs +--- hugs98-Mar2005-patched/fptools/libraries/OpenAL/Sound/OpenAL/AL/Errors.hs 1970-01-01 09:00:00.000000000 +0900 ++++ ghc-6.4.2/libraries/OpenAL/Sound/OpenAL/AL/Errors.hs 2006-03-22 00:58:03.000000000 +0900 +@@ -0,0 +1,88 @@ ++-------------------------------------------------------------------------------- ++-- | ++-- Module : Sound.OpenAL.AL.Errors ++-- Copyright : (c) Sven Panne 2003-2005 ++-- License : BSD-style (see the file libraries/OpenAL/LICENSE) ++-- ++-- Maintainer : sven.panne@aedion.de ++-- Stability : provisional ++-- Portability : portable ++-- ++-- This module corresponds to section 2.7 (AL Errors) of the OpenAL ++-- Specification and Reference (version 1.1). ++-- ++-------------------------------------------------------------------------------- ++ ++module Sound.OpenAL.AL.Errors ( ++ ALError(..), ALErrorCategory(..), alErrors ++) where ++ ++import Graphics.Rendering.OpenGL.GL.StateVar ( ++ GettableStateVar, makeGettableStateVar ) ++import Sound.OpenAL.AL.BasicTypes ( ALenum ) ++import Sound.OpenAL.Constants ( ++ al_NO_ERROR, al_INVALID_NAME, al_INVALID_ENUM, al_INVALID_VALUE, ++ al_INVALID_OPERATION, al_OUT_OF_MEMORY ) ++import Sound.OpenAL.AL.QueryUtils ( StringName(..), getString ) ++ ++-------------------------------------------------------------------------------- ++ ++-- | AL errors consist of a general error category and a description of what ++-- went wrong. ++ ++data ALError = ALError ALErrorCategory String ++ deriving ( Eq, Ord, Show ) ++ ++-------------------------------------------------------------------------------- ++ ++-- | General AL error categories. ++ ++data ALErrorCategory = ++ ALInvalidEnum ++ | ALInvalidValue ++ | ALInvalidOperation ++ | ALInvalidName ++ | ALOutOfMemory ++ deriving ( Eq, Ord, Show ) ++ ++unmarshalALErrorCategory :: ALenum -> ALErrorCategory ++unmarshalALErrorCategory x ++ | x == al_INVALID_ENUM = ALInvalidEnum ++ | x == al_INVALID_VALUE = ALInvalidValue ++ | x == al_INVALID_OPERATION = ALInvalidOperation ++ | x == al_INVALID_NAME = ALInvalidName ++ | x == al_OUT_OF_MEMORY = ALOutOfMemory ++ | otherwise = error ("unmarshalALErrorCategory: illegal value " ++ show x) ++ ++-------------------------------------------------------------------------------- ++ ++-- | OpenAL detects only a subset of those conditions that could be considered ++-- errors. This is because in many cases error checking would adversely impact ++-- the performance of an error-free program. The state variable 'alErrors' is ++-- used to obtain error information. When an error is detected by AL, a flag is ++-- set and the error code is recorded. Further errors, if they occur, do not ++-- affect this recorded code. When 'alErrors' is read, the error is returned and ++-- the flag is cleared, so that a further error will again record its code. If ++-- reading 'alErrors' returns @\[\]@ then there has been no detectable error ++-- since the last time 'alErrors' (or since the AL was initialized). ++-- ++-- When an error flag is set, results of AL operations are undefined only if ++-- 'ALOutOfMemory' has occurred. In other cases, the command generating the ++-- error is ignored so that it has no effect on AL state or output buffer ++-- contents. If the error generating command returns a value, it returns zero. ++-- If the generating command modifies values through a pointer argument, no ++-- change is made to these values. These error semantics apply only to AL ++-- errors, not to system errors such as memory access errors. ++ ++alErrors :: GettableStateVar [ALError] ++alErrors = ++ makeGettableStateVar $ do ++ c <- alGetError ++ if c == al_NO_ERROR ++ then return [] ++ else do ++ s <- getString (ALErrorCategory c) ++ return [ ALError (unmarshalALErrorCategory c) s ] ++ ++foreign import CALLCONV unsafe "alGetError" ++ alGetError :: IO ALenum +diff -uNr --exclude=autom4te.cache --exclude=.cvsignore hugs98-Mar2005-patched/fptools/libraries/OpenAL/Sound/OpenAL/AL/Extensions.hs ghc-6.4.2/libraries/OpenAL/Sound/OpenAL/AL/Extensions.hs +--- hugs98-Mar2005-patched/fptools/libraries/OpenAL/Sound/OpenAL/AL/Extensions.hs 1970-01-01 09:00:00.000000000 +0900 ++++ ghc-6.4.2/libraries/OpenAL/Sound/OpenAL/AL/Extensions.hs 2006-03-22 00:58:03.000000000 +0900 +@@ -0,0 +1,102 @@ ++-------------------------------------------------------------------------------- ++-- | ++-- Module : Sound.OpenAL.AL.Extensions ++-- Copyright : (c) Sven Panne 2003-2005 ++-- License : BSD-style (see the file libraries/OpenAL/LICENSE) ++-- ++-- Maintainer : sven.panne@aedion.de ++-- Stability : provisional ++-- Portability : portable ++-- ++-- This module corresponds to section 3.1.2 (String Queries) and chapter 7 ++-- (Appendix: Extensions) of the OpenAL Specification and Reference (version ++-- 1.1). ++-- ++-------------------------------------------------------------------------------- ++ ++module Sound.OpenAL.AL.Extensions ( ++ alExtensions, alIsExtensionPresent, alProcAddress, alEnumValue, alVersion ++) where ++ ++import Foreign.Ptr ( Ptr, FunPtr ) ++import Graphics.Rendering.OpenGL.GL.StateVar ( ++ GettableStateVar, makeGettableStateVar ) ++import Sound.OpenAL.AL.ALboolean ( unmarshalALboolean ) ++import Sound.OpenAL.AL.BasicTypes ( ALboolean, ALchar, ALenum ) ++import Sound.OpenAL.AL.QueryUtils ( StringName(..), getString ) ++import Sound.OpenAL.AL.String ( withALString ) ++ ++#ifdef __HADDOCK__ ++import Foreign.Ptr ( nullFunPtr ) ++#endif ++ ++-------------------------------------------------------------------------------- ++ ++-- | Contains the list of available extensions. ++ ++alExtensions :: GettableStateVar [String] ++alExtensions = makeGettableStateVar (fmap words $ getString Extensions) ++ ++-------------------------------------------------------------------------------- ++ ++-- | Contains a version string in the format @\"/\/./\/ /\/\"@. ++ ++alVersion :: GettableStateVar String ++alVersion = makeGettableStateVar (getString Version) ++ ++-------------------------------------------------------------------------------- ++ ++-- | To verify that a given extension is available for the current context, use ++-- 'alIsExtensionPresent'. For invalid and unsupported string tokens it contains ++-- 'False'. The extension name is not case sensitive: The implementation will ++-- convert the name to all upper-case internally (and will express extension ++-- names in upper-case). ++ ++alIsExtensionPresent :: String -> GettableStateVar Bool ++alIsExtensionPresent extensionName = ++ makeGettableStateVar $ ++ fmap unmarshalALboolean $ ++ withALString extensionName alIsExtensionPresent_ ++ ++foreign import CALLCONV unsafe "alIsExtensionPresent" ++ alIsExtensionPresent_ :: Ptr ALchar -> IO ALboolean ++ ++-------------------------------------------------------------------------------- ++ ++-- | To retrieving function entry addresses, applications can use ++-- 'alProcAddress'. It contains 'nullFunPtr' if no entry point with the given ++-- name can be found. Implementations are free to use 'nullFunPtr' if an ++-- entry point is present, but not applicable for the current context. However ++-- the specification does not guarantee this behavior. Applications can use ++-- 'alProcAddress' to obtain core API entry points, not just extensions. This ++-- is the recommended way to dynamically load and unload OpenAL DLLs as sound ++-- drivers. ++ ++alProcAddress :: String -> GettableStateVar (FunPtr a) ++alProcAddress funcName = makeGettableStateVar $ ++ withALString funcName alGetProcAddress ++ ++foreign import CALLCONV unsafe "alGetProcAddress" ++ alGetProcAddress :: Ptr ALchar -> IO (FunPtr a) ++ ++-------------------------------------------------------------------------------- ++ ++-- | To obtain enumeration values for extensions, the application has to use ++-- 'alEnumValue' of an extension token. Enumeration values are defined within ++-- the OpenAL name space and allocated according to specification of the core ++-- API and the extensions, thus they are context-independent. ++-- ++-- 'alEnumValue' contains 0 if the enumeration can not be found. The presence of ++-- an enum value does not guarantee the applicability of an extension to the ++-- current context. A non-zero value indicates merely that the implementation is ++-- aware of the existence of this extension. Implementations should not attempt ++-- to use 0 to indicate that the extensions is not supported for the current ++-- context. ++ ++alEnumValue :: String -> GettableStateVar ALenum ++alEnumValue enumName = makeGettableStateVar $ ++ withALString enumName alGetEnumValue ++ ++foreign import CALLCONV unsafe "alGetEnumValue" ++ alGetEnumValue :: Ptr ALchar -> IO ALenum +diff -uNr --exclude=autom4te.cache --exclude=.cvsignore hugs98-Mar2005-patched/fptools/libraries/OpenAL/Sound/OpenAL/AL/Format.hs ghc-6.4.2/libraries/OpenAL/Sound/OpenAL/AL/Format.hs +--- hugs98-Mar2005-patched/fptools/libraries/OpenAL/Sound/OpenAL/AL/Format.hs 2004-04-05 21:55:40.000000000 +0900 ++++ ghc-6.4.2/libraries/OpenAL/Sound/OpenAL/AL/Format.hs 2006-03-22 00:58:03.000000000 +0900 +@@ -2,13 +2,15 @@ + -------------------------------------------------------------------------------- + -- | + -- Module : Sound.OpenAL.AL.Format +--- Copyright : (c) Sven Panne 2003-2004 ++-- Copyright : (c) Sven Panne 2003-2005 + -- License : BSD-style (see the file libraries/OpenAL/LICENSE) + -- + -- Maintainer : sven.panne@aedion.de + -- Stability : provisional + -- Portability : portable + -- ++-- This is a purely internal module for (un-)marshaling Format. ++-- + -------------------------------------------------------------------------------- + + module Sound.OpenAL.AL.Format ( +@@ -16,49 +18,33 @@ + ) where + + import Sound.OpenAL.AL.BasicTypes ( ALenum ) ++import Sound.OpenAL.Constants ( ++ al_FORMAT_MONO8, al_FORMAT_MONO16, al_FORMAT_STEREO8, al_FORMAT_STEREO16 ) + + -------------------------------------------------------------------------------- + +-#include "HsOpenALConfig.h" +- +--------------------------------------------------------------------------------- ++-- | Valid sound formats. An implementation may expose other formats, see ++-- "Sound.OpenAL.ALC.Extensions" for information on determining if additional ++-- formats are supported. + + data Format = + Mono8 + | Mono16 + | Stereo8 + | Stereo16 +- | IMAADPCMMono16 +- | IMAADPCMStereo16 +- | Wave +- | Vorbis +- | Quad8 +- | Quad16 + deriving ( Eq, Ord, Show ) + + marshalFormat :: Format -> ALenum + marshalFormat x = case x of +- Mono8 -> 0x1100 +- Mono16 -> 0x1101 +- Stereo8 -> 0x1102 +- Stereo16 -> 0x1103 +- IMAADPCMMono16 -> 0x10000 +- IMAADPCMStereo16 -> 0x10001 +- Wave -> 0x10002 +- Vorbis -> CONST_AL_FORMAT_VORBIS_EXT +- Quad8 -> 0x10004 +- Quad16 -> 0x10005 ++ Mono8 -> al_FORMAT_MONO8 ++ Mono16 -> al_FORMAT_MONO16 ++ Stereo8 -> al_FORMAT_STEREO8 ++ Stereo16 -> al_FORMAT_STEREO16 + + unmarshalFormat :: ALenum -> Format + unmarshalFormat x +- | x == 0x1100 = Mono8 +- | x == 0x1101 = Mono16 +- | x == 0x1102 = Stereo8 +- | x == 0x1103 = Stereo16 +- | x == 0x10000 = IMAADPCMMono16 +- | x == 0x10001 = IMAADPCMStereo16 +- | x == 0x10002 = Wave +- | x == CONST_AL_FORMAT_VORBIS_EXT = Vorbis +- | x == 0x10004 = Quad8 +- | x == 0x10005 = Quad16 ++ | x == al_FORMAT_MONO8 = Mono8 ++ | x == al_FORMAT_MONO16 = Mono16 ++ | x == al_FORMAT_STEREO8 = Stereo8 ++ | x == al_FORMAT_STEREO16 = Stereo16 + | otherwise = error ("unmarshalFormat: illegal value " ++ show x) +diff -uNr --exclude=autom4te.cache --exclude=.cvsignore hugs98-Mar2005-patched/fptools/libraries/OpenAL/Sound/OpenAL/AL/Listener.hs ghc-6.4.2/libraries/OpenAL/Sound/OpenAL/AL/Listener.hs +--- hugs98-Mar2005-patched/fptools/libraries/OpenAL/Sound/OpenAL/AL/Listener.hs 2004-01-03 04:03:09.000000000 +0900 ++++ ghc-6.4.2/libraries/OpenAL/Sound/OpenAL/AL/Listener.hs 2006-03-22 00:58:03.000000000 +0900 +@@ -1,70 +1,112 @@ + -------------------------------------------------------------------------------- + -- | + -- Module : Sound.OpenAL.AL.Listener +--- Copyright : (c) Sven Panne 2003-2004 ++-- Copyright : (c) Sven Panne 2003-2005 + -- License : BSD-style (see the file libraries/OpenAL/LICENSE) + -- + -- Maintainer : sven.panne@aedion.de + -- Stability : provisional + -- Portability : portable + -- +--------------------------------------------------------------------------------- ++-- This module corresponds to sections 4.1 (Basic Listener and Source ++-- Attributes) and 4.2 (Listener Object) of the OpenAL Specification and ++-- Reference (version 1.1). ++-- ++-- The listener object defines various properties that affect processing of the ++-- sound for the actual output. The listener is unique for an OpenAL Context, ++-- and has no name. By controlling the listener, the application controls the ++-- way the user experiences the virtual world, as the listener defines the ++-- sampling\/pickup point and orientation, and other parameters that affect the ++-- output stream. ++-- ++-- It is entirely up to the driver and hardware configuration, i.e. the ++-- installation of OpenAL as part of the operating system and hardware setup, ++-- whether the output stream is generated for headphones or 2 speakers, 4.1 ++-- speakers, or other arrangements, whether (and which) HRTFs are applied, ++-- etc... ++-- ++--------------------------------------------------------------------------------- + + module Sound.OpenAL.AL.Listener ( +- listenerGain, listenerPosition, listenerVelocity, orientation ++ listenerPosition, listenerVelocity, Gain, listenerGain, orientation + ) where + +-import Foreign.Marshal.Alloc ( alloca ) + import Foreign.Marshal.Array ( allocaArray, withArray ) + import Foreign.Marshal.Utils ( with ) + import Foreign.Ptr ( Ptr ) ++import Foreign.Storable ( Storable ) + import Graphics.Rendering.OpenGL.GL.CoordTrans ( Vector3(..) ) + import Graphics.Rendering.OpenGL.GL.VertexSpec ( Vertex3(..) ) + import Graphics.Rendering.OpenGL.GL.StateVar ( StateVar, makeStateVar ) + import Sound.OpenAL.AL.BasicTypes ( ALenum, ALfloat ) + import Sound.OpenAL.AL.PeekPoke ( peek1, peek3, peek6 ) + import Sound.OpenAL.AL.QueryUtils ( +- GetPName(GetGain,GetPosition,GetVelocity,GetOrientation), marshalGetPName ) ++ GetPName(GetPosition,GetVelocity,GetGain,GetOrientation), marshalGetPName ) + + -------------------------------------------------------------------------------- + +-listenerGain :: StateVar ALfloat +-listenerGain = +- makeStateVar +- (do alloca $ \buf -> do +- getListenerfv GetGain buf +- peek1 id buf) +- (listenerf GetGain) +- +--------------------------------------------------------------------------------- ++-- | 'listenerPosition' contains the current location of the listener in the ++-- world coordinate system. Any 3-tuple of valid float values is allowed. ++-- Implementation behavior on encountering NaN and infinity is not defined. The ++-- initial position is ('Vertex3' 0 0 0). + + listenerPosition :: StateVar (Vertex3 ALfloat) +-listenerPosition = +- makeStateVar +- (do allocaArray 3 $ \buf -> do +- getListenerfv GetPosition buf +- peek3 Vertex3 buf) +- (\pos -> with pos $ listenerVertex3 GetPosition) ++listenerPosition = makeListenerVar GetPosition 3 (peek3 Vertex3) listener3f + + -------------------------------------------------------------------------------- + ++-- | 'listenerVelocity' contains current velocity (speed and direction) of the ++-- listener in the world coordinate system. Any 3-tuple of valid float ++-- values is allowed, and the initial velocity is ('Vector3' 0 0 0). ++-- 'listenerVelocity' does not affect 'listenerPosition'. OpenAL does not ++-- calculate the velocity from subsequent position updates, nor does it ++-- adjust the position over time based on the specified velocity. Any ++-- such calculation is left to the application. For the purposes of sound ++-- processing, position and velocity are independent parameters affecting ++-- different aspects of the sounds. ++-- ++-- 'listenerVelocity' is taken into account by the driver to synthesize the ++-- Doppler effect perceived by the listener for each source, based on the ++-- velocity of both source and listener, and the Doppler related parameters. ++ + listenerVelocity :: StateVar (Vector3 ALfloat) +-listenerVelocity = +- makeStateVar +- (do allocaArray 3 $ \buf -> do +- getListenerfv GetVelocity buf +- peek3 Vector3 buf) +- (\vel -> with vel $ listenerVector3 GetVelocity) ++listenerVelocity = makeListenerVar GetVelocity 3 (peek3 Vector3) listener3f ++ ++-------------------------------------------------------------------------------- ++ ++-- | A scalar amplitude multiplier. ++type Gain = ALfloat ++ ++-- | 'listenerGain' contains a scalar amplitude multiplier, which is effectively ++-- applied to all sources in the current context. The initial value 1 means ++-- that the sound is unattenuated. A 'listenerGain' value of 0.5 is equivalent ++-- to an attenuation of 6dB. The value zero equals silence (no output). Driver ++-- implementations are free to optimize this case and skip mixing and processing ++-- stages where applicable. The implementation is in charge of ensuring ++-- artifact-free (click-free) changes of gain values and is free to defer actual ++-- modification of the sound samples, within the limits of acceptable latencies. ++-- ++-- A 'listenerGain' larger than 1 (amplification) is permitted. However, the ++-- implementation is free to clamp the total gain (effective gain per source ++-- times listener gain) to 1 to prevent overflow. ++ ++listenerGain :: StateVar Gain ++listenerGain = makeListenerVar GetGain 1 (peek1 id) listenerf + + -------------------------------------------------------------------------------- + ++-- | 'orientation' contains an \"at\" vector and an \"up\" vector, where the ++-- \"at\" vector represents the \"forward\" direction of the listener and the ++-- orthogonal projection of the \"up\" vector into the subspace perpendicular to ++-- the \"at\" vector represents the \"up\" direction for the listener. OpenAL ++-- expects two vectors that are linearly independent. These vectors are not ++-- expected to be normalized. If the two vectors are linearly dependent, ++-- behavior is undefined. The initial orientation is ('Vector3' 0 0 (-1), ++-- 'Vector3' 0 1 0), i.e. looking down the Z axis with the Y axis pointing ++-- upwards. ++ + orientation :: StateVar (Vector3 ALfloat, Vector3 ALfloat) +-orientation = +- makeStateVar +- (do allocaArray 6 $ \buf -> do +- getListenerfv GetOrientation buf +- peek6 Vector3 buf) +- (\(at, up) -> withArray [at, up] $ listenerVector3 GetOrientation) ++orientation = makeListenerVar GetOrientation 6 (peek6 Vector3) listenerVector6 + + -------------------------------------------------------------------------------- + +@@ -74,31 +116,35 @@ + foreign import CALLCONV unsafe "alListenerf" + alListenerf :: ALenum -> ALfloat -> IO () + +-listenerVertex3 :: GetPName -> Ptr (Vertex3 ALfloat) -> IO () +-listenerVertex3 = alListenerfv . marshalGetPName ++-------------------------------------------------------------------------------- ++ ++listener3f :: Storable a => GetPName -> a -> IO () ++listener3f n x = with x $ listenerfv n + +-listenerVector3 :: GetPName -> Ptr (Vector3 ALfloat) -> IO () +-listenerVector3 = alListenerfv . marshalGetPName ++listenerVector6 :: GetPName -> (Vector3 ALfloat, Vector3 ALfloat) -> IO () ++listenerVector6 n (x, y) = withArray [x, y] $ listenerfv n ++ ++listenerfv :: GetPName -> Ptr a -> IO () ++listenerfv = alListenerfv . marshalGetPName + + foreign import CALLCONV unsafe "alListenerfv" + alListenerfv :: ALenum -> Ptr a -> IO () + ++-------------------------------------------------------------------------------- ++ + getListenerfv :: GetPName -> Ptr ALfloat -> IO () + getListenerfv = alGetListenerfv . marshalGetPName + + foreign import CALLCONV unsafe "alGetListenerfv" + alGetListenerfv :: ALenum -> Ptr ALfloat -> IO () + +-{- +-listenerf: +-AL_GAIN_LINEAR_LOKI +-AL_GAIN +- +-listenerfv: +-AL_POSITION +-AL_VELOCITY +-AL_ORIENTATION (6: at + up) +- +-getlistenerfv: +-all above +--} ++-------------------------------------------------------------------------------- ++ ++makeListenerVar :: GetPName -> Int -> (Ptr ALfloat -> IO a) ++ -> (GetPName -> a -> IO ()) -> StateVar a ++makeListenerVar pname size reader writer = ++ makeStateVar ++ (allocaArray size $ \buf -> do ++ getListenerfv pname buf ++ reader buf) ++ (writer pname) +diff -uNr --exclude=autom4te.cache --exclude=.cvsignore hugs98-Mar2005-patched/fptools/libraries/OpenAL/Sound/OpenAL/AL/PeekPoke.hs ghc-6.4.2/libraries/OpenAL/Sound/OpenAL/AL/PeekPoke.hs +--- hugs98-Mar2005-patched/fptools/libraries/OpenAL/Sound/OpenAL/AL/PeekPoke.hs 2004-01-03 04:03:09.000000000 +0900 ++++ ghc-6.4.2/libraries/OpenAL/Sound/OpenAL/AL/PeekPoke.hs 2006-03-22 00:58:03.000000000 +0900 +@@ -2,7 +2,7 @@ + -------------------------------------------------------------------------------- + -- | + -- Module : Sound.OpenAL.AL.PeekPoke +--- Copyright : (c) Sven Panne 2003-2004 ++-- Copyright : (c) Sven Panne 2003-2005 + -- License : BSD-style (see the file libraries/OpenGL/LICENSE) + -- + -- Maintainer : sven.panne@aedion.de +@@ -14,8 +14,7 @@ + -------------------------------------------------------------------------------- + + module Sound.OpenAL.AL.PeekPoke ( +- poke1, poke3, poke6, +- peek1, peek3, peek6 ++ poke1, peek1, peek3, peek6 + ) where + + import Foreign.Ptr ( Ptr ) +@@ -32,23 +31,6 @@ + poke1 ptr x = + pokeElemOff ptr 0 x + +-{-# INLINE poke3 #-} +-poke3 :: Storable a => Ptr a -> a -> a -> a -> IO () +-poke3 ptr x y z = do +- pokeElemOff ptr 0 x +- pokeElemOff ptr 1 y +- pokeElemOff ptr 2 z +- +-{-# INLINE poke6 #-} +-poke6 :: Storable a => Ptr a -> (a, a, a) -> (a, a, a) -> IO () +-poke6 ptr (x, y, z) (u, v, w) = do +- pokeElemOff ptr 0 x +- pokeElemOff ptr 1 y +- pokeElemOff ptr 2 z +- pokeElemOff ptr 3 u +- pokeElemOff ptr 4 v +- pokeElemOff ptr 5 w +- + -------------------------------------------------------------------------------- + + {-# INLINE peek1 #-} +diff -uNr --exclude=autom4te.cache --exclude=.cvsignore hugs98-Mar2005-patched/fptools/libraries/OpenAL/Sound/OpenAL/AL/QueryUtils.hs ghc-6.4.2/libraries/OpenAL/Sound/OpenAL/AL/QueryUtils.hs +--- hugs98-Mar2005-patched/fptools/libraries/OpenAL/Sound/OpenAL/AL/QueryUtils.hs 2004-01-03 04:03:09.000000000 +0900 ++++ ghc-6.4.2/libraries/OpenAL/Sound/OpenAL/AL/QueryUtils.hs 2006-03-22 00:58:03.000000000 +0900 +@@ -2,7 +2,7 @@ + -------------------------------------------------------------------------------- + -- | + -- Module : Sound.OpenAL.AL.QueryUtils +--- Copyright : (c) Sven Panne 2003-2004 ++-- Copyright : (c) Sven Panne 2003-2005 + -- License : BSD-style (see the file libraries/OpenGL/LICENSE) + -- + -- Maintainer : sven.panne@aedion.de +@@ -15,124 +15,108 @@ + + module Sound.OpenAL.AL.QueryUtils ( + GetPName(..), marshalGetPName, +- getFloat1, getFloat3, getFloat6 ++ StringName(..), getString + ) where + +-import Control.Monad ( liftM ) +-import Foreign.Marshal.Array ( allocaArray ) + import Foreign.Ptr ( Ptr ) +-import Sound.OpenAL.AL.BasicTypes ( ALenum, ALfloat ) +-import Sound.OpenAL.AL.PeekPoke ( peek3, peek6 ) ++import Sound.OpenAL.AL.BasicTypes ( ALchar, ALenum ) ++import Sound.OpenAL.AL.String ( peekALString ) ++import Sound.OpenAL.Constants ( ++ al_DISTANCE_MODEL, al_DOPPLER_FACTOR, al_SPEED_OF_SOUND, al_POSITION, ++ al_VELOCITY, al_GAIN, al_ORIENTATION, al_SOURCE_RELATIVE, al_SOURCE_TYPE, ++ al_LOOPING, al_BUFFER, al_BUFFERS_QUEUED, al_BUFFERS_PROCESSED, al_MIN_GAIN, ++ al_MAX_GAIN, al_REFERENCE_DISTANCE, al_ROLLOFF_FACTOR, al_MAX_DISTANCE, ++ al_PITCH, al_DIRECTION, al_CONE_INNER_ANGLE, al_CONE_OUTER_ANGLE, ++ al_CONE_OUTER_GAIN, al_SEC_OFFSET, al_SAMPLE_OFFSET, al_BYTE_OFFSET, ++ al_SOURCE_STATE, al_VENDOR, al_RENDERER, al_VERSION, al_EXTENSIONS ) + + -------------------------------------------------------------------------------- + + data GetPName = +- GetSourceType +- | GetSourceRelative +- | GetConeInnerAngle +- | GetConeOuterAngle +- | GetPitch ++ GetDistanceModel ++ | GetDopplerFactor ++ | GetSpeedOfSound ++ + | GetPosition +- | GetDirection ++ + | GetVelocity +- | GetLooping +- | GetStreaming +- | GetBuffer + | GetGain +- | GetByte +- | GetMinGain +- | GetMaxGain ++ + | GetOrientation +- | GetSourceState ++ ++ | GetSourceRelative ++ | GetSourceType ++ | GetLooping ++ | GetBuffer + | GetBuffersQueued + | GetBuffersProcessed +- | GetPending +- | GetProcessed ++ | GetMinGain ++ | GetMaxGain + | GetReferenceDistance + | GetRolloffFactor +- | GetConeOuterGain + | GetMaxDistance +- | GetFrequency +- | GetBits +- | GetChannels +- | GetSize +- | GetVendor +- | GetVersion +- | GetRenderer +- | GetExtensions +- | GetDopplerFactor +- | GetDopplerVelocity +- | GetDistanceScale +- | GetDistanceModel +- | GetInverseDistance +- | GetInverseDistanceClamped ++ | GetPitch ++ | GetDirection ++ | GetConeInnerAngle ++ | GetConeOuterAngle ++ | GetConeOuterGain ++ | GetSecOffset ++ | GetSampleOffset ++ | GetByteOffset ++ | GetSourceState + + marshalGetPName :: GetPName -> ALenum + marshalGetPName x = case x of +- GetSourceType -> 0x0200 +- GetSourceRelative -> 0x0202 +- GetConeInnerAngle -> 0x1001 +- GetConeOuterAngle -> 0x1002 +- GetPitch -> 0x1003 +- GetPosition -> 0x1004 +- GetDirection -> 0x1005 +- GetVelocity -> 0x1006 +- GetLooping -> 0x1007 +- GetStreaming -> 0x1008 +- GetBuffer -> 0x1009 +- GetGain -> 0x100A +- GetByte -> 0x100C +- GetMinGain -> 0x100D +- GetMaxGain -> 0x100E +- GetOrientation -> 0x100F +- GetSourceState -> 0x1010 +- GetBuffersQueued -> 0x1015 +- GetBuffersProcessed -> 0x1016 +- GetPending -> 0x1017 +- GetProcessed -> 0x1018 +- GetReferenceDistance -> 0x1020 +- GetRolloffFactor -> 0x1021 +- GetConeOuterGain -> 0x1022 +- GetMaxDistance -> 0x1023 +- GetFrequency -> 0x2001 +- GetBits -> 0x2002 +- GetChannels -> 0x2003 +- GetSize -> 0x2004 +- GetVendor -> 0xB001 +- GetVersion -> 0xB002 +- GetRenderer -> 0xB003 +- GetExtensions -> 0xB004 +- GetDopplerFactor -> 0xC000 +- GetDopplerVelocity -> 0xC001 +- GetDistanceScale -> 0xC002 +- GetDistanceModel -> 0xD000 +- GetInverseDistance -> 0xD001 +- GetInverseDistanceClamped -> 0xD002 ++ GetDistanceModel -> al_DISTANCE_MODEL ++ GetDopplerFactor -> al_DOPPLER_FACTOR ++ GetSpeedOfSound -> al_SPEED_OF_SOUND ++ ++ GetPosition -> al_POSITION ++ GetVelocity -> al_VELOCITY ++ GetGain -> al_GAIN ++ ++ GetOrientation -> al_ORIENTATION ++ ++ GetSourceRelative -> al_SOURCE_RELATIVE ++ GetSourceType -> al_SOURCE_TYPE ++ GetLooping -> al_LOOPING ++ GetBuffer -> al_BUFFER ++ GetBuffersQueued -> al_BUFFERS_QUEUED ++ GetBuffersProcessed -> al_BUFFERS_PROCESSED ++ GetMinGain -> al_MIN_GAIN ++ GetMaxGain -> al_MAX_GAIN ++ GetReferenceDistance -> al_REFERENCE_DISTANCE ++ GetRolloffFactor -> al_ROLLOFF_FACTOR ++ GetMaxDistance -> al_MAX_DISTANCE ++ GetPitch -> al_PITCH ++ GetDirection -> al_DIRECTION ++ GetConeInnerAngle -> al_CONE_INNER_ANGLE ++ GetConeOuterAngle -> al_CONE_OUTER_ANGLE ++ GetConeOuterGain -> al_CONE_OUTER_GAIN ++ GetSecOffset -> al_SEC_OFFSET ++ GetSampleOffset -> al_SAMPLE_OFFSET ++ GetByteOffset -> al_BYTE_OFFSET ++ GetSourceState -> al_SOURCE_STATE + + -------------------------------------------------------------------------------- + +--- Note: OpenAL is not yet orthogonal enough to use getFloatv here, too. +- +-getFloat1 :: (ALfloat -> a) -> GetPName -> IO a +-getFloat1 f = liftM f . alGetFloat . marshalGetPName +- +-foreign import CALLCONV unsafe "alGetFloat" +- alGetFloat :: ALenum -> IO ALfloat +- +-getFloat3 :: (ALfloat -> ALfloat -> ALfloat -> a) -> GetPName -> IO a +-getFloat3 f n = allocaArray 3 $ \buf -> do +- getFloatv n buf +- peek3 f buf +- +-getFloat6 :: +- (ALfloat -> ALfloat -> ALfloat -> a) +- -> GetPName -> IO (a, a) +-getFloat6 f n = allocaArray 6 $ \buf -> do +- getFloatv n buf +- peek6 f buf ++data StringName = ++ Vendor ++ | Renderer ++ | Version ++ | Extensions ++ | ALErrorCategory ALenum ++ ++marshalStringName :: StringName -> ALenum ++marshalStringName x = case x of ++ Vendor -> al_VENDOR ++ Renderer -> al_RENDERER ++ Version -> al_VERSION ++ Extensions -> al_EXTENSIONS ++ ALErrorCategory e -> e + +-getFloatv :: GetPName -> Ptr ALfloat -> IO () +-getFloatv = alGetFloatv . marshalGetPName ++getString :: StringName -> IO String ++getString n = alGetString (marshalStringName n) >>= peekALString + +-foreign import CALLCONV unsafe "alGetFloatv" +- alGetFloatv :: ALenum -> Ptr ALfloat -> IO () ++foreign import CALLCONV unsafe "alGetString" ++ alGetString :: ALenum -> IO (Ptr ALchar) +diff -uNr --exclude=autom4te.cache --exclude=.cvsignore hugs98-Mar2005-patched/fptools/libraries/OpenAL/Sound/OpenAL/AL/Source.hs ghc-6.4.2/libraries/OpenAL/Sound/OpenAL/AL/Source.hs +--- hugs98-Mar2005-patched/fptools/libraries/OpenAL/Sound/OpenAL/AL/Source.hs 2004-03-30 16:07:15.000000000 +0900 ++++ ghc-6.4.2/libraries/OpenAL/Sound/OpenAL/AL/Source.hs 2006-03-22 00:58:03.000000000 +0900 +@@ -1,119 +1,775 @@ + -------------------------------------------------------------------------------- + -- | + -- Module : Sound.OpenAL.AL.Source +--- Copyright : (c) Sven Panne 2003-2004 ++-- Copyright : (c) Sven Panne 2003-2005 + -- License : BSD-style (see the file libraries/OpenAL/LICENSE) + -- + -- Maintainer : sven.panne@aedion.de + -- Stability : provisional + -- Portability : portable + -- ++-- This module corresponds to sections 4.1 (Basic Listener and Source ++-- Attributes) and 4.3 (Source Objects) of the OpenAL Specification and ++-- Reference (version 1.1). ++-- ++-- Sources specify attributes like position, velocity, and a buffer with sample ++-- data. By controlling a source\'s attributes the application can modify and ++-- parameterize the static sample data provided by the buffer referenced by the ++-- source. Sources define a localized sound, and encapsulate a set of attributes ++-- applied to a sound at its origin, i.e. in the very first stage of the ++-- processing on the way to the listener. Source related effects have to be ++-- applied before listener related effects unless the output is invariant to any ++-- collapse or reversal of order. OpenAL also provides additional functions to ++-- manipulate and query the execution state of sources: the current playing ++-- status of a source, including access to the current sampling position within ++-- the associated buffer. ++-- + -------------------------------------------------------------------------------- + + module Sound.OpenAL.AL.Source ( +- Source ++ -- * The Source Type ++ Source, ++ ++ -- * Source Attributes ++ ++ -- ** Basic Source Attributes ++ sourcePosition, sourceVelocity, sourceGain, ++ ++ -- ** Source Positioning ++ SourceRelative(..), sourceRelative, ++ ++ -- ** Source Type ++ SourceType(..), sourceType, ++ ++ -- ** Buffer Looping ++ LoopingMode(..), loopingMode, ++ ++ -- ** Current Buffer ++ buffer, ++ ++ -- ** Queue State Queries ++ buffersQueued, buffersProcessed, ++ ++ -- ** Bounds on Gain ++ gainBounds, ++ ++ -- ** Distance Model Attributes ++ referenceDistance, rolloffFactor, maxDistance, ++ ++ -- ** Frequency Shift by Pitch ++ pitch, ++ ++ -- ** Direction and Cone ++ -- $DirectionAndCone ++ direction, coneAngles, coneOuterGain, ++ ++ -- ** Offset ++ secOffset, sampleOffset, byteOffset, ++ ++ -- * Queuing Buffers with a Source ++ -- $QueuingBuffersWithASource ++ queueBuffers, unqueueBuffers, ++ ++ -- * Managing Source Execution ++ -- $ManagingSourceExecution ++ SourceState(..), sourceState, play, pause, stop, rewind + ) where + +-import Control.Monad ( liftM ) ++import Control.Monad ( liftM2 ) + import Foreign.Marshal.Array ( withArrayLen, peekArray, allocaArray ) +-import Foreign.Ptr ( Ptr ) ++import Foreign.Marshal.Utils ( with ) ++import Foreign.Ptr ( Ptr, castPtr ) ++import Foreign.Storable ( Storable(..) ) + import Graphics.Rendering.OpenGL.GL.BufferObjects ( ObjectName(..) ) ++import Graphics.Rendering.OpenGL.GL.CoordTrans ( Vector3(..) ) ++import Graphics.Rendering.OpenGL.GL.VertexSpec ( Vertex3(..) ) ++import Graphics.Rendering.OpenGL.GL.StateVar ( ++ HasGetter(get), HasSetter(($=)), makeStateVar, StateVar, GettableStateVar, ++ makeGettableStateVar ) ++import Sound.OpenAL.AL.ALboolean ( marshalALboolean, unmarshalALboolean ) + import Sound.OpenAL.AL.BasicTypes +-import Sound.OpenAL.AL.ALboolean ( unmarshalALboolean ) ++import Sound.OpenAL.AL.Buffer ( Buffer ) ++import Sound.OpenAL.AL.BufferInternal ( marshalBuffer, unmarshalBuffer ) ++import Sound.OpenAL.AL.Listener ( Gain ) ++import Sound.OpenAL.AL.PeekPoke ( peek1, poke1, peek3 ) ++import Sound.OpenAL.AL.SourceState ( SourceState(..), unmarshalSourceState ) ++import Sound.OpenAL.AL.QueryUtils ( ++ GetPName(GetPosition,GetVelocity,GetGain,GetSourceRelative,GetSourceType, ++ GetLooping,GetBuffer,GetBuffersQueued,GetBuffersProcessed, ++ GetMinGain,GetMaxGain,GetReferenceDistance,GetRolloffFactor, ++ GetMaxDistance,GetPitch,GetDirection,GetConeInnerAngle, ++ GetConeOuterAngle,GetConeOuterGain,GetSecOffset,GetSampleOffset, ++ GetByteOffset,GetSourceState), ++ marshalGetPName ) ++import Sound.OpenAL.Constants ( al_UNDETERMINED, al_STATIC, al_STREAMING ) ++ ++#ifdef __HADDOCK__ ++import Sound.OpenAL.AL.Listener ( listenerGain ) ++import Sound.OpenAL.AL.Errors ( ALErrorCategory(..) ) ++#endif + + -------------------------------------------------------------------------------- + +-newtype Source = Source { sourceID :: ALuint } ++-- | The abstract buffer type. ++ ++newtype Source = Source ALuint + deriving ( Eq, Ord, Show ) + ++instance Storable Source where ++ sizeOf ~(Source b) = sizeOf b ++ alignment ~(Source b) = alignment b ++ peek = peek1 Source . castPtr ++ poke ptr (Source b) = poke1 (castPtr ptr) b ++ + instance ObjectName Source where + genObjectNames n = + allocaArray n $ \buf -> do + alGenSources (fromIntegral n) buf +- liftM (map Source) $ peekArray n buf ++ peekArray n buf + +- deleteObjectNames sources = +- withArrayLen (map sourceID sources) $ +- alDeleteSources . fromIntegral ++ deleteObjectNames = withArraySizei alDeleteSources + +- isObjectName = liftM unmarshalALboolean . alIsSource . sourceID ++ isObjectName = fmap unmarshalALboolean . alIsSource + + foreign import CALLCONV unsafe "alGenSources" +- alGenSources :: ALsizei -> Ptr ALuint -> IO () ++ alGenSources :: ALsizei -> Ptr Source -> IO () + + foreign import CALLCONV unsafe "alDeleteSources" +- alDeleteSources :: ALsizei -> Ptr ALuint -> IO () ++ alDeleteSources :: ALsizei -> Ptr Source -> IO () + + foreign import CALLCONV unsafe "alIsSource" +- alIsSource :: ALuint -> IO ALboolean ++ alIsSource :: Source -> IO ALboolean ++ ++-------------------------------------------------------------------------------- ++ ++-- | 'sourcePosition' contains the current location of the source in the world ++-- coordinate system. Any 3-tuple of valid float values is allowed. ++-- Implementation behavior on encountering NaN and infinity is not defined. The ++-- initial position is ('Vertex3' 0 0 0). ++ ++sourcePosition :: Source -> StateVar (Vertex3 ALfloat) ++sourcePosition = makeSourceStateVar dictVertex3ALfloat GetPosition ++ ++-- | 'sourceVelocity' contains current velocity (speed and direction) of the ++-- source in the world coordinate system. Any 3-tuple of valid float values is ++-- allowed, and the initial velocity is ('Vector3' 0 0 0). 'sourceVelocity' does ++-- not affect 'sourcePosition'. OpenAL does not calculate the velocity from ++-- subsequent position updates, nor does it adjust the position over time based ++-- on the specified velocity. Any such calculation is left to the application. ++-- For the purposes of sound processing, position and velocity are independent ++-- parameters affecting different aspects of the sounds. ++-- ++-- 'sourceVelocity' is taken into account by the driver to synthesize the ++-- Doppler effect perceived by the listener for each source, based on the ++-- velocity of both source and listener, and the Doppler related parameters. ++ ++sourceVelocity :: Source -> StateVar (Vector3 ALfloat) ++sourceVelocity = makeSourceStateVar dictVector3ALfloat GetVelocity ++ ++-- | 'sourceGain' contains a scalar amplitude multiplier for the given source. ++-- The initial value 1 means that the sound is unattenuated. A 'sourceGain' ++-- value of 0.5 is equivalent to an attenuation of 6dB. The value zero equals ++-- silence (no output). Driver implementations are free to optimize this case ++-- and skip mixing and processing stages where applicable. The implementation is ++-- in charge of ensuring artifact-free (click-free) changes of gain values and ++-- is free to defer actual modification of the sound samples, within the limits ++-- of acceptable latencies. ++-- ++-- A 'sourceGain' larger than 1 (amplification) is permitted. However, the ++-- implementation is free to clamp the total gain (effective gain per source ++-- times listener gain) to 1 to prevent overflow. ++ ++sourceGain :: Source -> StateVar Gain ++sourceGain = makeSourceStateVar dictALfloat GetGain ++ ++-------------------------------------------------------------------------------- ++ ++-- | The entity to which the source attributes 'sourcePosition', ++-- 'sourceVelocity' and 'direction' are to be interpreted. ++ ++data SourceRelative = ++ World ++ | Listener ++ deriving ( Eq, Ord, Show ) ++ ++marshalSourceRelative :: SourceRelative -> Bool ++marshalSourceRelative = (== Listener) ++ ++unmarshalSourceRelative :: Bool -> SourceRelative ++unmarshalSourceRelative x = if x then Listener else World ++ ++-- | If 'sourceRelative' contains 'Listener', it indicates indicates that the ++-- values specified by 'sourcePosition', 'sourceVelocity' and 'direction' are to ++-- be interpreted relative to the listener position. The initial value is ++-- 'World', indicating that those source attributes are to be interpreted ++-- relative to the world, i.e. they are considered absolute. + ++sourceRelative :: Source -> StateVar SourceRelative ++sourceRelative = makeSourceStateVar dictSourceRelative GetSourceRelative ++ ++-------------------------------------------------------------------------------- ++ ++-- | When first created, a source will be in the 'Undetermined' state. If a ++-- buffer is then attached using 'buffer', then the source will enter the ++-- 'Static' state. If the first buffer attached to a source is attached using ++-- 'queueBuffers', then the source will enter the 'Streaming' state. A source of ++-- either state will be reset to state 'Undetermined' by setting its 'buffer' to ++-- 'Nothing', and attaching any buffer to a streaming source will change the ++-- state to 'Static'. Attempting to queue a buffer on a static source will ++-- result in an 'ALInvalidOperation' error. ++ ++data SourceType = ++ Undetermined ++ | Static ++ | Streaming ++ deriving ( Eq, Ord, Show ) ++ ++unmarshalSourceType :: ALint -> SourceType ++unmarshalSourceType x ++ | x == al_UNDETERMINED = Undetermined ++ | x == al_STATIC = Static ++ | x == al_STREAMING = Streaming ++ | otherwise = error ("unmarshalSourceType: illegal value " ++ show x) ++ ++-- | 'sourceType' indicates whether a source is ready to queue buffers, ready to ++-- use a static buffer, or is in an undetermined state where it can be used for ++-- either streaming or static playback. ++ ++sourceType :: Source -> GettableStateVar SourceType ++sourceType = makeSourceGettableStateVar dictSourceType GetSourceType ++ ++-------------------------------------------------------------------------------- ++ ++-- | Specifies what should happen when the end of a buffer queue is reached. ++ ++data LoopingMode = ++ OneShot ++ | Looping ++ deriving ( Eq, Ord, Show ) ++ ++marshalLoopingMode :: LoopingMode -> Bool ++marshalLoopingMode = (== Looping) ++ ++unmarshalLoopingMode :: Bool -> LoopingMode ++unmarshalLoopingMode x = if x then Looping else OneShot ++ ++-- | If 'loopingMode' contains 'Looping', it indicates that the source will not ++-- be in the 'Stopped' state once it reaches the end of last buffer in the ++-- buffer queue. Instead, the source will immediately promote to 'Initial' and ++-- 'Playing'. The initial value is 'OneShot'. 'loopingMode' can be changed on a ++-- source in any execution state. In particular, it can be changed on a ++-- 'Playing' source. ++ ++loopingMode :: Source -> StateVar LoopingMode ++loopingMode = makeSourceStateVar dictLoopingMode GetLooping ++ ++-------------------------------------------------------------------------------- ++ ++-- | 'buffer' contains the current buffer object. Setting 'buffer' to 'Just' a ++-- buffer object makes it the head entry in the source\'s queue. Setting ++-- 'buffer'for a source in the 'Stopped' or 'Initial' state empties the entire ++-- queue, then appends the one buffer specified (or none at all if 'Nothing' ++-- was specified). ++-- ++-- For a source in the 'Playing' or 'Paused' state, setting 'buffer' will result ++-- in the 'ALInvalidOperation' error state being set. 'buffer' can be applied only ++-- to sources in the 'Initial' and 'Stopped' states. Specifying an invalid ++-- buffer name (either because the buffer name doesn\'t exist or because that ++-- buffer can\'t be attached to the specified source) will result in an ++-- 'ALInvalidValue' error while specifying an invalid source name results in an ++-- 'ALInvalidName' error. Setting 'buffer' to 'Nothing' is a legal way to release ++-- the current buffer queue on a source in the 'Initial' or 'Stopped' state, ++-- whether the source has just one entry (current buffer) or more. Setting ++-- 'buffer' to 'Nothing' still causes an 'ALInvalidOperation' for any source in ++-- the 'Playing' or 'Paused' state, consequently it cannot be used to mute or ++-- stop a source. The initial value is 'Nothing'. ++ ++buffer :: Source -> StateVar (Maybe Buffer) ++buffer = makeSourceStateVar dictMaybeBuffer GetBuffer ++ ++-------------------------------------------------------------------------------- ++ ++-- | 'buffersQueued' contains the number of buffers in the queue of a given ++-- source. This includes those not yet played, the one currently playing, and ++-- the ones that have been played already. It will contain 0 if 'buffer' has ++-- been set to 'Nothing'. ++ ++buffersQueued :: Source -> GettableStateVar ALint ++buffersQueued = makeSourceGettableStateVar dictALint GetBuffersQueued ++ ++-- | 'buffersProcessed' contains the number of buffers that have been played ++-- by a given source. Indirectly, this gives the index of the buffer currently ++-- playing. It can be used to determine how much slots are needed for unqueuing ++-- them. On a source in the 'Stopped' state, all buffers are processed. On a ++-- source in the 'Initial' state, no buffers are processed, all buffers are ++-- pending. It will contain 0 if 'buffer' has been set to 'Nothing'. ++ ++buffersProcessed :: Source -> GettableStateVar ALint ++buffersProcessed = makeSourceGettableStateVar dictALint GetBuffersProcessed ++ ++-------------------------------------------------------------------------------- ++ ++-- | 'gainBounds' contains two scalar amplitude thresholds between 0 and 1 ++-- (included): The minimum guaranteed gain for this source and the maximum gain ++-- permitted, with initial values 0 and 1, respectively At the end of the ++-- processing of various attenuation factors such as distance based attenuation ++-- and 'sourceGain', the effective gain calculated is compared to these values: ++-- ++-- If the effective gain is lower than the minimum gain, the minimum gain is ++-- applied. This happens before the 'listenerGain' is applied. If a zero minimum ++-- gain is set, then the effective gain will not be corrected. ++-- ++-- If the effective gain is higher than the maximum gain, the maximum gain is ++-- applied. This happens before the 'listenerGain' is applied. If the ++-- 'listenerGain' times the maximum gain still exceeds the maximum gain the ++-- implementation can handle, the implementation is free to clamp. If a zero ++-- maximum gain is set, then the source is effectively muted. The implementation ++-- is free to optimize for this situation, but no optimization is required or ++-- recommended as setting 'sourceGain' to zero is the proper way to mute a ++-- source. ++ ++gainBounds :: Source -> StateVar (Gain, Gain) ++gainBounds source = ++ pairStateVars ++ (makeSourceStateVar dictALfloat GetMinGain source) ++ (makeSourceStateVar dictALfloat GetMaxGain source) ++ ++-------------------------------------------------------------------------------- + ++-- | 'referenceDistance' is used for distance attenuation calculations based on ++-- inverse distance with rolloff. Depending on the distance model it will also ++-- act as a distance threshold below which gain is clamped. See ++-- "Sound.OpenAL.AL.Attenuation" for details. The initial value is 1. ++ ++referenceDistance :: Source -> StateVar ALfloat ++referenceDistance = makeSourceStateVar dictALfloat GetReferenceDistance ++ ++-- | 'rolloffFactor' is used for distance attenuation calculations based on ++-- inverse distance with rolloff. For distances smaller than 'maxDistance' (and, ++-- depending on the distance model, larger than 'referenceDistance'), this will ++-- scale the distance attenuation over the applicable range. See ++-- "Sound.OpenAL.AL.Attenuation" for details how the attenuation is computed as ++-- a function of the distance. The initial value is 1. ++-- ++-- In particular, 'rolloffFactor' can be set to zero for those sources that are ++-- supposed to be exempt from distance attenuation. The implementation is ++-- encouraged to optimize this case, bypassing distance attenuation calculation ++-- entirely on a persource basis. ++ ++rolloffFactor :: Source -> StateVar ALfloat ++rolloffFactor = makeSourceStateVar dictALfloat GetRolloffFactor ++ ++-- | 'maxDistance' is used for distance attenuation calculations based on ++-- inverse distance with rolloff, if the inverse clamped distance model is ++-- used. In this case, distances greater than 'maxDistance' will be clamped to ++-- 'maxDistance'. 'maxDistance' based clamping is applied before minimum gain ++-- clamping (see 'gainBounds'), so if the effective gain at 'maxDistance' is ++-- larger than the minimum gain, the minimum gain will have no effect. No ++-- culling is supported. The initial value is the largest representable ++-- 'ALfloat'. ++ ++maxDistance :: Source -> StateVar ALfloat ++maxDistance = makeSourceStateVar dictALfloat GetMaxDistance ++ ++-------------------------------------------------------------------------------- ++ ++-- | 'pitch' contains the desired pitch shift, where 1 (the initial value) ++-- equals identity. Each reduction by 50 percent equals a pitch shift of -12 ++-- semitones (one octave reduction). Each doubling equals a pitch shift of 12 ++-- semitones (one octave increase). Zero is not a legal value. Implementations ++-- may clamp the actual output pitch range to any values subject to the ++-- implementation's own limits. ++ ++pitch :: Source -> StateVar ALfloat ++pitch = makeSourceStateVar dictALfloat GetPitch ++ ++-------------------------------------------------------------------------------- ++-- $DirectionAndCone ++-- Each source can be directional, depending on the settings for 'coneAngles'. ++-- There are three zones defined: the inner cone, the outside zone, and the ++-- transitional zone in between. The angle-dependent gain for a directional ++-- source is constant inside the inner cone, and changes over the transitional ++-- zone to the value specified outside the outer cone. 'sourceGain' is applied ++-- for the inner cone, with an application selectable 'coneOuterGain' factor to ++-- define the gain in the outer zone. In the transitional zone ++-- implementation-dependent interpolation between 'sourceGain' and 'sourceGain' ++-- times 'coneOuterGain' is applied. ++ ++-------------------------------------------------------------------------------- ++ ++-- | If 'direction' does not contain the zero vector ('Vector3' 0 0 0), the ++-- source is directional. The sound emission is presumed to be symmetric around ++-- the direction vector (cylinder symmetry). Sources are not oriented in full 3 ++-- degrees of freedom, only two angles are effectively needed. ++-- ++-- The zero vector is the initial value, indicating that a source is not ++-- directional. Specifying a non-zero vector will make the source directional. ++-- Specifying a zero vector for a directional source will effectively mark it as ++-- nondirectional. ++ ++direction :: Source -> StateVar (Vector3 ALfloat) ++direction = makeSourceStateVar dictVector3ALfloat GetDirection ++ ++-- | 'coneAngles' contains the inner and outer angles of the sound cone, in ++-- degrees. The default of 360 for the inner cone angle means that it covers the ++-- entire world, which is equivalent to an omni-directional source. The default ++-- of 360 for the outer cone angle means that it covers the entire world. If the ++-- inner angle is also 360, then the zone for angle-dependent attenuation is ++-- zero. ++ ++coneAngles :: Source -> StateVar (ALfloat, ALfloat) ++coneAngles source = ++ pairStateVars ++ (makeSourceStateVar dictALfloat GetConeInnerAngle source) ++ (makeSourceStateVar dictALfloat GetConeOuterAngle source) ++ ++-- | 'coneOuterGain' contains the factor with which 'sourceGain' is multiplied ++-- to determine the effective gain outside the cone defined by the outer angle. ++-- The effective gain applied outside the outer cone is 'sourceGain' times ++-- 'coneOuterGain'. Changing 'sourceGain' affects all directions, i.e. the ++-- source is attenuated in all directions, for any position of the listener. The ++-- application has to change 'coneOuterGain' as well if a different behavior is ++-- desired. ++ ++coneOuterGain :: Source -> StateVar Gain ++coneOuterGain = makeSourceStateVar dictALfloat GetConeOuterGain ++ ++-------------------------------------------------------------------------------- ++ ++-- | 'secOffset' contains the playback position, expressed in seconds (the value ++-- will loop back to zero for looping sources). ++-- ++-- When setting 'secOffset' on a source which is already playing, the playback ++-- will jump to the new offset unless the new offset is out of range, in which ++-- case an 'ALInvalidValue' error is set. If the source is not playing, then the ++-- offset will be applied on the next 'play' call. ++-- ++-- The position is relative to the beginning of all the queued buffers for the ++-- source, and any queued buffers traversed by a set call will be marked as ++-- processed. ++-- ++-- This value is based on byte position, so a pitch-shifted source will have an ++-- exaggerated playback speed. For example, you can be 0.5 seconds into a buffer ++-- having taken only 0.25 seconds to get there if the pitch is set to 2. ++ ++secOffset :: Source -> StateVar ALfloat ++secOffset = makeSourceStateVar dictALfloat GetSecOffset ++ ++-- | 'sampleOffset' contains the playback position, expressed in samples (the ++-- value will loop back to zero for looping sources). For a compressed format, ++-- this value will represent an exact offset within the uncompressed data. ++-- ++-- When setting 'sampleOffset' on a source which is already playing, the ++-- playback will jump to the new offset unless the new offset is out of range, ++-- in which case an 'ALInvalidValue' error is set. If the source is not playing, ++-- then the offset will be applied on the next 'play' call. A 'stop', 'rewind', ++-- or a second 'play' call will reset the offset to the beginning of the buffer. ++-- ++-- The position is relative to the beginning of all the queued buffers for the ++-- source, and any queued buffers traversed by a set call will be marked as ++-- processed. ++ ++sampleOffset :: Source -> StateVar ALint ++sampleOffset = makeSourceStateVar dictALint GetSampleOffset ++ ++-- | 'byteOffset' contains the playback position, expressed in bytes (the value ++-- will loop back to zero for looping sources). For a compressed format, this ++-- value may represent an approximate offset within the compressed data buffer. ++-- ++-- When setting 'byteOffset' on a source which is already playing, the playback ++-- will jump to the new offset unless the new offset is out of range, in which ++-- case an 'ALInvalidValue' error is set. If the source is not playing, then the ++-- offset will be applied on the next 'play' call. A 'stop', 'rewind', or a ++-- second 'play' call will reset the offset to the beginning of the buffer. ++-- ++-- The position is relative to the beginning of all the queued buffers for the ++-- source, and any queued buffers traversed by a set call will be marked as ++-- processed. ++ ++byteOffset :: Source -> StateVar ALint ++byteOffset = makeSourceStateVar dictALint GetByteOffset ++ ++-------------------------------------------------------------------------------- ++ ++pairStateVars :: StateVar a -> StateVar b -> StateVar (a,b) ++pairStateVars var1 var2 = ++ makeStateVar ++ (liftM2 (,) (get var1) (get var2)) ++ (\(val1,val2) -> do var1 $= val1; var2 $= val2) ++ ++data Dictionary a b c = Dictionary { ++ alGetter :: Source -> ALenum -> Ptr b -> IO (), ++ alSetter :: Source -> ALenum -> Ptr b -> IO (), ++ size :: Int, ++ peekSize :: Ptr b -> IO a, ++ marshal :: a -> c } ++ ++dictALint :: Dictionary ALint ALint ALint ++dictALint = Dictionary { ++ alGetter = alGetSourceiv, ++ alSetter = alSourceiv, ++ size = 1, ++ peekSize = peek1 id, ++ marshal = id } ++ ++dictALfloat :: Dictionary ALfloat ALfloat ALfloat ++dictALfloat = Dictionary { ++ alGetter = alGetSourcefv, ++ alSetter = alSourcefv, ++ size = 1, ++ peekSize = peek1 id, ++ marshal = id } ++ ++dictSourceRelative :: Dictionary SourceRelative ALint ALint ++dictSourceRelative = Dictionary { ++ alGetter = alGetSourceiv, ++ alSetter = alSourceiv, ++ size = 1, ++ peekSize = peek1 (unmarshalSourceRelative . unmarshalALboolean . fromIntegral), ++ marshal = fromIntegral . marshalALboolean . marshalSourceRelative } ++ ++dictSourceType :: Dictionary SourceType ALint ALint ++dictSourceType = Dictionary { ++ alGetter = alGetSourceiv, ++ alSetter = undefined, ++ size = 1, ++ peekSize = peek1 unmarshalSourceType, ++ marshal = undefined } ++ ++dictLoopingMode :: Dictionary LoopingMode ALint ALint ++dictLoopingMode = Dictionary { ++ alGetter = alGetSourceiv, ++ alSetter = alSourceiv, ++ size = 1, ++ peekSize = peek1 (unmarshalLoopingMode . unmarshalALboolean . fromIntegral), ++ marshal = fromIntegral . marshalALboolean . marshalLoopingMode } ++ ++dictSourceState :: Dictionary SourceState ALint ALint ++dictSourceState = Dictionary { ++ alGetter = alGetSourceiv, ++ alSetter = undefined, ++ size = 1, ++ peekSize = peek1 unmarshalSourceState, ++ marshal = undefined } ++ ++dictVertex3ALfloat :: Dictionary (Vertex3 ALfloat) ALfloat (Vertex3 ALfloat) ++dictVertex3ALfloat = Dictionary { ++ alGetter = alGetSourcefv, ++ alSetter = alSourcefv, ++ size = 3, ++ peekSize = peek3 Vertex3, ++ marshal = id } ++ ++dictVector3ALfloat :: Dictionary (Vector3 ALfloat) ALfloat (Vector3 ALfloat) ++dictVector3ALfloat = Dictionary { ++ alGetter = alGetSourcefv, ++ alSetter = alSourcefv, ++ size = 3, ++ peekSize = peek3 Vector3, ++ marshal = id } ++ ++dictMaybeBuffer :: Dictionary (Maybe Buffer) ALint ALint ++dictMaybeBuffer = Dictionary { ++ alGetter = alGetSourceiv, ++ alSetter = alSourceiv, ++ size = 1, ++ peekSize = peek1 (unmarshalBuffer . fromIntegral), ++ marshal = fromIntegral . marshalBuffer } ++ ++makeGetter :: Storable b => Dictionary a b c -> GetPName -> Source -> IO a ++makeGetter dict name source = ++ allocaArray (size dict) $ \buf -> do ++ alGetter dict source (marshalGetPName name) buf ++ peekSize dict buf ++ ++makeSetter :: Storable c => Dictionary a b c -> GetPName -> Source -> a -> IO () ++makeSetter dict name source value = ++ with (marshal dict value) $ ++ alSetter dict source (marshalGetPName name) . castPtr ++ ++makeSourceStateVar :: ++ (Storable b, Storable c) => ++ Dictionary a b c -> GetPName -> Source -> StateVar a ++makeSourceStateVar dict name source = ++ makeStateVar ++ (makeGetter dict name source) ++ (makeSetter dict name source) ++ ++makeSourceGettableStateVar :: ++ (Storable b, Storable c) => ++ Dictionary a b c -> GetPName -> Source -> GettableStateVar a ++makeSourceGettableStateVar dict name source = ++ makeGettableStateVar ++ (makeGetter dict name source) ++ ++-------------------------------------------------------------------------------- ++ ++foreign import CALLCONV unsafe "alGetSourcefv" ++ alGetSourcefv :: Source -> ALenum -> Ptr ALfloat -> IO () ++ ++foreign import CALLCONV unsafe "alSourcefv" ++ alSourcefv :: Source -> ALenum -> Ptr ALfloat -> IO () ++ ++foreign import CALLCONV unsafe "alGetSourceiv" ++ alGetSourceiv :: Source -> ALenum -> Ptr ALint -> IO () ++ ++-- Note: Older OpenAL implementations have no alSourceiv, so we emulate it here. ++alSourceiv :: Source -> ALenum -> Ptr ALint -> IO () ++alSourceiv source n buf = peek buf >>= alSourcei source n ++ ++foreign import CALLCONV unsafe "alSourcei" ++ alSourcei :: Source -> ALenum -> ALint -> IO () ++ ++-------------------------------------------------------------------------------- ++-- $QueuingBuffersWithASource ++-- OpenAL does not specify a built-in streaming mechanism. There is no mechanism ++-- to stream data into a buffer object. Instead, the API has a more flexible and ++-- versatile mechanism to queue buffers for sources. There are many ways to use ++-- this feature, with streaming being only one of them. ++-- ++-- Streaming is replaced by queuing static buffers. This effectively moves any ++-- multi-buffer caching into the application and allows the application to ++-- select how many buffers it wants to use, the size of the buffers, and whether ++-- these are re-used in cycle, pooled, or thrown away. ++-- ++-- Looping (over a finite number of repetitions) can be implemented by ++-- explicitly repeating buffers in the queue. Infinite loops can (theoretically) ++-- be accomplished by sufficiently large repetition counters. If only a single ++-- buffer is supposed to be repeated infinitely, using the respective source ++-- attribute 'loopingMode' is recommended. ++-- ++-- Loop Points for restricted looping inside a buffer can in many cases be ++-- replaced by splitting the sample into several buffers and queuing the sample ++-- fragments (including repetitions) accordingly. ++-- ++-- Buffers can be queued, unqueued after they have been used, and either be ++-- deleted, or refilled and queued again. Splitting large samples over several ++-- buffers maintained in a queue has distinct advantages over approaches that ++-- require explicit management of samples and sample indices. ++ ++-------------------------------------------------------------------------------- ++ ++-- | The application can queue up one or multiple buffer names using ++-- 'queueBuffers'. The buffers will be queued in the sequence in which they ++-- appear in the list. ++-- ++-- This command is legal on a source in any playback state (to allow for ++-- streaming, queuing has to be possible on a 'Playing' source). ++-- ++-- All buffers in a queue must have the same format and attributes. An attempt ++-- to mix formats or other buffer attributes will result in a failure and an ++-- 'ALInvalidValue' error will be thrown. If the queue operation fails, the source ++-- queue will remain unchanged (even if some of the buffers could have been ++-- queued). ++ ++queueBuffers :: Source -> [Buffer] -> IO () ++queueBuffers = withArraySizei . alSourceQueueBuffers ++ ++withArraySizei :: Storable a => (ALsizei -> Ptr a -> IO ()) -> [a] -> IO () ++withArraySizei f xs = withArrayLen xs $ f . fromIntegral ++ ++foreign import CALLCONV unsafe "alSourceQueueBuffers" ++ alSourceQueueBuffers :: Source -> ALsizei -> Ptr Buffer -> IO () ++ ++-------------------------------------------------------------------------------- ++ ++-- | Once a queue entry for a buffer has been appended to a queue and is pending ++-- processing, it should not be changed. Removal of a given queue entry is not ++-- possible unless either the source is stopped (in which case then entire queue ++-- is considered processed), or if the queue entry has already been processed ++-- ('Playing' or 'Paused' source). A playing source will enter the 'Stopped' ++-- state if it completes playback of the last buffer in its queue (the same ++-- behavior as when a single buffer has been attached to a source and has ++-- finished playback). ++-- ++-- The 'unqueueBuffers' command removes a number of buffers entries that have ++-- finished processing, in the order of appearance, from the queue. The ++-- operation will fail with an 'ALInvalidValue' error if more buffers are ++-- requested than available, leaving the destination arguments unchanged. ++ ++unqueueBuffers :: Source -> [Buffer] -> IO () ++unqueueBuffers = withArraySizei . alSourceUnqueueBuffers ++ ++foreign import CALLCONV unsafe "alSourceUnqueueBuffers" ++ alSourceUnqueueBuffers :: Source -> ALsizei -> Ptr Buffer -> IO () ++ ++-------------------------------------------------------------------------------- ++-- $ManagingSourceExecution ++-- The execution state of a source can be queried. OpenAL provides a set of ++-- functions that initiate state transitions causing sources to start and stop ++-- execution. ++ ++-------------------------------------------------------------------------------- ++ ++-- | Contains the current execution state of the given source. The initial state ++-- of any source is 'Initial'. ++-- ++-- Note that the 'Initial' state is not necessarily identical to the initial ++-- state in which a source is created, because the other source attributes are ++-- not automatically reset to their initial values. 'Initial' merely indicates ++-- that the source can be executed using the 'play' command. A 'Stopped' or ++-- 'Initial' source can be reset into the default configuration by using a ++-- sequence of source commands as necessary. As the application has to specify ++-- all relevant state anyway to create a useful source configuration, no reset ++-- command is provided. ++ ++sourceState :: Source -> GettableStateVar SourceState ++sourceState source = ++ makeGettableStateVar ++ (makeGetter dictSourceState GetSourceState source) ++ ++-------------------------------------------------------------------------------- + +-{- +-sourcei/sourcef/sourcefv: +-AL_BUFFER +-AL_CONE_INNER_ANGLE +-AL_CONE_OUTER_ANGLE +-AL_CONE_OUTER_GAIN +-AL_DIRECTION +-AL_GAIN +-AL_GAIN_LINEAR_LOKI +-AL_LOOPING +-AL_MAX_DISTANCE +-AL_MAX_GAIN +-AL_MIN_GAIN +-AL_PITCH +-AL_POSITION +-AL_REFERENCE_DISTANCE +-AL_ROLLOFF_FACTOR +-AL_SOURCE_RELATIVE +-AL_STREAMING +-AL_VELOCITY +- +-getsourceiv +-AL_BUFFERS_PROCESSED +-AL_BUFFERS_QUEUED +-AL_BYTE_LOKI +-AL_CONE_INNER_ANGLE +-AL_CONE_OUTER_ANGLE +-AL_CONE_OUTER_GAIN +-AL_DIRECTION +-AL_GAIN +-AL_GAIN_LINEAR_LOKI +-AL_LOOPING +-AL_MAX_DISTANCE +-AL_PITCH +-AL_POSITION +-AL_REFERENCE_DISTANCE +-AL_ROLLOFF_FACTOR +-AL_SOURCE_RELATIVE +-AL_SOURCE_STATE +-AL_STREAMING +-AL_VELOCITY +- +-getsourcefv +-*AL_BUFFER +-AL_BUFFERS_PROCESSED +-AL_BUFFERS_QUEUED +-AL_BYTE_LOKI +-AL_CONE_INNER_ANGLE +-AL_CONE_OUTER_ANGLE +-AL_CONE_OUTER_GAIN +-AL_DIRECTION +-AL_GAIN +-AL_GAIN_LINEAR_LOKI +-AL_LOOPING +-AL_MAX_DISTANCE +-*AL_MAX_GAIN +-*AL_MIN_GAIN +-AL_PITCH +-AL_POSITION +-AL_REFERENCE_DISTANCE +-AL_ROLLOFF_FACTOR +-AL_SOURCE_RELATIVE +-AL_SOURCE_STATE +-AL_STREAMING +-AL_VELOCITY ++-- | 'play' applied to an 'Initial' source will promote the source to 'Playing', ++-- thus the data found in the buffer will be fed into the processing, starting ++-- at the beginning. 'play' applied to a 'Playing' source will restart the ++-- source from the beginning. It will not affect the configuration, and will ++-- leave the source in 'Playing' state, but reset the sampling offset to the ++-- beginning. 'play' applied to a 'Paused' source will resume processing using ++-- the source state as preserved at the 'pause' operation. 'play' applied to a ++-- 'Stopped' source will propagate it to 'Initial' then to 'Playing' ++-- immediately. ++ ++play :: [Source] -> IO () ++play = withArraySizei alSourcePlayv ++ ++foreign import CALLCONV unsafe "alSourcePlayv" ++ alSourcePlayv :: ALsizei -> Ptr Source -> IO () ++ ++-- | 'pause' applied to an 'Initial' source is a legal NOP. 'pause' applied to a ++-- 'Playing' source will change its state to 'Paused'. The source is exempt from ++-- processing, its current state is preserved. 'pause' applied to a 'Paused' ++-- source is a legal NOP. 'pause' applied to a 'Stopped' source is a legal NOP. ++ ++pause :: [Source] -> IO () ++pause = withArraySizei alSourcePausev ++ ++foreign import CALLCONV unsafe "alSourcePausev" ++ alSourcePausev :: ALsizei -> Ptr Source -> IO () ++ ++-- | 'stop' applied to an 'Initial' source is a legal NOP. 'stop' applied to a ++-- 'Playing' source will change its state to 'Stopped'. The source is exempt ++-- from processing, its current state is preserved. 'stop' applied to a 'Paused' ++-- source will change its state to 'Stopped', with the same consequences as on a ++-- 'Playing' source. 'stop' applied to a 'Stopped' source is a legal NOP. ++ ++stop :: [Source] -> IO () ++stop = withArraySizei alSourceStopv ++ ++foreign import CALLCONV unsafe "alSourceStopv" ++ alSourceStopv :: ALsizei -> Ptr Source -> IO () ++ ++-- | 'rewind' applied to an 'Initial' source is a legal NOP. 'rewind' applied to ++-- a 'Playing' source will change its state to 'Stopped' then 'Initial'. The ++-- source is exempt from processing: its current state is preserved, with the ++-- exception of the sampling offset, which is reset to the beginning. 'rewind' ++-- applied to a 'Paused' source will change its state to 'Initial', with the ++-- same consequences as on a 'Playing' source. 'rewind' applied to an 'Stopped' ++-- source promotes the source to 'Initial', resetting the sampling offset to the ++-- beginning. + ++rewind :: [Source] -> IO () ++rewind = withArraySizei alSourceRewindv + +--} ++foreign import CALLCONV unsafe "alSourceRewindv" ++ alSourceRewindv :: ALsizei -> Ptr Source -> IO () +diff -uNr --exclude=autom4te.cache --exclude=.cvsignore hugs98-Mar2005-patched/fptools/libraries/OpenAL/Sound/OpenAL/AL/SourceState.hs ghc-6.4.2/libraries/OpenAL/Sound/OpenAL/AL/SourceState.hs +--- hugs98-Mar2005-patched/fptools/libraries/OpenAL/Sound/OpenAL/AL/SourceState.hs 1970-01-01 09:00:00.000000000 +0900 ++++ ghc-6.4.2/libraries/OpenAL/Sound/OpenAL/AL/SourceState.hs 2006-03-22 00:58:03.000000000 +0900 +@@ -0,0 +1,46 @@ ++-- #hide ++-------------------------------------------------------------------------------- ++-- | ++-- Module : Sound.OpenAL.AL.SourceState ++-- Copyright : (c) Sven Panne 2003-2005 ++-- License : BSD-style (see the file libraries/OpenAL/LICENSE) ++-- ++-- Maintainer : sven.panne@aedion.de ++-- Stability : provisional ++-- Portability : portable ++-- ++-------------------------------------------------------------------------------- ++ ++module Sound.OpenAL.AL.SourceState ( ++ SourceState(..), unmarshalSourceState ++) where ++ ++import Sound.OpenAL.AL.BasicTypes ( ALint ) ++import Sound.OpenAL.Constants ( al_INITIAL, al_PLAYING, al_PAUSED, al_STOPPED ) ++ ++-------------------------------------------------------------------------------- ++ ++-- | Each source can be in one of four possible execution states: 'Initial', ++-- 'Playing', 'Paused', 'Stopped'. Sources that are either 'Playing' or 'Paused' ++-- are considered active. Sources that are 'Stopped' or 'Initial' are considered ++-- inactive. Only 'Playing' sources are included in the processing. The ++-- implementation is free to skip those processing stages for sources that have ++-- no effect on the output (e.g. mixing for a source muted by zero gain, but not ++-- sample offset increments). Depending on the current state of a source certain ++-- (e.g. repeated) state transition commands are legal NOPs: they will be ++-- ignored, no error is generated. ++ ++data SourceState = ++ Initial ++ | Playing ++ | Paused ++ | Stopped ++ deriving ( Eq, Ord, Show ) ++ ++unmarshalSourceState :: ALint -> SourceState ++unmarshalSourceState x ++ | x == al_INITIAL = Initial ++ | x == al_PLAYING = Playing ++ | x == al_PAUSED = Paused ++ | x == al_STOPPED = Stopped ++ | otherwise = error ("unmarshalSourceState: illegal value " ++ show x) +diff -uNr --exclude=autom4te.cache --exclude=.cvsignore hugs98-Mar2005-patched/fptools/libraries/OpenAL/Sound/OpenAL/AL/String.hs ghc-6.4.2/libraries/OpenAL/Sound/OpenAL/AL/String.hs +--- hugs98-Mar2005-patched/fptools/libraries/OpenAL/Sound/OpenAL/AL/String.hs 1970-01-01 09:00:00.000000000 +0900 ++++ ghc-6.4.2/libraries/OpenAL/Sound/OpenAL/AL/String.hs 2006-03-22 00:58:03.000000000 +0900 +@@ -0,0 +1,31 @@ ++-- #hide ++-------------------------------------------------------------------------------- ++-- | ++-- Module : Sound.OpenAL.AL.String ++-- Copyright : (c) Sven Panne 2005 ++-- License : BSD-style (see the file libraries/OpenAL/LICENSE) ++-- ++-- Maintainer : sven.panne@aedion.de ++-- Stability : provisional ++-- Portability : portable ++-- ++-------------------------------------------------------------------------------- ++ ++module Sound.OpenAL.AL.String ( ++ withALString, peekALString ++) where ++ ++import Foreign.C.String ( withCString, peekCString ) ++import Foreign.Ptr ( Ptr, castPtr ) ++import Sound.OpenAL.AL.BasicTypes ( ALchar ) ++ ++-------------------------------------------------------------------------------- ++ ++-- AL uses "Ptr ALchar" instead of "CString" for strings, so some wrappers ++-- are quite handy. ++ ++withALString :: String -> (Ptr ALchar -> IO a) -> IO a ++withALString str action = withCString str (action . castPtr) ++ ++peekALString :: Ptr ALchar -> IO String ++peekALString = peekCString . castPtr +diff -uNr --exclude=autom4te.cache --exclude=.cvsignore hugs98-Mar2005-patched/fptools/libraries/OpenAL/Sound/OpenAL/AL/StringQueries.hs ghc-6.4.2/libraries/OpenAL/Sound/OpenAL/AL/StringQueries.hs +--- hugs98-Mar2005-patched/fptools/libraries/OpenAL/Sound/OpenAL/AL/StringQueries.hs 1970-01-01 09:00:00.000000000 +0900 ++++ ghc-6.4.2/libraries/OpenAL/Sound/OpenAL/AL/StringQueries.hs 2006-03-22 00:58:03.000000000 +0900 +@@ -0,0 +1,34 @@ ++-------------------------------------------------------------------------------- ++-- | ++-- Module : Sound.OpenAL.AL.StringQueries ++-- Copyright : (c) Sven Panne 2003-2005 ++-- License : BSD-style (see the file libraries/OpenAL/LICENSE) ++-- ++-- Maintainer : sven.panne@aedion.de ++-- Stability : provisional ++-- Portability : portable ++-- ++-- This module corresponds to section 3.1.2 (String Queries) of the OpenAL ++-- Specification and Reference (version 1.1). ++-- ++-------------------------------------------------------------------------------- ++ ++module Sound.OpenAL.AL.StringQueries ( ++ alVendor, alRenderer ++) where ++ ++import Graphics.Rendering.OpenGL.GL.StateVar ( ++ GettableStateVar, makeGettableStateVar ) ++import Sound.OpenAL.AL.QueryUtils ( StringName(..), getString ) ++ ++-------------------------------------------------------------------------------- ++ ++-- | Contains the name of the vendor. ++ ++alVendor :: GettableStateVar String ++alVendor = makeGettableStateVar (getString Vendor) ++ ++-- | Contains information about the specific renderer. ++ ++alRenderer :: GettableStateVar String ++alRenderer = makeGettableStateVar (getString Renderer) +diff -uNr --exclude=autom4te.cache --exclude=.cvsignore hugs98-Mar2005-patched/fptools/libraries/OpenAL/Sound/OpenAL/AL.hs ghc-6.4.2/libraries/OpenAL/Sound/OpenAL/AL.hs +--- hugs98-Mar2005-patched/fptools/libraries/OpenAL/Sound/OpenAL/AL.hs 2004-01-03 04:03:07.000000000 +0900 ++++ ghc-6.4.2/libraries/OpenAL/Sound/OpenAL/AL.hs 2006-03-22 00:58:03.000000000 +0900 +@@ -1,23 +1,128 @@ + -------------------------------------------------------------------------------- + -- | + -- Module : Sound.OpenAL.AL +--- Copyright : (c) Sven Panne 2003-2004 ++-- Copyright : (c) Sven Panne 2003-2005 + -- License : BSD-style (see the file libraries/OpenAL/LICENSE) + -- + -- Maintainer : sven.panne@aedion.de + -- Stability : provisional + -- Portability : portable + -- ++-- This module corresponds to chapters 2 (OpenAL Operation), 3 (State and State ++-- Requests), 4 (Listener and Sources) and 5 (Buffers) of the OpenAL ++-- Specification and Reference (version 1.1). ++-- + -------------------------------------------------------------------------------- + + module Sound.OpenAL.AL ( ++ -- * OpenAL Fundamentals ++ -- $OpenALFundamentals ++ ++ -- * Basic AL Operation ++ -- $BasicALOperation ++ ++ -- * Time and Frequency ++ -- $TimeAndFrequency ++ ++ -- * Space and Distance ++ -- $SpaceAndDistance ++ ++ -- * Coordinate System ++ -- $CoordinateSystem ++ + module Sound.OpenAL.AL.BasicTypes, +- module Sound.OpenAL.AL.Buffer, ++ module Sound.OpenAL.AL.Errors, ++ module Sound.OpenAL.AL.StringQueries, ++ module Sound.OpenAL.AL.Attenuation, ++ module Sound.OpenAL.AL.Doppler, ++ module Sound.OpenAL.AL.Listener, + module Sound.OpenAL.AL.Source, +- module Sound.OpenAL.AL.Listener ++ module Sound.OpenAL.AL.Buffer, ++ module Sound.OpenAL.AL.Extensions + ) where + + import Sound.OpenAL.AL.BasicTypes +-import Sound.OpenAL.AL.Buffer +-import Sound.OpenAL.AL.Source ++import Sound.OpenAL.AL.Errors ++import Sound.OpenAL.AL.StringQueries ++import Sound.OpenAL.AL.Attenuation ++import Sound.OpenAL.AL.Doppler + import Sound.OpenAL.AL.Listener ++import Sound.OpenAL.AL.Source ++import Sound.OpenAL.AL.Buffer ++import Sound.OpenAL.AL.Extensions ++ ++-------------------------------------------------------------------------------- ++-- $OpenALFundamentals ++-- OpenAL is concerned with rendering audio into an output buffer and collecting ++-- audio data from an input buffer. OpenAL\'s primary use is assumed to be for ++-- spatialized audio. There is no support for MIDI. ++-- ++-- OpenAL has three fundamental primitives or objects: 'Buffer's, 'Source's, and ++-- a single listener (see "Sound.OpenAL.AL.Listener"). Each object can be ++-- changed independently; the setting of one object does not affect the setting ++-- of others. The application can also set modes that affect processing. Modes ++-- are set, objects specified, and other OpenAL operations performed by sending ++-- commands in the form of function or procedure calls. ++-- ++-- Sources store locations, directions, and other attributes of an object in 3D ++-- space and have a buffer associated with them for playback. When the program ++-- wants to play a sound, it controls execution through a source object. Sources ++-- are processed independently from each other. ++-- ++-- Buffers store compressed or uncompressed audio data. It is common to ++-- initialize a large set of buffers when the program first starts (or at ++-- non-critical times during execution, between levels in a game, for ++-- instance). Buffers are referred to by sources. Data (audio sample data) is ++-- associated with buffers. ++-- ++-- There is only one listener (per audio context). The listener attributes are ++-- similar to source attributes, but are used to represent where the user is ++-- hearing the audio from. The influence of all the sources from the perspective ++-- of the listener is mixed and played for the user. ++ ++-------------------------------------------------------------------------------- ++-- $BasicALOperation ++-- OpenAL can be used for a variety of audio playback tasks, and is an excellent ++-- complement to OpenGL for real-time rendering, see ++-- "Graphics.Rendering.OpenGL". A programmer who is familiar with OpenGL will ++-- immediately notice the similarities between the two APIs in that they ++-- describe their 3D environments using similar methods. ++-- ++-- For an OpenGL\/OpenAL program, most of the audio programming will be in two ++-- places in the code: initialization of the program, and the rendering loop. An ++-- OpenGL\/OpenAL program will typically contain a section where the graphics ++-- and audio systems are initialized, although it may be spread into multiple ++-- functions. For OpenAL, initialization normally consists of creating a ++-- context, creating the initial set of buffers, loading the buffers with sample ++-- data, creating sources, attaching buffers to sources, setting locations and ++-- directions for the listener and sources, and setting the initial values for ++-- state global to OpenAL. ++ ++-------------------------------------------------------------------------------- ++-- $TimeAndFrequency ++-- By default, OpenAL uses seconds and Hertz as units for time and frequency, ++-- respectively. A float or integral value of one for a variable that specifies ++-- quantities like duration, latency, delay, or any other parameter measured as ++-- time, specifies 1 second. For frequency, the basic unit is 1\/second, or ++-- Hertz. In other words, sample frequencies and frequency cut-offs or filter ++-- parameters specifying frequencies are expressed in units of Hertz. ++ ++-------------------------------------------------------------------------------- ++-- $SpaceAndDistance ++-- OpenAL does not define the units of measurement for distances. The ++-- application is free to use meters, inches, or parsecs. OpenAL provides means ++-- for simulating the natural attenuation of sound according to distance, and to ++-- exaggerate or reduce this effect. However, the resulting effects do not ++-- depend on the distance unit used by the application to express source and ++-- listener coordinates. OpenAL calculations are scale invariant. The ++-- specification assumes Euclidean calculation of distances, and mandates that ++-- if two sources are sorted with respect to the Euclidean metric, the distance ++-- calculation used by the implementation has to preserve that order. ++ ++-------------------------------------------------------------------------------- ++-- $CoordinateSystem ++-- OpenAL - like OpenGL - uses a right-handed Cartesian coordinate system (RHS), ++-- where in a frontal default view X (thumb) points right, Y (index finger) ++-- points up, and Z (middle finger) points towards the viewer\/camera. To switch ++-- from a left handed coordinate system (LHS) to a right handed coordinate ++-- systems, flip the sign on the Z coordinate. +diff -uNr --exclude=autom4te.cache --exclude=.cvsignore hugs98-Mar2005-patched/fptools/libraries/OpenAL/Sound/OpenAL/ALC/ALCboolean.hs ghc-6.4.2/libraries/OpenAL/Sound/OpenAL/ALC/ALCboolean.hs +--- hugs98-Mar2005-patched/fptools/libraries/OpenAL/Sound/OpenAL/ALC/ALCboolean.hs 1970-01-01 09:00:00.000000000 +0900 ++++ ghc-6.4.2/libraries/OpenAL/Sound/OpenAL/ALC/ALCboolean.hs 2006-03-22 00:58:03.000000000 +0900 +@@ -0,0 +1,30 @@ ++-- #hide ++-------------------------------------------------------------------------------- ++-- | ++-- Module : Sound.OpenAL.ALC.ALCboolean ++-- Copyright : (c) Sven Panne 2005 ++-- License : BSD-style (see the file libraries/OpenAL/LICENSE) ++-- ++-- Maintainer : sven.panne@aedion.de ++-- Stability : provisional ++-- Portability : portable ++-- ++-- This is a purely internal module for (un-)marshaling ALCboolean. ++-- ++-------------------------------------------------------------------------------- ++ ++module Sound.OpenAL.ALC.ALCboolean ( ++ marshalALCboolean, unmarshalALCboolean ++) where ++ ++import Sound.OpenAL.ALC.BasicTypes ( ALCboolean ) ++import Sound.OpenAL.Constants ( alc_FALSE, alc_TRUE ) ++ ++-------------------------------------------------------------------------------- ++ ++marshalALCboolean :: Bool -> ALCboolean ++marshalALCboolean False = alc_FALSE ++marshalALCboolean True = alc_TRUE ++ ++unmarshalALCboolean :: ALCboolean -> Bool ++unmarshalALCboolean = (/= alc_FALSE) +diff -uNr --exclude=autom4te.cache --exclude=.cvsignore hugs98-Mar2005-patched/fptools/libraries/OpenAL/Sound/OpenAL/ALC/BasicTypes.hs ghc-6.4.2/libraries/OpenAL/Sound/OpenAL/ALC/BasicTypes.hs +--- hugs98-Mar2005-patched/fptools/libraries/OpenAL/Sound/OpenAL/ALC/BasicTypes.hs 2004-01-03 04:03:09.000000000 +0900 ++++ ghc-6.4.2/libraries/OpenAL/Sound/OpenAL/ALC/BasicTypes.hs 2006-03-22 00:58:03.000000000 +0900 +@@ -1,82 +1,24 @@ +--- #hide + -------------------------------------------------------------------------------- + -- | + -- Module : Sound.OpenAL.ALC.BasicTypes +--- Copyright : (c) Sven Panne 2003-2004 ++-- Copyright : (c) Sven Panne 2003-2005 + -- License : BSD-style (see the file libraries/OpenAL/LICENSE) + -- + -- Maintainer : sven.panne@aedion.de + -- Stability : provisional + -- Portability : portable + -- ++-- This module corresponds to the introductory parts of chapter 6 (AL Contexts ++-- and the ALC API) of the OpenAL Specification and Reference (version 1.1). ++-- ++-- The context API makes use of ALC types which are defined separately from the ++-- AL types - there is an 'ALCboolean', 'ALCchar', etc. ++-- + -------------------------------------------------------------------------------- + + module Sound.OpenAL.ALC.BasicTypes ( +- ALCenum, +- Device(..), isDevice, fromDevice, +- withALString, peekALString, +- ContextAttribute(..), marshalContextAttribute, unmarshalContextAttribute ++ ALCboolean, ALCchar, ALCbyte, ALCubyte, ALCshort, ALCushort, ALCint, ALCuint, ++ ALCsizei, ALCenum, ALCfloat, ALCdouble + ) where + +-import Foreign +-import Foreign.C.String ( withCString, peekCString ) +-import Sound.OpenAL.AL.BasicTypes ( ALubyte, ALint ) +-import Sound.OpenAL.AL.ALboolean ( marshalALboolean, unmarshalALboolean ) +-import Sound.OpenAL.AL.Buffer ( Frequency ) +- +--------------------------------------------------------------------------------- +- +-#include "HsOpenALConfig.h" +- +-type ALCenum = HTYPE_ALCENUM +- +--------------------------------------------------------------------------------- +- +-type ALCdevice = () +- +-newtype Device = Device (Ptr ALCdevice) +- deriving ( Eq, Ord, Show ) +- +-isDevice :: Device -> Bool +-isDevice (Device dev) = dev /= nullPtr +- +-fromDevice :: Maybe Device -> Device +-fromDevice = maybe (Device nullPtr) id +- +--------------------------------------------------------------------------------- +- +--- AL uses "Ptr ALubyte" instead of "CString" for strings, so some wrappers +--- are quite handy. +- +-withALString :: String -> (Ptr ALubyte -> IO a) -> IO a +-withALString str action = withCString str (action . castPtr) +- +-peekALString :: Ptr ALubyte -> IO String +-peekALString = peekCString . castPtr +- +--------------------------------------------------------------------------------- +- +-data ContextAttribute = +- Frequency Frequency +- | Refresh ALint +- | Sync Bool +- | Sources ALint +- | Buffers ALint +- deriving ( Eq, Ord, Show ) +- +-marshalContextAttribute :: ContextAttribute -> (ALint,ALint) +-marshalContextAttribute a = case a of +- Frequency f -> (CONST_ALC_FREQUENCY, fromIntegral f) +- Refresh r -> (CONST_ALC_REFRESH, r) +- Sync s -> (CONST_ALC_SYNC, fromIntegral (marshalALboolean s)) +- Sources s -> (0x200000, s) +- Buffers b -> (0x200001, b) +- +-unmarshalContextAttribute :: (ALint,ALint) -> ContextAttribute +-unmarshalContextAttribute a@(x,y) +- | x == CONST_ALC_FREQUENCY = Frequency (fromIntegral y) +- | x == CONST_ALC_REFRESH = Refresh y +- | x == CONST_ALC_SYNC = Sync (unmarshalALboolean (fromIntegral y)) +- | x == 0x200000 = Sources y +- | x == 0x200001 = Buffers y +- | otherwise = error ("unmarshalContextAttribute: illegal value " ++ show a) ++import Sound.OpenAL.Config +diff -uNr --exclude=autom4te.cache --exclude=.cvsignore hugs98-Mar2005-patched/fptools/libraries/OpenAL/Sound/OpenAL/ALC/Capture.hs ghc-6.4.2/libraries/OpenAL/Sound/OpenAL/ALC/Capture.hs +--- hugs98-Mar2005-patched/fptools/libraries/OpenAL/Sound/OpenAL/ALC/Capture.hs 1970-01-01 09:00:00.000000000 +0900 ++++ ghc-6.4.2/libraries/OpenAL/Sound/OpenAL/ALC/Capture.hs 2006-03-22 00:58:03.000000000 +0900 +@@ -0,0 +1,136 @@ ++-------------------------------------------------------------------------------- ++-- | ++-- Module : Sound.OpenAL.ALC.Capture ++-- Copyright : (c) Sven Panne 2005 ++-- License : BSD-style (see the file libraries/OpenAL/LICENSE) ++-- ++-- Maintainer : sven.panne@aedion.de ++-- Stability : provisional ++-- Portability : portable ++-- ++-- This module corresponds to section 6.4.2. (Capture) of the OpenAL ++-- Specification and Reference (version 1.1). ++-- ++-------------------------------------------------------------------------------- ++ ++module Sound.OpenAL.ALC.Capture ( ++ NumSamples, captureOpenDevice, captureStart, captureNumSamples, ++ captureSamples, captureStop, captureCloseDevice, ++ captureDefaultDeviceSpecifier, captureDeviceSpecifier, ++ allCaptureDeviceSpecifiers ++) where ++ ++import Foreign.Ptr ( Ptr, nullPtr, FunPtr ) ++import Graphics.Rendering.OpenGL.GL.StateVar ( ++ GettableStateVar, makeGettableStateVar, get ) ++import Sound.OpenAL.AL.Buffer ( Format ) ++import Sound.OpenAL.AL.Format ( marshalFormat ) ++import Sound.OpenAL.ALC.ALCboolean ( unmarshalALCboolean ) ++import Sound.OpenAL.ALC.BasicTypes ( ++ ALCchar, ALCuint, ALCenum, ALCsizei, ALCboolean ) ++import Sound.OpenAL.ALC.Context ( Frequency ) ++import Sound.OpenAL.ALC.Device ( Device ) ++import Sound.OpenAL.ALC.Extensions ( alcProcAddress ) ++import Sound.OpenAL.ALC.QueryUtils ( IntQuery(..), getInteger ) ++import Sound.OpenAL.ALC.QueryUtils ( ++ StringQuery(..), getString, getStringRaw, alcIsExtensionPresent ) ++import Sound.OpenAL.ALC.String ( withALCString, peekALCStrings ) ++import Sound.OpenAL.Config ( ALCdevice, marshalDevice, unmarshalDevice ) ++ ++-------------------------------------------------------------------------------- ++ ++type NumSamples = ALCsizei ++ ++-------------------------------------------------------------------------------- ++ ++type Invoker a = FunPtr a -> a ++ ++getCaptureFunc :: String -> IO (FunPtr a) ++getCaptureFunc = get . alcProcAddress Nothing ++ ++-------------------------------------------------------------------------------- ++ ++captureOpenDevice :: ++ Maybe String -> Frequency -> Format -> NumSamples -> IO (Maybe Device) ++captureOpenDevice maybeDeviceSpec frequency format size = do ++ funPtr <- getCaptureFunc "alcCaptureOpenDevice" ++ let open deviceSpec = ++ invokeCaptureOpenDevice funPtr deviceSpec (round frequency) ++ (fromIntegral (marshalFormat format)) size ++ fmap unmarshalDevice $ ++ (maybe (open nullPtr) -- use preferred device ++ (flip withALCString open) ++ maybeDeviceSpec) ++ ++foreign import CALLCONV unsafe "dynamic" ++ invokeCaptureOpenDevice :: Invoker (Ptr ALCchar -> ALCuint -> ALCenum -> ALCsizei -> IO ALCdevice) ++ ++-------------------------------------------------------------------------------- ++ ++captureStart :: Device -> IO () ++captureStart = captureStartStop "alcCaptureStart" ++ ++captureStartStop :: String -> Device -> IO () ++captureStartStop funName device = do ++ funPtr <- getCaptureFunc funName ++ invokeCaptureStartStop funPtr (marshalDevice device) ++ ++foreign import CALLCONV unsafe "dynamic" ++ invokeCaptureStartStop :: Invoker (ALCdevice -> IO ()) ++ ++-------------------------------------------------------------------------------- ++ ++captureNumSamples :: Device -> GettableStateVar NumSamples ++captureNumSamples device = ++ makeGettableStateVar $ getInteger (Just device) CaptureSamples ++ ++-------------------------------------------------------------------------------- ++ ++captureSamples :: Device -> Ptr a -> NumSamples -> IO () ++captureSamples = alcCaptureSamples . marshalDevice ++ ++foreign import CALLCONV unsafe "alcCaptureSamples" ++ alcCaptureSamples :: ALCdevice -> Ptr a -> NumSamples -> IO () ++ ++-------------------------------------------------------------------------------- ++ ++captureStop :: Device -> IO () ++captureStop = captureStartStop "alcCaptureStop" ++ ++-------------------------------------------------------------------------------- ++ ++captureCloseDevice :: Device -> IO Bool ++captureCloseDevice device = do ++ funPtr <- getCaptureFunc "alcCaptureCloseDevice" ++ fmap unmarshalALCboolean . ++ invokeCaptureCloseDevice funPtr . marshalDevice $ device ++ ++foreign import CALLCONV unsafe "dynamic" ++ invokeCaptureCloseDevice :: Invoker (ALCdevice -> IO ALCboolean) ++ ++-------------------------------------------------------------------------------- ++ ++-- | Contains the name of the default capture device. ++ ++captureDefaultDeviceSpecifier :: GettableStateVar String ++captureDefaultDeviceSpecifier = makeGettableStateVar $ ++ getString Nothing CaptureDefaultDeviceSpecifier ++ ++-------------------------------------------------------------------------------- ++ ++-- | Contains the specifier string for the given capture device. ++ ++captureDeviceSpecifier :: Device -> GettableStateVar String ++captureDeviceSpecifier device = makeGettableStateVar $ ++ getString (Just device) CaptureDeviceSpecifier ++ ++-------------------------------------------------------------------------------- ++ ++-- | Contains a list of specifiers for all available capture devices. ++ ++allCaptureDeviceSpecifiers :: GettableStateVar [String] ++allCaptureDeviceSpecifiers = makeGettableStateVar $ do ++ enumExtPresent <- get (alcIsExtensionPresent Nothing "ALC_ENUMERATION_EXT") ++ if enumExtPresent ++ then peekALCStrings =<< getStringRaw Nothing CaptureDeviceSpecifier ++ else fmap (\s -> [s]) $ get captureDefaultDeviceSpecifier +diff -uNr --exclude=autom4te.cache --exclude=.cvsignore hugs98-Mar2005-patched/fptools/libraries/OpenAL/Sound/OpenAL/ALC/Context.hs ghc-6.4.2/libraries/OpenAL/Sound/OpenAL/ALC/Context.hs +--- hugs98-Mar2005-patched/fptools/libraries/OpenAL/Sound/OpenAL/ALC/Context.hs 2005-02-24 18:58:23.000000000 +0900 ++++ ghc-6.4.2/libraries/OpenAL/Sound/OpenAL/ALC/Context.hs 2006-03-22 00:58:03.000000000 +0900 +@@ -1,152 +1,198 @@ + -------------------------------------------------------------------------------- + -- | + -- Module : Sound.OpenAL.ALC.Context +--- Copyright : (c) Sven Panne 2003-2004 ++-- Copyright : (c) Sven Panne 2003-2005 + -- License : BSD-style (see the file libraries/OpenAL/LICENSE) + -- + -- Maintainer : sven.panne@aedion.de + -- Stability : provisional + -- Portability : portable + -- +--- Managing Rendering Contexts ++-- This module corresponds to section 6.2 (Managing Rendering Contexts) of the ++-- OpenAL Specification and Reference (version 1.1). ++-- ++-- All operations of the AL core API affect a current AL context. Within the ++-- scope of AL, the ALC is implied - it is not visible as a handle or function ++-- parameter. Only one AL Context per process can be current at a time. ++-- Applications maintaining multiple AL Contexts, whether threaded or not, ++-- have to set the current context accordingly. Applications can have multiple ++-- threads that share one more or contexts. In other words, AL and ALC are ++-- threadsafe. + -- + -------------------------------------------------------------------------------- + + module Sound.OpenAL.ALC.Context ( +- ContextAttribute(..), Context, createContext, destroyContext, currentContext, +- processContext, suspendContext, +- +- contextsDevice, allAttributes ++ Frequency, ContextAttribute(..), Context, createContext, currentContext, ++ processContext, suspendContext, destroyContext, contextsDevice, allAttributes + ) where + + +-import Control.Monad ( liftM ) + import Foreign.Marshal.Array ( withArray0 ) +-import Foreign.Ptr ( Ptr, nullPtr ) ++import Foreign.Ptr ( Ptr ) + import Graphics.Rendering.OpenGL.GL.StateVar ( + StateVar, makeStateVar, GettableStateVar, makeGettableStateVar ) +-import Sound.OpenAL.AL.BasicTypes ( ALint ) ++import Sound.OpenAL.ALC.BasicTypes ( ALCint ) ++import Sound.OpenAL.ALC.ALCboolean ( marshalALCboolean, unmarshalALCboolean ) + import Sound.OpenAL.ALC.Device ( Device ) +-import Sound.OpenAL.ALC.Queries ( IntQuery(..), getInteger, getIntegerv ) +-import Sound.OpenAL.ALC.BasicTypes ( +- ALCenum, isDevice, +- ContextAttribute(..), marshalContextAttribute, unmarshalContextAttribute ) +-import Sound.OpenAL.ALC.Errors ( checkError ) ++import Sound.OpenAL.ALC.QueryUtils ( IntQuery(..), getInteger, getIntegerv ) ++import Sound.OpenAL.Config ( ++ ALCdevice, marshalDevice, unmarshalDevice, ++ ALCcontext, Context, nullContext, marshalContext, unmarshalContext, ++ alcProcessContext, alcDestroyContext, alcMakeContextCurrent ) ++import Sound.OpenAL.Constants ( ++ alc_FREQUENCY, alc_REFRESH, alc_SYNC, alc_MONO_SOURCES, alc_STEREO_SOURCES ) + +--------------------------------------------------------------------------------- ++#ifdef __HADDOCK__ ++import Sound.OpenAL.ALC.Errors ( ALCErrorCategory(..) ) ++#endif + +-type ALCcontext = () ++-------------------------------------------------------------------------------- + +-newtype Context = Context (Ptr ALCcontext) +- deriving ( Eq, Ord, Show ) ++-- | Frequency, specified in samples per second, i.e. units of Hertz \[Hz\]. ++-- Note that the underlying OpenAL API currently uses integral frequencies ++-- only, but we want to mirror physical reality here more closely. + +-isContext :: Context -> Bool +-isContext (Context ctx) = ctx /= nullPtr ++type Frequency = Float + + -------------------------------------------------------------------------------- + +--- | Allocates, initializes, and returns a context for the given device with the +--- requested attributes. If any attribute cannot have the required value met or +--- exceeded, an 'IOError' is thrown. If the device is not valid, an +--- 'Sound.OpenAL.ALC.Errors.ALCInvalidDevice' error is set and an 'IOError' is +--- thrown. Note that 'createContext' does /not/ set the current context, this +--- must be done separately via 'currentContext'. ++-- | The application can choose to specify certain attributes for a context at ++-- context-creation time. Attributes not specified explicitly are set to ++-- implementation dependent defaults. + +-createContext :: Device -> [ContextAttribute] -> IO Context +-createContext device attributes = +- let pairToList (key, value) = [key, value] +- attrs = concatMap (pairToList . marshalContextAttribute) attributes +- in checkError isContext . withArray0 0 attrs $ alcCreateContext device ++data ContextAttribute = ++ Frequency Frequency -- ^ Frequency for mixing output buffer, in units of ++ -- Hz ++ | Refresh Frequency -- ^ Refresh intervals, in units of Hz ++ | Sync Bool -- ^ Flag, indicating a synchronous context ++ | MonoSources Int -- ^ A hint indicating how many sources should be ++ -- capable of supporting mono data ++ | StereoSources Int -- ^ A hint indicating how many sources should be ++ -- capable of supporting stereo data ++ deriving ( Eq, Ord, Show ) + +-foreign import CALLCONV unsafe "alcCreateContext" +- alcCreateContext :: Device -> Ptr ALint -> IO Context ++marshalContextAttribute :: ContextAttribute -> (ALCint,ALCint) ++marshalContextAttribute a = case a of ++ Frequency f -> (alc_FREQUENCY, round f) ++ Refresh r -> (alc_REFRESH, round r) ++ Sync s -> (alc_SYNC, fromIntegral (marshalALCboolean s)) ++ MonoSources m -> (alc_MONO_SOURCES, fromIntegral m) ++ StereoSources s -> (alc_STEREO_SOURCES, fromIntegral s) ++ ++unmarshalContextAttribute :: (ALCint,ALCint) -> ContextAttribute ++unmarshalContextAttribute a@(x,y) ++ | x == alc_FREQUENCY = Frequency (fromIntegral y) ++ | x == alc_REFRESH = Refresh (fromIntegral y) ++ | x == alc_SYNC = Sync (unmarshalALCboolean (fromIntegral y)) ++ | x == alc_MONO_SOURCES = MonoSources (fromIntegral y) ++ | x == alc_STEREO_SOURCES = StereoSources (fromIntegral y) ++ | otherwise = error ("unmarshalContextAttribute: illegal value " ++ show a) + + -------------------------------------------------------------------------------- + +--- | Destroys the given context. ++-- | Create a context for a given device and given attributes. Context creation ++-- will fail in the following cases: a) if the application requests attributes ++-- that, by themselves, can not be provided b) if the combination of specified ++-- attributes can not be provided c) if a specified attribute, or the ++-- combination of attributes, does not match the default values for unspecified ++-- attributes If context creation fails, 'Nothing' will be returned, otherwise ++-- 'Just' the new context. Note that 'createContext' does /not/ set the current ++-- context, this must be done separately via 'currentContext'. + +-destroyContext :: Context -> IO () +-destroyContext = ignore . alcDestroyContext ++createContext :: Device -> [ContextAttribute] -> IO (Maybe Context) ++createContext device attributes = do ++ let pairToList (key, value) = [key, value] ++ attrs = concatMap (pairToList . marshalContextAttribute) attributes ++ fmap unmarshalContext . ++ withArray0 0 attrs . alcCreateContext . marshalDevice $ device + +-foreign import CALLCONV unsafe "alcDestroyContext" +- alcDestroyContext :: Context -> IO ALCenum ++foreign import CALLCONV unsafe "alcCreateContext" ++ alcCreateContext :: ALCdevice -> Ptr ALCint -> IO ALCcontext + + -------------------------------------------------------------------------------- + +--- | 'Just' the current context, 'Nothing' means paused. ++-- | Contains 'Just' the current context with respect to OpenAL operation, or ++-- 'Nothing' if there is no current context. Setting it to the latter is useful ++-- when shutting OpenAL down. The state variable applies to the device that the ++-- context was created for. For each OS process (usually this means for each ++-- application), only one context can be current at any given time. All AL ++-- commands apply to the current context. Commands that affect objects shared ++-- among contexts (e.g. buffers) have side effects on other contexts. + + currentContext :: StateVar (Maybe Context) + currentContext = makeStateVar getCurrentContext makeContextCurrent + +--- | Returns 'Just' the current context or 'Nothing' if there is none. +- + getCurrentContext :: IO (Maybe Context) +-getCurrentContext = do +- context <- alcGetCurrentContext +- return $ if isContext context then Nothing else Just context ++getCurrentContext = fmap unmarshalContext $ alcGetCurrentContext + + foreign import CALLCONV unsafe "alcGetCurrentContext" +- alcGetCurrentContext :: IO Context +- +--- | Makes the given context the current context or pauses when given 'Nothing'. ++ alcGetCurrentContext :: IO ALCcontext + + makeContextCurrent :: Maybe Context -> IO () +-makeContextCurrent mbContext = +- ignore $ alcMakeContextCurrent (maybe (Context nullPtr) id mbContext) +- +-foreign import CALLCONV unsafe "alcMakeContextCurrent" +- alcMakeContextCurrent :: Context -> IO ALCenum ++makeContextCurrent = ++ fmap (const ()) . alcMakeContextCurrent . marshalContext . maybe nullContext id + + -------------------------------------------------------------------------------- + +--- | Performs processing on a synced context, nop on an asynchronous context. ++-- | The current context is the only context accessible to state changes by AL ++-- commands (aside from state changes affecting shared objects). However, ++-- multiple contexts can be processed at the same time. To indicate that a ++-- context should be processed (i.e. that internal execution state like offset ++-- increments are supposed to be performed), the application has to use ++-- 'processContext'. Repeated calls to 'processContext' are legal, and do not ++-- affect a context that is already marked as processing. The default state of a ++-- context created by 'createContext' is that it is processing. + + processContext :: Context -> IO () +-processContext = ignore . alcProcessContext ++processContext = fmap (const ()) . alcProcessContext . marshalContext + +-foreign import CALLCONV unsafe "alcProcessContext" +- alcProcessContext :: Context -> IO Context ++-- | The application can suspend any context from processing (including the ++-- current one). To indicate that a context should be suspended from processing ++-- (i.e. that internal execution state like offset increments is not supposed to ++-- be changed), the application has to use 'suspendContext'. Repeated calls to ++-- 'suspendContext' are legal, and do not affect a context that is already ++-- marked as suspended. + +--- | Suspends processing on an asynchronous context. This is a legal nop on a +--- synced context. ++suspendContext :: Context -> IO () ++suspendContext = alcSuspendContext . marshalContext + + foreign import CALLCONV unsafe "alcSuspendContext" +- suspendContext :: Context -> IO () ++ alcSuspendContext :: ALCcontext -> IO () + + -------------------------------------------------------------------------------- + +--- ALC's error handling is highly irregular: Somtimes a success/failure value is +--- returned in addition to setting the internal error state. We don't do the +--- same in our Haskell API, effectively ignoring the returned value. ++-- | Destroy the given context. Note that the the correct way to destroy a ++-- context is to first release it by setting 'currentContext' to ++-- 'Nothing'. Applications should not attempt to destroy a current context, ++-- doing so will not work and will result in an 'ALCInvalidOperation' error. + +-ignore :: IO a -> IO () +-ignore action = do +- action +- return () ++destroyContext :: Context -> IO () ++destroyContext = fmap (const ()) . alcDestroyContext . marshalContext + + -------------------------------------------------------------------------------- + +--- | 'Just' the device of the given context or 'Nothing' if the context is +--- invalid. ++-- | Contains 'Just' the device of the given context or 'Nothing' if the context ++-- is invalid. + + contextsDevice :: Context -> GettableStateVar (Maybe Device) +-contextsDevice context = makeGettableStateVar $ do +- device <- alcGetContextsDevice context +- return $ if isDevice device then Nothing else Just device ++contextsDevice = ++ makeGettableStateVar . ++ fmap unmarshalDevice . alcGetContextsDevice . marshalContext + + foreign import CALLCONV unsafe "alcGetContextsDevice" +- alcGetContextsDevice :: Context -> IO Device ++ alcGetContextsDevice :: ALCcontext -> IO ALCdevice + + -------------------------------------------------------------------------------- + +--- | Note that we need a current context here! ++-- | Contains the attribute list for the current context of the specified ++-- device. + + allAttributes :: Device -> GettableStateVar [ContextAttribute] + allAttributes device = makeGettableStateVar $ do +- numALints <- liftM fromIntegral $ getInteger device AttributesSize +- liftM toContextAttributes $ getIntegerv device AllAttributes numALints ++ numALCints <- fmap fromIntegral $ getInteger (Just device) AttributesSize ++ fmap toContextAttributes $ getIntegerv (Just device) AllAttributes numALCints + +-toContextAttributes :: [ALint] -> [ContextAttribute] ++toContextAttributes :: [ALCint] -> [ContextAttribute] + toContextAttributes xs = case xs of + [] -> [] -- should only happen when device and/or current context is invalid + (0:_) -> [] +diff -uNr --exclude=autom4te.cache --exclude=.cvsignore hugs98-Mar2005-patched/fptools/libraries/OpenAL/Sound/OpenAL/ALC/Device.hs ghc-6.4.2/libraries/OpenAL/Sound/OpenAL/ALC/Device.hs +--- hugs98-Mar2005-patched/fptools/libraries/OpenAL/Sound/OpenAL/ALC/Device.hs 2004-04-05 23:15:54.000000000 +0900 ++++ ghc-6.4.2/libraries/OpenAL/Sound/OpenAL/ALC/Device.hs 2006-03-22 00:58:03.000000000 +0900 +@@ -1,79 +1,223 @@ + -------------------------------------------------------------------------------- + -- | + -- Module : Sound.OpenAL.ALC.Device +--- Copyright : (c) Sven Panne 2003-2004 ++-- Copyright : (c) Sven Panne 2003-2005 + -- License : BSD-style (see the file libraries/OpenAL/LICENSE) + -- + -- Maintainer : sven.panne@aedion.de + -- Stability : provisional + -- Portability : portable + -- +--- Managing Devices ++-- This module corresponds to section 6.1 (Managing Devices) of the OpenAL ++-- Specification and Reference (version 1.1). ++-- ++-- ALC introduces the notion of a device. A device can be, depending on the ++-- implementation, a hardware device, or a daemon\/OS service\/actual ++-- server. This mechanism also permits different drivers (and hardware) to ++-- coexist within the same system, as well as allowing several applications to ++-- share system resources for audio, including a single hardware output ++-- device. The details are left to the implementation, which has to map the ++-- available backends to unique device specifiers. + -- + -------------------------------------------------------------------------------- + + module Sound.OpenAL.ALC.Device ( + Device, openDevice, closeDevice, +- deviceSpecifier, alcVersion, +- defaultDeviceSpecifier, allDeviceSpecifiers ++ defaultDeviceSpecifier, deviceSpecifier, allDeviceSpecifiers + ) where + +-import Control.Monad ( liftM, liftM2 ) + import Foreign.Ptr ( Ptr, nullPtr ) ++import Foreign.Marshal.Utils ( maybePeek ) + import Graphics.Rendering.OpenGL.GL.StateVar ( + GettableStateVar, makeGettableStateVar, get ) +-import Sound.OpenAL.AL.BasicTypes ( ALubyte, ALint ) +-import Sound.OpenAL.ALC.Queries( +- StringQuery(..), alcGetString, alcGetString_, +- IntQuery(..), getInteger, +- alcIsExtensionPresent ) +-import Sound.OpenAL.ALC.BasicTypes ( Device, isDevice, withALString ) +-import Sound.OpenAL.ALC.Errors ( checkError ) ++import Sound.OpenAL.ALC.BasicTypes ( ALCchar ) ++import Sound.OpenAL.ALC.QueryUtils ( ++ StringQuery(..), getString, getStringRaw, alcIsExtensionPresent ) ++import Sound.OpenAL.ALC.String ( withALCString, peekALCString, peekALCStrings ) ++import Sound.OpenAL.Config ( ++ Device, ALCdevice, unmarshalDevice, closeDevice ) + + -------------------------------------------------------------------------------- + +--- | Opens a device, using an alrc expression to specify attributes for the +--- device. Throws an IOError on failure. The ALC error flag is cleared in any +--- case. ++-- | 'openDevice' allows the application (i.e. the client program) to connect to ++-- a device (i.e. the server). If the function returns 'Nothing', then no sound ++-- driver\/device has been found. The argument to 'openDevice' specifies a ++-- certain device or device configuration. If it is 'Nothing', the ++-- implementation will provide an implementation specific default, see ++-- 'defaultDeviceSpecifier'. Otherwise it is 'Just' an implementation-dependent ++-- string. You can use 'allDeviceSpecifiers' to get a list of the known OpenAL ++-- devices. ++-- ++-- /Notes for Windows:/ There are 3 possible device strings, each having a ++-- deprecated equivalent for legacy applications only: ++-- ++-- * @\"Generic Hardware\"@ (legacy string: @\"DirectSound3D\"@) ++-- ++-- * @\"Generic Software\"@ (legacy string: @\"DirectSound\"@) ++-- ++-- * @\"Generic Software Fallback\"@ (legacy string: @\"MMSYSTEM\"@) ++-- ++-- /Notes for Linux\/\*nix:/ If an @.openalrc@ file is present in the user\'s ++-- home directory, it is loaded first, otherwise @\/etc\/openalrc@ is tried. ++-- The bindings (if any) of @devices@, @direction@, @sampling-rate@, and ++-- @speaker-num@ (see below) after loading one of these files take precedence ++-- over any bindings done via the argument to 'openDevice'. ++-- ++-- The syntax of these files is lisp-based and a sequence of expressions, where ++-- an expression is one the following: ++-- ++-- * A boolean value of the form @\#f@ or @\#t@, which evaluate to /false/ and ++-- /true/, respectively. ++-- ++-- * An non-negative integer value, i.e. a sequence of decimal digits, ++-- evaluating to itself. ++-- ++-- * A (signed) floating point value, as recoginzed by C\'s @atof()@, evaluating ++-- to itself. ++-- ++-- * A pointer value of the form @\#p/num/@, where /num/ can be an octal, ++-- decimal or hexadecimal value, as recoginzed by C\`s @strtol()@, evaluating ++-- to itself. This kind of expression is currently unused. ++-- ++-- * A string, i.e. a sequence of printable\/whitespace characters between ++-- double quotes, evaluating to itself. ++-- ++-- * A symbol, i.e. a sequence of almost all characters which don\'t form a ++-- simple expression like the ones mentioned below, e.g. @foo@, @bar1@, @3baz@, ++-- ... The symbol evaluates to the value currently bound to it. ++-- ++-- * A function application of the form @(/symbol/ /expression/...)@. The ++-- function bound to the symbol is applied to the evaluated arguments. ++-- ++-- * A quotation of the form @(quote /expression/)@ or @\'/expression/@, ++-- evaluating to the unevaluated /expression/ itself. ++-- ++-- * A definition of the form @(define /symbol/ /expression/)@, binding /symbol/ ++-- to the value of /expression/. The whole expression evaluates to the value of ++-- /expression/, too. ++-- ++-- * A conjunction of boolean expressions of the form @(and /expression/...)@. ++-- Each /expression/ is evaluated in turn, and if one of them evaluates to ++-- /false/, the value of the whole expression is /false/. Otherwise the value is ++-- /true/. ++-- ++-- * An extension loading mechanism of the form @(load-extension ++-- /libraryName/)@, where /libraryName/ has to evaluate to a string. This tries ++-- to load the dynamic library with up to 3 special entry points: ++-- @alExtension_03282000@ (pointing to a mandatory NULL-terminated sequence of ++-- pairs of pointers to names and extension functions), @alExtInit_03282000@ (an ++-- optional initialization function), and @alExtFini_03282000@ (an optional ++-- cleanup function). If the extension could be loaded successfully, the whole ++-- expression evaluates to /true/, otherwise to /false/. ++-- ++-- Some symbols have a special meaning for OpenAL: ++-- ++-- [@devices@] Has the form @(/devspec/...)@, where /devspec/ is either a ++-- symbol\/string specifying a device or @(/device/ /device-param/...)@, ++-- specifying a device with additional parameters. These optional device ++-- parameters are stored in a variable @device-params@, but are currently ++-- unused. The first device which can successfully opened is used. ++-- ++-- [@direction@] Type string or symbol: @\"read\"@ specifies that the device ++-- should be an input device, everything else means output device (default). ++-- ++-- [@sampling-rate@] Type integer or float: Specifies the internal mixing ++-- frequency, default is 44.1kHz. ++-- ++-- [@speaker-num@] Type integer or float: Specifies the number of speakers, ++-- which can be 1, 2 (default), or 4. ++-- ++-- [@alsa-device@] Type string, @alsa@ backend only: Specifies both ++-- @alsa-out-device@ and @alsa-in-device@, default @\"plughw:0,0\"@. ++-- ++-- [@alsa-out-device@] Type string, @alsa@ backend only: Specifies the ALSA ++-- output device, defaults to the value of @alsa-device@. ++-- ++-- [@alsa-in-device@] Type string, @alsa@ backend only: Specifies the ALSA ++-- input device, defaults to the value of @alsa-device@. ++-- ++-- [@native-in-device@] Type string, @native@ backend on IRIX only. ++-- ++-- [@native-out-device@] Type string, @native@ backend on IRIX only. ++-- ++-- [@native-rear-out-device@] Type string, @native@ backend on IRIX only. ++-- ++-- [@native-use-select@] Type boolean, @native@ backend on Linux only: If @\#t@, ++-- wait up to 0.8sec for the device to become ready for writing. If @\#f@, just ++-- try to write and hope it won\'t hang forever. The latter might be necessary ++-- for some drivers which don\'t implement @select()@ , like some Aureal ++-- drivers. ++-- ++-- [@lin-dsp-path@] Type string, @native@ backend on Linux only: Path to DSP ++-- device for writing, tried before @\/dev\/sound\/dsp@ and @\/dev\/sound@ if ++-- set. ++-- ++-- [@lin-dsp-read-path@] Type string, @native@ backend on Linux only: Path to ++-- DSP device for reading, tried before @\/dev\/sound\/dsp@ and @\/dev\/sound@ ++-- if set. Defaults to the value of @lin-dsp-path@. ++-- ++-- [@native-backend-debug@] Type boolean, @native@ backend on Darwin only: If ++-- set to @\#f@, be a bit verbose on stderr about what\'s going on in the ++-- backend. ++-- ++-- [@source-rolloff-factor@] Type integer or float: Value of the initial rolloff ++-- factor for sources, default is @1.0@. ++-- ++-- [@listener-position@] List of 3 integers or floats: Value of the initial ++-- listener position, default is @(0 0 0)@. ++-- ++-- [@listener-velocity@] List of 3 integers or floats: Value of the initial ++-- listener velocity, default is @(0 0 0)@. ++-- ++-- [@listener-orientation@] List of 6 integers or floats: Value of the initial ++-- listener orientation (at\/up), default is @(0 0 -1 0 1 0)@. ++-- ++-- The string given to 'openDevice' has to be of the form @\'((/symbol/ ++-- /expression/) ...)@, which means basically a sequence of @define@ ++-- expressions. Example: ++-- ++-- @ ++-- \"\'((sampling-rate 8000) (native-backend-debug \#f))\" ++-- @ ++-- ++-- /Note:/ The information above has been reverse-engineered from the OpenAL SI ++-- and could be inaccurate. Any corrections and\/or additions are highly ++-- welcome. + +-openDevice :: Maybe String -> IO Device ++openDevice :: Maybe String -> IO (Maybe Device) + openDevice maybeDeviceSpec = +- checkError isDevice $ ++ fmap unmarshalDevice $ + maybe (alcOpenDevice nullPtr) -- use preferred device +- (flip withALString alcOpenDevice) ++ (flip withALCString alcOpenDevice) + maybeDeviceSpec + + foreign import CALLCONV unsafe "alcOpenDevice" +- alcOpenDevice :: Ptr ALubyte -> IO Device ++ alcOpenDevice :: Ptr ALCchar -> IO ALCdevice ++ ++-------------------------------------------------------------------------------- + +--- | Closes the given device. ++-- | Contains 'Just' the specifier string for the default device or 'Nothing' if ++-- there is no sound support at all. + +-foreign import CALLCONV unsafe "alcCloseDevice" +- closeDevice :: Device -> IO () ++defaultDeviceSpecifier :: GettableStateVar (Maybe String) ++defaultDeviceSpecifier = makeGettableStateVar $ ++ getStringRaw Nothing DefaultDeviceSpecifier >>= maybePeek peekALCString + + -------------------------------------------------------------------------------- + ++-- | Contains the specifier string for the given device. ++ + deviceSpecifier :: Device -> GettableStateVar String + deviceSpecifier device = makeGettableStateVar $ +- alcGetString (Just device) DeviceSpecifier +- +--------------------------------------------------------------------------------- +- +-alcVersion :: Device -> GettableStateVar (ALint, ALint) -- ToDo: Without Device????? +-alcVersion device = makeGettableStateVar $ +- liftM2 (,) (getInteger device MajorVersion) (getInteger device MinorVersion) ++ getString (Just device) DeviceSpecifier + + -------------------------------------------------------------------------------- + +-defaultDeviceSpecifier :: GettableStateVar String +-defaultDeviceSpecifier = makeGettableStateVar $ +- alcGetString Nothing DefaultDeviceSpecifier ++-- | Contains a list of specifiers for all available devices. + + allDeviceSpecifiers :: GettableStateVar [String] + allDeviceSpecifiers = makeGettableStateVar $ do +- enumExtPresent <- alcIsExtensionPresent Nothing "ALC_ENUMERATION_EXT" ++ enumExtPresent <- get (alcIsExtensionPresent Nothing "ALC_ENUMERATION_EXT") + if enumExtPresent +- then do +- ptr <- alcGetString_ Nothing DeviceSpecifier +- return [] -- Todo!!!!! +- else liftM (\s -> [s]) $ get defaultDeviceSpecifier ++ then getStringRaw Nothing DeviceSpecifier >>= peekALCStrings ++ else get defaultDeviceSpecifier >>= (return . maybe [] (\s -> [s])) +diff -uNr --exclude=autom4te.cache --exclude=.cvsignore hugs98-Mar2005-patched/fptools/libraries/OpenAL/Sound/OpenAL/ALC/Errors.hs ghc-6.4.2/libraries/OpenAL/Sound/OpenAL/ALC/Errors.hs +--- hugs98-Mar2005-patched/fptools/libraries/OpenAL/Sound/OpenAL/ALC/Errors.hs 2004-01-03 04:03:09.000000000 +0900 ++++ ghc-6.4.2/libraries/OpenAL/Sound/OpenAL/ALC/Errors.hs 2006-03-22 00:58:03.000000000 +0900 +@@ -1,65 +1,93 @@ + -------------------------------------------------------------------------------- + -- | + -- Module : Sound.OpenAL.ALC.Errors +--- Copyright : (c) Sven Panne 2003-2004 ++-- Copyright : (c) Sven Panne 2003-2005 + -- License : BSD-style (see the file libraries/OpenAL/LICENSE) + -- + -- Maintainer : sven.panne@aedion.de + -- Stability : provisional + -- Portability : portable + -- +--- Errors ++-- This module corresponds to section 6.3.6 (Query for Error Conditions) of the ++-- OpenAL Specification and Reference (version 1.1). + -- + -------------------------------------------------------------------------------- + + module Sound.OpenAL.ALC.Errors ( +- ALCerror(..), alcGetError, checkError ++ ALCError(..), ALCErrorCategory(..), alcErrors + ) where + +-import Sound.OpenAL.ALC.BasicTypes ( ALCenum, Device, fromDevice ) ++import Graphics.Rendering.OpenGL.GL.StateVar ( ++ GettableStateVar, makeGettableStateVar ) ++import Sound.OpenAL.ALC.BasicTypes ( ALCenum ) ++import Sound.OpenAL.ALC.Device ( Device ) ++import Sound.OpenAL.ALC.QueryUtils ( StringQuery(..), getString ) ++import Sound.OpenAL.Constants ( ++ alc_NO_ERROR, alc_INVALID_DEVICE, alc_INVALID_CONTEXT, alc_INVALID_ENUM, ++ alc_INVALID_VALUE, alc_OUT_OF_MEMORY, alc_INVALID_OPERATION ) ++import Sound.OpenAL.Config ( ALCdevice, marshalDevice ) + + -------------------------------------------------------------------------------- + +-#include "HsOpenALConfig.h" ++-- | ALC errors consist of a general error category and a description of what ++-- went wrong. ++ ++data ALCError = ALCError ALCErrorCategory String ++ deriving ( Eq, Ord, Show ) + + -------------------------------------------------------------------------------- + +-data ALCerror = +- ALCInvalidDevice +- | ALCInvalidContext +- | ALCInvalidEnum ++-- | General ALC error categories. ++ ++data ALCErrorCategory = ++ ALCInvalidEnum + | ALCInvalidValue ++ | ALCInvalidOperation ++ | ALCInvalidDevice ++ | ALCInvalidContext + | ALCOutOfMemory + deriving ( Eq, Ord, Show ) + +-unmarshalALCerror :: ALCenum -> ALCerror +-unmarshalALCerror x +- | x == CONST_ALC_INVALID_DEVICE = ALCInvalidDevice +- | x == CONST_ALC_INVALID_CONTEXT = ALCInvalidContext +- | x == CONST_ALC_INVALID_ENUM = ALCInvalidEnum +- | x == CONST_ALC_INVALID_VALUE = ALCInvalidValue +- | x == CONST_ALC_OUT_OF_MEMORY = ALCOutOfMemory +- | otherwise = error ("unmarshalALCerror: illegal value " ++ show x) ++unmarshalALCErrorCategory :: ALCenum -> ALCErrorCategory ++unmarshalALCErrorCategory x ++ | x == alc_INVALID_ENUM = ALCInvalidEnum ++ | x == alc_INVALID_VALUE = ALCInvalidValue ++ | x == alc_INVALID_OPERATION = ALCInvalidOperation ++ | x == alc_INVALID_DEVICE = ALCInvalidDevice ++ | x == alc_INVALID_CONTEXT = ALCInvalidContext ++ | x == alc_OUT_OF_MEMORY = ALCOutOfMemory ++ | otherwise = error ("unmarshalALCErrorCategory: illegal value " ++ show x) + + -------------------------------------------------------------------------------- + +-alcGetError :: Maybe Device -> IO (Maybe ALCerror) -- ToDo: The device is always unused! +-alcGetError device = do +- e <- alcGetError_ (fromDevice device) +- return $ if e == CONST_ALC_NO_ERROR then Nothing else Just (unmarshalALCerror e) ++-- | OpenAL detects only a subset of those conditions that could be considered ++-- errors. This is because in many cases error checking would adversely impact ++-- the performance of an error-free program. The state variable 'alcErrors' is ++-- used to obtain error information. When an error is detected by ALC, a flag is ++-- set and the error code is recorded. Further errors, if they occur, do not ++-- affect this recorded code. When 'alcErrors' is read, the error for the given ++-- device is returned and the flag is cleared, so that a further error will ++-- again record its code. If reading 'alcErrors' returns @\[\]@ then there has ++-- been no detectable error since the last time 'alcErrors' (or since the ALC ++-- was initialized). ++-- ++-- When an error flag is set, results of ALC operations are undefined only if ++-- 'ALCOutOfMemory' has occurred. In other cases, the command generating the ++-- error is ignored so that it has no effect on ALC state or output buffer ++-- contents. If the error generating command returns a value, it returns zero. ++-- If the generating command modifies values through a pointer argument, no ++-- change is made to these values. These error semantics apply only to ALC ++-- errors, not to system errors such as memory access errors. ++ ++alcErrors :: Device -> GettableStateVar [ALCError] ++alcErrors device = ++ makeGettableStateVar $ do ++ c <- alcGetError (marshalDevice device) ++ if c == alc_NO_ERROR ++ then return [] ++ else do ++ s <- getString (Just device) (ALCErrorCategory c) ++ return [ ALCError (unmarshalALCErrorCategory c) s ] + + foreign import CALLCONV unsafe "alcGetError" +- alcGetError_ :: Device -> IO ALCenum +- +--------------------------------------------------------------------------------- +- +--- OpenAL does not always set the error flag, especially for out of memory +--- conditions, so we hack around this fact below. *sigh* +-checkError :: (a -> Bool) -> IO a -> IO a +-checkError predicate action = do +- alcGetError Nothing -- clear error flag +- val <- action +- if predicate val +- then return val +- else do err <- alcGetError Nothing +- ioError . userError . show . maybe ALCOutOfMemory id $ err ++ alcGetError :: ALCdevice -> IO ALCenum +diff -uNr --exclude=autom4te.cache --exclude=.cvsignore hugs98-Mar2005-patched/fptools/libraries/OpenAL/Sound/OpenAL/ALC/Extensions.hs ghc-6.4.2/libraries/OpenAL/Sound/OpenAL/ALC/Extensions.hs +--- hugs98-Mar2005-patched/fptools/libraries/OpenAL/Sound/OpenAL/ALC/Extensions.hs 2004-01-03 04:03:09.000000000 +0900 ++++ ghc-6.4.2/libraries/OpenAL/Sound/OpenAL/ALC/Extensions.hs 2006-03-22 00:58:03.000000000 +0900 +@@ -1,51 +1,86 @@ + -------------------------------------------------------------------------------- + -- | + -- Module : Sound.OpenAL.ALC.Extensions +--- Copyright : (c) Sven Panne 2003-2004 ++-- Copyright : (c) Sven Panne 2003-2005 + -- License : BSD-style (see the file libraries/OpenAL/LICENSE) + -- + -- Maintainer : sven.panne@aedion.de + -- Stability : provisional + -- Portability : portable + -- +--- Extension Handling ++-- This module corresponds to the extension handling parts of section 6.3 ++-- (ALC Queries) of the OpenAL Specification and Reference (version 1.1). + -- + -------------------------------------------------------------------------------- + + module Sound.OpenAL.ALC.Extensions ( +- alcExtensions, alcIsExtensionPresent, alcGetProcAddress, alcGetEnumValue ++ alcExtensions, alcIsExtensionPresent, alcProcAddress, alcEnumValue, ++ alcVersion + ) where + +-import Control.Monad ( liftM ) ++import Control.Monad ( liftM2 ) + import Foreign.Ptr ( Ptr, FunPtr ) + import Graphics.Rendering.OpenGL.GL.StateVar ( + GettableStateVar, makeGettableStateVar ) +-import Sound.OpenAL.AL.BasicTypes +-import Sound.OpenAL.ALC.BasicTypes ( fromDevice, withALString ) ++import Sound.OpenAL.ALC.BasicTypes ( ALCchar, ALCenum, ALCint ) + import Sound.OpenAL.ALC.Device ( Device ) +-import Sound.OpenAL.ALC.Queries ( +- StringQuery(..), alcGetString, alcIsExtensionPresent ) ++import Sound.OpenAL.ALC.QueryUtils ( ++ StringQuery(..), getString, IntQuery(..), getInteger, alcIsExtensionPresent ) ++import Sound.OpenAL.ALC.String ( withALCString ) ++import Sound.OpenAL.Config ( ALCdevice, nullDevice, marshalDevice ) + + -------------------------------------------------------------------------------- + +-alcExtensions :: GettableStateVar [String] +-alcExtensions = makeGettableStateVar $ +- liftM words $ alcGetString Nothing Extensions ++-- | Contains a list of available context extensions. ++ ++alcExtensions :: Device -> GettableStateVar [String] ++alcExtensions device = makeGettableStateVar $ ++ fmap words $ getString (Just device) Extensions + + -------------------------------------------------------------------------------- + +-alcGetProcAddress :: Maybe Device -> String -> IO (FunPtr a) +-alcGetProcAddress device funcName = +- withALString funcName (alcGetProcAddress_ (fromDevice device)) ++-- | The application is expected to verify the applicability of an extension or ++-- core function entry point before requesting it by name, by use of ++-- 'alcIsExtensionPresent'. Extension entry points can be retrieved using ++-- 'alcProcAddress'. Entry points can be device specific, but are not context ++-- specific. Using 'Nothing' as the device does not guarantee that the entry ++-- point is returned, even if available for one of the available devices. ++ ++alcProcAddress :: Maybe Device -> String -> GettableStateVar (FunPtr a) ++alcProcAddress maybeDevice funcName = ++ makeGettableStateVar . ++ withALCString funcName . ++ alcGetProcAddress . marshalDevice . maybe nullDevice id $ maybeDevice + + foreign import CALLCONV unsafe "alcGetProcAddress" +- alcGetProcAddress_ :: Device -> Ptr ALubyte -> IO (FunPtr a) ++ alcGetProcAddress :: ALCdevice -> Ptr ALCchar -> IO (FunPtr a) + + -------------------------------------------------------------------------------- + +-alcGetEnumValue :: Maybe Device -> String -> IO ALenum +-alcGetEnumValue device enumName = +- withALString enumName (alcGetEnumValue_ (fromDevice device)) ++-- | Enumeration\/token values are device independent, but tokens defined for ++-- extensions might not be present for a given device. Using 'Nothing' as the ++-- device is legal, but only the tokens defined by the AL core are ++-- guaranteed. Availability of extension tokens depends on the ALC extension. ++ ++alcEnumValue :: Maybe Device -> String -> GettableStateVar ALCenum ++alcEnumValue maybeDevice enumName = ++ makeGettableStateVar . ++ withALCString enumName . ++ alcGetEnumValue . marshalDevice . maybe nullDevice id $ maybeDevice + + foreign import CALLCONV unsafe "alcGetEnumValue" +- alcGetEnumValue_ :: Device -> Ptr ALubyte -> IO ALenum ++ alcGetEnumValue :: ALCdevice -> Ptr ALCchar -> IO ALCenum ++ ++-------------------------------------------------------------------------------- ++ ++-- | Contains the \"/major/./minor/\" specification revision for this implementation. ++ ++alcVersion :: GettableStateVar String ++alcVersion = ++ makeGettableStateVar $ ++ liftM2 makeVersionString ++ (getInteger Nothing MajorVersion) ++ (getInteger Nothing MinorVersion) ++ ++makeVersionString :: ALCint -> ALCint -> String ++makeVersionString major minor = show major ++ "." ++ show minor +diff -uNr --exclude=autom4te.cache --exclude=.cvsignore hugs98-Mar2005-patched/fptools/libraries/OpenAL/Sound/OpenAL/ALC/Queries.hs ghc-6.4.2/libraries/OpenAL/Sound/OpenAL/ALC/Queries.hs +--- hugs98-Mar2005-patched/fptools/libraries/OpenAL/Sound/OpenAL/ALC/Queries.hs 2004-01-03 04:03:09.000000000 +0900 ++++ ghc-6.4.2/libraries/OpenAL/Sound/OpenAL/ALC/Queries.hs 1970-01-01 09:00:00.000000000 +0900 +@@ -1,99 +0,0 @@ +--- #hide +--------------------------------------------------------------------------------- +--- | +--- Module : Sound.OpenAL.ALC.Queries +--- Copyright : (c) Sven Panne 2003-2004 +--- License : BSD-style (see the file libraries/OpenAL/LICENSE) +--- +--- Maintainer : sven.panne@aedion.de +--- Stability : provisional +--- Portability : portable +--- +--------------------------------------------------------------------------------- +- +-module Sound.OpenAL.ALC.Queries ( +- StringQuery(..), alcGetString, alcGetString_, +- IntQuery(..), marshalIntQuery, getInteger, getIntegerv, +- alcIsExtensionPresent +-) where +- +-import Control.Monad ( liftM, when ) +-import Foreign +-import Sound.OpenAL.AL.BasicTypes ( ALubyte, ALint, ALenum, ALsizei ) +-import Sound.OpenAL.AL.ALboolean ( ALboolean, unmarshalALboolean ) +-import Sound.OpenAL.ALC.BasicTypes ( +- Device, fromDevice, withALString, peekALString ) +- +--------------------------------------------------------------------------------- +- +-#include "HsOpenALConfig.h" +- +--------------------------------------------------------------------------------- +- +-data StringQuery = +- DefaultDeviceSpecifier +- | DeviceSpecifier +- | Extensions +- +-marshalStringQuery :: StringQuery -> ALenum +-marshalStringQuery x = case x of +- DefaultDeviceSpecifier -> CONST_ALC_DEFAULT_DEVICE_SPECIFIER +- DeviceSpecifier -> CONST_ALC_DEVICE_SPECIFIER +- Extensions -> CONST_ALC_EXTENSIONS +- +--------------------------------------------------------------------------------- +- +-alcGetString :: Maybe Device -> StringQuery -> IO String +-alcGetString device query = alcGetString_ device query >>= peekALString +- +-alcGetString_ :: Maybe Device -> StringQuery -> IO (Ptr ALubyte) +-alcGetString_ device = alcGetString__ (fromDevice device) . marshalStringQuery +- +-foreign import CALLCONV unsafe "alcGetString" +- alcGetString__ :: Device -> ALenum -> IO (Ptr ALubyte) +- +--------------------------------------------------------------------------------- +- +-data IntQuery = +- MajorVersion +- | MinorVersion +- | AttributesSize +- | AllAttributes +- +-marshalIntQuery :: IntQuery -> ALenum +-marshalIntQuery x = case x of +- MajorVersion -> CONST_ALC_MAJOR_VERSION +- MinorVersion -> CONST_ALC_MINOR_VERSION +- AttributesSize -> CONST_ALC_ATTRIBUTES_SIZE +- AllAttributes -> CONST_ALC_ALL_ATTRIBUTES +- +--------------------------------------------------------------------------------- +- +-getInteger :: Device -> IntQuery -> IO ALint +-getInteger device query = liftM head $ getIntegerv device query 1 +- +--- We are extremely careful below to avoid segfaults in case that there is no +--- current context, an invalid device, etc. +-getIntegerv :: Device -> IntQuery -> Int -> IO [ALint] +-getIntegerv device query numALints = +- withArray (replicate numALints 0) $ \buf -> do +- let numBytes = fromIntegral (numALints * sizeOf (0 :: ALint)) +- when (numALints > 0) $ +- alcGetIntegerv device (marshalIntQuery query) numBytes buf +- peekArray numALints buf +- +-foreign import CALLCONV unsafe "alcGetIntegerv" +- alcGetIntegerv :: Device -> ALenum -> ALsizei -> Ptr ALint -> IO () +- +--------------------------------------------------------------------------------- +- +--- | Returns 'True' if the given ALC extension is present on the given device, +--- 'False' otherwise. +- +-alcIsExtensionPresent :: Maybe Device -> String -> IO Bool +-alcIsExtensionPresent device extensionName = +- liftM unmarshalALboolean $ +- withALString extensionName (alcIsExtensionPresent_ (fromDevice device)) +- +-foreign import CALLCONV unsafe "alcIsExtensionPresent" +- alcIsExtensionPresent_ :: Device -> Ptr ALubyte -> IO ALboolean +diff -uNr --exclude=autom4te.cache --exclude=.cvsignore hugs98-Mar2005-patched/fptools/libraries/OpenAL/Sound/OpenAL/ALC/QueryUtils.hs ghc-6.4.2/libraries/OpenAL/Sound/OpenAL/ALC/QueryUtils.hs +--- hugs98-Mar2005-patched/fptools/libraries/OpenAL/Sound/OpenAL/ALC/QueryUtils.hs 1970-01-01 09:00:00.000000000 +0900 ++++ ghc-6.4.2/libraries/OpenAL/Sound/OpenAL/ALC/QueryUtils.hs 2006-03-22 00:58:03.000000000 +0900 +@@ -0,0 +1,122 @@ ++-- #hide ++-------------------------------------------------------------------------------- ++-- | ++-- Module : Sound.OpenAL.ALC.QueryUtils ++-- Copyright : (c) Sven Panne 2003-2005 ++-- License : BSD-style (see the file libraries/OpenAL/LICENSE) ++-- ++-- Maintainer : sven.panne@aedion.de ++-- Stability : provisional ++-- Portability : portable ++-- ++-------------------------------------------------------------------------------- ++ ++module Sound.OpenAL.ALC.QueryUtils ( ++ StringQuery(..), getString, getStringRaw, ++ IntQuery(..), marshalIntQuery, getInteger, getIntegerv, ++ alcIsExtensionPresent ++) where ++ ++import Control.Monad ( when ) ++import Foreign.Marshal.Array ( withArray, peekArray ) ++import Foreign.Ptr ( Ptr ) ++import Graphics.Rendering.OpenGL.GL.StateVar ( ++ GettableStateVar, makeGettableStateVar ) ++import Sound.OpenAL.ALC.ALCboolean ( unmarshalALCboolean ) ++import Sound.OpenAL.ALC.BasicTypes ( ++ ALCboolean, ALCchar, ALCint, ALCenum, ALCsizei ) ++import Sound.OpenAL.ALC.String ( withALCString, peekALCString ) ++import Sound.OpenAL.Config ( Device, ALCdevice, nullDevice, marshalDevice ) ++import Sound.OpenAL.Constants ( ++ alc_DEFAULT_DEVICE_SPECIFIER, alc_DEVICE_SPECIFIER, alc_EXTENSIONS, ++ alc_CAPTURE_DEFAULT_DEVICE_SPECIFIER, alc_CAPTURE_DEVICE_SPECIFIER, ++ alc_ATTRIBUTES_SIZE, alc_ALL_ATTRIBUTES, alc_MAJOR_VERSION, ++ alc_MINOR_VERSION, alc_CAPTURE_SAMPLES ) ++ ++-------------------------------------------------------------------------------- ++ ++data StringQuery = ++ DefaultDeviceSpecifier ++ | DeviceSpecifier ++ | Extensions ++ | CaptureDefaultDeviceSpecifier ++ | CaptureDeviceSpecifier ++ | ALCErrorCategory ALCenum ++ ++marshalStringQuery :: StringQuery -> ALCenum ++marshalStringQuery x = case x of ++ DefaultDeviceSpecifier -> alc_DEFAULT_DEVICE_SPECIFIER ++ DeviceSpecifier -> alc_DEVICE_SPECIFIER ++ Extensions -> alc_EXTENSIONS ++ CaptureDefaultDeviceSpecifier -> alc_CAPTURE_DEFAULT_DEVICE_SPECIFIER ++ CaptureDeviceSpecifier -> alc_CAPTURE_DEVICE_SPECIFIER ++ ALCErrorCategory e -> e ++ ++-------------------------------------------------------------------------------- ++ ++getString :: Maybe Device -> StringQuery -> IO String ++getString device query = getStringRaw device query >>= peekALCString ++ ++getStringRaw :: Maybe Device -> StringQuery -> IO (Ptr ALCchar) ++getStringRaw maybeDevice = ++ alcGetString (marshalMaybeDevice maybeDevice) . marshalStringQuery ++ ++marshalMaybeDevice :: Maybe Device -> ALCdevice ++marshalMaybeDevice = marshalDevice . maybe nullDevice id ++ ++foreign import CALLCONV unsafe "alcGetString" ++ alcGetString :: ALCdevice -> ALCenum -> IO (Ptr ALCchar) ++ ++-------------------------------------------------------------------------------- ++ ++data IntQuery = ++ AttributesSize ++ | AllAttributes ++ | MajorVersion ++ | MinorVersion ++ | CaptureSamples ++ ++marshalIntQuery :: IntQuery -> ALCenum ++marshalIntQuery x = case x of ++ AttributesSize -> alc_ATTRIBUTES_SIZE ++ AllAttributes -> alc_ALL_ATTRIBUTES ++ MajorVersion -> alc_MAJOR_VERSION ++ MinorVersion -> alc_MINOR_VERSION ++ CaptureSamples -> alc_CAPTURE_SAMPLES ++ ++-------------------------------------------------------------------------------- ++ ++getInteger :: Maybe Device -> IntQuery -> IO ALCint ++getInteger maybeDevice query = fmap head $ getIntegerv maybeDevice query 1 ++ ++-- We are extremely careful below to avoid segfaults in case that there is no ++-- current context, an invalid device, etc. ++getIntegerv :: Maybe Device -> IntQuery -> ALCsizei -> IO [ALCint] ++getIntegerv maybeDevice query numALCints = ++ let n = fromIntegral numALCints ++ in withArray (replicate n 0) $ \buf -> do ++ when (numALCints > 0) $ ++ alcGetIntegerv (marshalMaybeDevice maybeDevice) ++ (marshalIntQuery query) numALCints buf ++ peekArray n buf ++ ++foreign import CALLCONV unsafe "alcGetIntegerv" ++ alcGetIntegerv :: ALCdevice -> ALCenum -> ALCsizei -> Ptr ALCint -> IO () ++ ++-------------------------------------------------------------------------------- ++ ++-- | To verify that a given extension is available for the current context and ++-- the device it is associated with, use 'alcIsExtensionPresent'. For invalid ++-- and unsupported string tokens it contains 'False'. Using 'Nothing' as the ++-- device is acceptable. The extension name is not case sensitive: The ++-- implementation will convert the name to all upper-case internally (and will ++-- express extension names in upper-case). ++ ++alcIsExtensionPresent :: Maybe Device -> String -> GettableStateVar Bool ++alcIsExtensionPresent maybeDevice extensionName = makeGettableStateVar $ ++ fmap unmarshalALCboolean $ ++ withALCString extensionName $ ++ alcIsExtensionPresent_ (marshalMaybeDevice maybeDevice) ++ ++foreign import CALLCONV unsafe "alcIsExtensionPresent" ++ alcIsExtensionPresent_ :: ALCdevice -> Ptr ALCchar -> IO ALCboolean +diff -uNr --exclude=autom4te.cache --exclude=.cvsignore hugs98-Mar2005-patched/fptools/libraries/OpenAL/Sound/OpenAL/ALC/String.hs ghc-6.4.2/libraries/OpenAL/Sound/OpenAL/ALC/String.hs +--- hugs98-Mar2005-patched/fptools/libraries/OpenAL/Sound/OpenAL/ALC/String.hs 1970-01-01 09:00:00.000000000 +0900 ++++ ghc-6.4.2/libraries/OpenAL/Sound/OpenAL/ALC/String.hs 2006-03-22 00:58:03.000000000 +0900 +@@ -0,0 +1,42 @@ ++-- #hide ++-------------------------------------------------------------------------------- ++-- | ++-- Module : Sound.OpenAL.ALC.String ++-- Copyright : (c) Sven Panne 2005 ++-- License : BSD-style (see the file libraries/OpenAL/LICENSE) ++-- ++-- Maintainer : sven.panne@aedion.de ++-- Stability : provisional ++-- Portability : portable ++-- ++-------------------------------------------------------------------------------- ++ ++module Sound.OpenAL.ALC.String ( ++ withALCString, peekALCString, peekALCStrings ++) where ++ ++import Foreign.C.String ( withCString, peekCString ) ++import Foreign.Marshal.Array ( lengthArray0 ) ++import Foreign.Ptr ( Ptr, castPtr, plusPtr ) ++import Sound.OpenAL.ALC.BasicTypes ( ALCchar ) ++ ++-------------------------------------------------------------------------------- ++ ++-- AL uses "Ptr ALCchar" instead of "CString" for strings, so some wrappers ++-- are quite handy. ++ ++withALCString :: String -> (Ptr ALCchar -> IO a) -> IO a ++withALCString str action = withCString str (action . castPtr) ++ ++peekALCString :: Ptr ALCchar -> IO String ++peekALCString = peekCString . castPtr ++ ++peekALCStrings :: Ptr ALCchar -> IO [String] ++peekALCStrings ptr = loop ptr [] ++ where loop p strs = do ++ str <- peekALCString p ++ if str == "" ++ then return (reverse strs) ++ else do ++ len <- lengthArray0 0 p ++ loop (p `plusPtr` (len + 1)) (str : strs) +diff -uNr --exclude=autom4te.cache --exclude=.cvsignore hugs98-Mar2005-patched/fptools/libraries/OpenAL/Sound/OpenAL/ALC.hs ghc-6.4.2/libraries/OpenAL/Sound/OpenAL/ALC.hs +--- hugs98-Mar2005-patched/fptools/libraries/OpenAL/Sound/OpenAL/ALC.hs 2004-01-03 04:03:07.000000000 +0900 ++++ ghc-6.4.2/libraries/OpenAL/Sound/OpenAL/ALC.hs 2006-03-22 00:58:03.000000000 +0900 +@@ -1,7 +1,7 @@ + -------------------------------------------------------------------------------- + -- | + -- Module : Sound.OpenAL.ALC +--- Copyright : (c) Sven Panne 2003-2004 ++-- Copyright : (c) Sven Panne 2003-2005 + -- License : BSD-style (see the file libraries/OpenAL/LICENSE) + -- + -- Maintainer : sven.panne@aedion.de +@@ -9,18 +9,27 @@ + -- Portability : portable + -- + -- This module corresponds to chapter 6 (AL Contexts and the ALC API) of the +--- OpenAL Specification and Reference (version 1.0). ++-- OpenAL Specification and Reference (version 1.1). ++-- ++-- ALC is a portable API for managing OpenAL contexts, including resource ++-- sharing, locking, and unlocking. Within the core AL API the existence of a ++-- context is implied, but the context is not exposed. The context encapsulates ++-- the state of a given instance of the AL state machine. + -- + -------------------------------------------------------------------------------- + + module Sound.OpenAL.ALC ( ++ module Sound.OpenAL.ALC.BasicTypes, + module Sound.OpenAL.ALC.Device, + module Sound.OpenAL.ALC.Context, + module Sound.OpenAL.ALC.Extensions, +- module Sound.OpenAL.ALC.Errors ++ module Sound.OpenAL.ALC.Errors, ++ module Sound.OpenAL.ALC.Capture + ) where + ++import Sound.OpenAL.ALC.BasicTypes + import Sound.OpenAL.ALC.Device + import Sound.OpenAL.ALC.Context + import Sound.OpenAL.ALC.Extensions + import Sound.OpenAL.ALC.Errors ++import Sound.OpenAL.ALC.Capture +diff -uNr --exclude=autom4te.cache --exclude=.cvsignore hugs98-Mar2005-patched/fptools/libraries/OpenAL/Sound/OpenAL/ALUT/Exception.hs ghc-6.4.2/libraries/OpenAL/Sound/OpenAL/ALUT/Exception.hs +--- hugs98-Mar2005-patched/fptools/libraries/OpenAL/Sound/OpenAL/ALUT/Exception.hs 2004-11-28 00:39:32.000000000 +0900 ++++ ghc-6.4.2/libraries/OpenAL/Sound/OpenAL/ALUT/Exception.hs 1970-01-01 09:00:00.000000000 +0900 +@@ -1,37 +0,0 @@ +--- #hide +--------------------------------------------------------------------------------- +--- | +--- Module : Sound.OpenAL.ALUT.Exception +--- Copyright : (c) Sven Panne 2003-2004 +--- License : BSD-style (see the file libraries/OpenGL/LICENSE) +--- +--- Maintainer : sven.panne@aedion.de +--- Stability : provisional +--- Portability : portable +--- +--- This is a purely internal module to compensate for differences between +--- Haskell implementations. +--- +--------------------------------------------------------------------------------- +- +-module Sound.OpenAL.ALUT.Exception ( +- bracket_, finally +-) where +- +-#ifdef __NHC__ +-finally :: IO a -> IO b -> IO a +-a `finally` sequel = do +- r <- a +- sequel +- return r +- +-{-# INLINE bracket_ #-} +-bracket_ :: IO a -> IO b -> IO c -> IO c +-bracket_ before after thing = do +- before +- r <- thing +- after +- return r +-#else +-import Control.Exception ( bracket_, finally ) +-#endif +diff -uNr --exclude=autom4te.cache --exclude=.cvsignore hugs98-Mar2005-patched/fptools/libraries/OpenAL/Sound/OpenAL/ALUT/Initialization.hs ghc-6.4.2/libraries/OpenAL/Sound/OpenAL/ALUT/Initialization.hs +--- hugs98-Mar2005-patched/fptools/libraries/OpenAL/Sound/OpenAL/ALUT/Initialization.hs 2004-11-28 00:39:32.000000000 +0900 ++++ ghc-6.4.2/libraries/OpenAL/Sound/OpenAL/ALUT/Initialization.hs 1970-01-01 09:00:00.000000000 +0900 +@@ -1,40 +0,0 @@ +--------------------------------------------------------------------------------- +--- | +--- Module : Sound.OpenAL.ALUT.Initialization +--- Copyright : (c) Sven Panne 2003-2004 +--- License : BSD-style (see the file libraries/OpenAL/LICENSE) +--- +--- Maintainer : sven.panne@aedion.de +--- Stability : provisional +--- Portability : portable +--- +--------------------------------------------------------------------------------- +- +-module Sound.OpenAL.ALUT.Initialization ( +- runOpenAL +-) where +- +-import Graphics.Rendering.OpenGL.GL.StateVar ( HasGetter(get), HasSetter(($=)) ) +-import Sound.OpenAL.ALUT.Exception ( bracket_ ) +-import Sound.OpenAL.ALC.Context ( +- createContext, destroyContext, currentContext, contextsDevice ) +-import Sound.OpenAL.ALC.Device ( openDevice, closeDevice ) +- +--------------------------------------------------------------------------------- +- +-alutInit :: IO () +-alutInit = do +- device <- openDevice Nothing +- context <- createContext device [] +- currentContext $= Just context +- +-alutExit :: IO () +-alutExit = get currentContext >>= maybe (return ()) cleanupContext +- where cleanupContext context = do +- maybeDevice <- get (contextsDevice context) +- currentContext $= Nothing +- destroyContext context +- maybe (return ()) closeDevice maybeDevice +- +-runOpenAL :: IO a -> IO a +-runOpenAL = bracket_ alutInit alutExit +diff -uNr --exclude=autom4te.cache --exclude=.cvsignore hugs98-Mar2005-patched/fptools/libraries/OpenAL/Sound/OpenAL/ALUT/WAV.hs ghc-6.4.2/libraries/OpenAL/Sound/OpenAL/ALUT/WAV.hs +--- hugs98-Mar2005-patched/fptools/libraries/OpenAL/Sound/OpenAL/ALUT/WAV.hs 2004-05-12 04:36:48.000000000 +0900 ++++ ghc-6.4.2/libraries/OpenAL/Sound/OpenAL/ALUT/WAV.hs 1970-01-01 09:00:00.000000000 +0900 +@@ -1,70 +0,0 @@ +--------------------------------------------------------------------------------- +--- | +--- Module : Sound.OpenAL.ALUT.WAV +--- Copyright : (c) Sven Panne 2003-2004 +--- License : BSD-style (see the file libraries/OpenAL/LICENSE) +--- +--- Maintainer : sven.panne@aedion.de +--- Stability : provisional +--- Portability : portable +--- +--------------------------------------------------------------------------------- +- +-module Sound.OpenAL.ALUT.WAV ( +- withWAVFile, withWAVMemory +-) where +- +-import Control.Monad ( liftM ) +-import Foreign.C.String ( withCString ) +-import Foreign.Marshal.Alloc ( alloca ) +-import Foreign.Storable ( Storable(peek) ) +-import Foreign.Ptr ( Ptr, castPtr ) +-import Sound.OpenAL.AL.BasicTypes ( ALbyte, ALsizei, ALenum ) +-import Sound.OpenAL.AL.ALboolean ( ALboolean, unmarshalALboolean ) +-import Sound.OpenAL.AL.Buffer ( BufferData(..) ) +-import Sound.OpenAL.AL.Format ( marshalFormat, unmarshalFormat ) +-import Sound.OpenAL.ALUT.Exception ( finally ) +- +--------------------------------------------------------------------------------- +- +-withWAVFile :: FilePath -> (BufferData a -> Bool -> IO b) -> IO b +-withWAVFile fileName action = +- withCString fileName $ \fileNameBuf -> +- withWAVInternal (alutLoadWAVFile (castPtr fileNameBuf)) action +- +-foreign import CALLCONV unsafe "alutLoadWAVFile" +- alutLoadWAVFile :: Ptr ALbyte -> Loader a +- +-withWAVMemory :: Ptr ALbyte -> (BufferData a -> Bool -> IO b) -> IO b +-withWAVMemory mem action = withWAVInternal (alutLoadWAVMemory mem) action +- +-foreign import CALLCONV unsafe "alutLoadWAVMemory" +- alutLoadWAVMemory :: Ptr ALbyte -> Loader a +- +-type Loader a = Ptr ALenum -> Ptr (Ptr a) -> Ptr ALsizei -> Ptr ALsizei +- -> Ptr ALboolean -> IO () +- +-withWAVInternal :: Loader a -> (BufferData a -> Bool -> IO b) -> IO b +-withWAVInternal loader action = do +- (bufferData, loop) <- alloca $ \formatBuf -> +- alloca $ \rawBuf -> +- alloca $ \sizeBuf -> +- alloca $ \frequencyBuf -> +- alloca $ \loopBuf -> do +- loader formatBuf rawBuf sizeBuf frequencyBuf loopBuf +- format <- liftM unmarshalFormat $ peek formatBuf +- raw <- peek rawBuf +- size <- peek sizeBuf +- frequency <- peek frequencyBuf +- loop <- liftM unmarshalALboolean $ peek loopBuf +- return (BufferData format raw size frequency, loop) +- action bufferData loop `finally` unloadWAV bufferData +- +--------------------------------------------------------------------------------- +- +-unloadWAV :: BufferData a -> IO () +-unloadWAV (BufferData format raw size frequency) = +- alutUnloadWAV (marshalFormat format) raw size frequency +- +-foreign import CALLCONV unsafe "alutUnloadWAV" +- alutUnloadWAV :: ALenum -> Ptr a -> ALsizei -> ALsizei -> IO () +diff -uNr --exclude=autom4te.cache --exclude=.cvsignore hugs98-Mar2005-patched/fptools/libraries/OpenAL/Sound/OpenAL/ALUT.hs ghc-6.4.2/libraries/OpenAL/Sound/OpenAL/ALUT.hs +--- hugs98-Mar2005-patched/fptools/libraries/OpenAL/Sound/OpenAL/ALUT.hs 2004-01-03 04:03:07.000000000 +0900 ++++ ghc-6.4.2/libraries/OpenAL/Sound/OpenAL/ALUT.hs 1970-01-01 09:00:00.000000000 +0900 +@@ -1,19 +0,0 @@ +--------------------------------------------------------------------------------- +--- | +--- Module : Sound.OpenAL.ALUT +--- Copyright : (c) Sven Panne 2003-2004 +--- License : BSD-style (see the file libraries/OpenAL/LICENSE) +--- +--- Maintainer : sven.panne@aedion.de +--- Stability : provisional +--- Portability : portable +--- +--------------------------------------------------------------------------------- +- +-module Sound.OpenAL.ALUT ( +- module Sound.OpenAL.ALUT.Initialization, +- module Sound.OpenAL.ALUT.WAV +-) where +- +-import Sound.OpenAL.ALUT.Initialization +-import Sound.OpenAL.ALUT.WAV +diff -uNr --exclude=autom4te.cache --exclude=.cvsignore hugs98-Mar2005-patched/fptools/libraries/OpenAL/Sound/OpenAL/Config.hs ghc-6.4.2/libraries/OpenAL/Sound/OpenAL/Config.hs +--- hugs98-Mar2005-patched/fptools/libraries/OpenAL/Sound/OpenAL/Config.hs 1970-01-01 09:00:00.000000000 +0900 ++++ ghc-6.4.2/libraries/OpenAL/Sound/OpenAL/Config.hs 2006-03-22 00:58:03.000000000 +0900 +@@ -0,0 +1,233 @@ ++-- #hide ++-------------------------------------------------------------------------------- ++-- | ++-- Module : Sound.OpenAL.Config ++-- Copyright : (c) Sven Panne 2005 ++-- License : BSD-style (see the file libraries/OpenAL/LICENSE) ++-- ++-- Maintainer : sven.panne@aedion.de ++-- Stability : provisional ++-- Portability : portable ++-- ++-- This purely internal module defines the platform-specific stuff which has ++-- been figured out by configure. ++-- ++-------------------------------------------------------------------------------- ++ ++module Sound.OpenAL.Config ( ++ -- AL types ++ ALboolean, ALchar, ALbyte, ALubyte, ALshort, ALushort, ALint, ALuint, ++ ALsizei, ALenum, ALfloat, ALdouble, ++ ++ -- ALC types ++ ALCboolean, ALCchar, ALCbyte, ALCubyte, ALCshort, ALCushort, ALCint, ALCuint, ++ ALCsizei, ALCenum, ALCfloat, ALCdouble, ++ ++ -- Device stuff ++ ALCdevice, Device, nullDevice, marshalDevice, unmarshalDevice, closeDevice, ++ ++ -- Context stuff ++ ALCcontext, Context, nullContext, marshalContext, unmarshalContext, ++ alcProcessContext, alcMakeContextCurrent, alcDestroyContext ++) where ++ ++import Data.Int ++import Data.Word ++import Foreign.Ptr ( Ptr, nullPtr ) ++ ++-------------------------------------------------------------------------------- ++ ++#include "HsOpenALConfig.h" ++ ++-------------------------------------------------------------------------------- ++-- AL types ++ ++-- | 8-bit boolean ++type ALboolean = HTYPE_ALBOOLEAN ++ ++-- | Character ++type ALchar = HTYPE_ALCHAR ++ ++-- | Signed 8-bit 2\'s complement integer ++type ALbyte = HTYPE_ALBYTE ++ ++-- | Unsigned 8-bit integer ++type ALubyte = HTYPE_ALUBYTE ++ ++-- | Signed 16-bit 2\'s complement integer ++type ALshort = HTYPE_ALSHORT ++ ++-- | Unsigned 16-bit integer ++type ALushort = HTYPE_ALUSHORT ++ ++-- | Signed 32-bit 2\'s complement integer ++type ALint = HTYPE_ALINT ++ ++-- | Unsigned 32-bit integer ++type ALuint = HTYPE_ALUINT ++ ++-- | Non-negatitve 32-bit binary integer size ++type ALsizei = HTYPE_ALSIZEI ++ ++-- | Enumerated 32-bit value ++type ALenum = HTYPE_ALENUM ++ ++-- | 32-bit IEEE754 floating-point ++type ALfloat = HTYPE_ALFLOAT ++ ++-- | 64-bit IEEE754 floating-point ++type ALdouble = HTYPE_ALDOUBLE ++ ++-------------------------------------------------------------------------------- ++-- ALC types ++ ++-- | 8-bit boolean ++type ALCboolean = HTYPE_ALCBOOLEAN ++ ++-- | Character ++type ALCchar = HTYPE_ALCCHAR ++ ++-- | Signed 8-bit 2\'s complement integer ++type ALCbyte = HTYPE_ALCBYTE ++ ++-- | Unsigned 8-bit integer ++type ALCubyte = HTYPE_ALCUBYTE ++ ++-- | Signed 16-bit 2\'s complement integer ++type ALCshort = HTYPE_ALCSHORT ++ ++-- | Unsigned 16-bit integer ++type ALCushort = HTYPE_ALCUSHORT ++ ++-- | Signed 32-bit 2\'s complement integer ++type ALCint = HTYPE_ALCINT ++ ++-- | Unsigned 32-bit integer ++type ALCuint = HTYPE_ALCUINT ++ ++-- | Non-negatitve 32-bit binary integer size ++type ALCsizei = HTYPE_ALCSIZEI ++ ++-- | Enumerated 32-bit value ++type ALCenum = HTYPE_ALCENUM ++ ++-- | 32-bit IEEE754 floating-point ++type ALCfloat = HTYPE_ALCFLOAT ++ ++-- | 64-bit IEEE754 floating-point ++type ALCdouble = HTYPE_ALCDOUBLE ++ ++-------------------------------------------------------------------------------- ++-- In OpenAL 1.1, alcCloseDevice() returns an ALCboolean, before it was void. ++-- To break a dependency cycle, we have to define the Device type here, too. ++ ++-- | The abstract device type. ++ ++newtype Device = Device ALCdevice ++ deriving ( Eq, Ord, Show ) ++ ++newtype ALCdevice = ALCdevice (Ptr ALCdevice) ++ deriving ( Eq, Ord, Show ) ++ ++nullDevice :: Device ++nullDevice = Device (ALCdevice nullPtr) ++ ++marshalDevice :: Device -> ALCdevice ++marshalDevice (Device device) = device ++ ++unmarshalDevice :: ALCdevice -> Maybe Device ++unmarshalDevice device = ++ if device == marshalDevice nullDevice then Nothing else Just (Device device) ++ ++-- | 'closeDevice' allows the application (i.e. the client program) to ++-- disconnect from a device (i.e. the server). It returns 'True' for success and ++-- 'False' for failure. Once closed, the 'Device' is invalid. ++-- ++-- /Note:/ Older OpenAL implementations will always report a success! ++ ++closeDevice :: Device -> IO Bool ++ ++#if ALCCLOSEDEVICE_VOID ++ ++closeDevice = fmap (const True) . alcCloseDevice . marshalDevice ++ ++foreign import CALLCONV unsafe "alcCloseDevice" ++ alcCloseDevice :: ALCdevice -> IO () ++ ++#else ++ ++-- inlined unmarshalALCboolean here to break dependency cycle ++closeDevice = fmap (/= CONST_ALC_FALSE) . alcCloseDevice . marshalDevice ++ ++foreign import CALLCONV unsafe "alcCloseDevice" ++ alcCloseDevice :: ALCdevice -> IO ALCboolean ++ ++#endif ++ ++-------------------------------------------------------------------------------- ++-- In OpenAL 1.1, alcProcessContext() returns void for all platforms, before it ++-- returned ALCcontext* on Linux. To break a dependency cycle, we have to define ++-- the Context type here, too. ++ ++-- | The abstract context type. ++ ++data Context = Context ALCcontext ++ deriving ( Eq, Ord, Show ) ++ ++newtype ALCcontext = ALCcontext (Ptr ALCcontext) ++ deriving ( Eq, Ord, Show ) ++ ++nullContext :: Context ++nullContext = Context (ALCcontext nullPtr) ++ ++marshalContext :: Context -> ALCcontext ++marshalContext (Context context) = context ++ ++unmarshalContext :: ALCcontext -> Maybe Context ++unmarshalContext context = ++ if context == marshalContext nullContext then Nothing else Just (Context context) ++ ++#if ALCPROCESSCONTEXT_VOID ++ ++foreign import CALLCONV unsafe "alcProcessContext" ++ alcProcessContext :: ALCcontext -> IO () ++ ++#else ++ ++foreign import CALLCONV unsafe "alcProcessContext" ++ alcProcessContext :: ALCcontext -> IO ALCcontext ++ ++#endif ++ ++-------------------------------------------------------------------------------- ++-- In OpenAL 1.1, alcMakeContextCurrent() returns void, before it was ALCenum on ++-- Linux and ALCboolean on other platforms. Currently we default to ALCenum in ++-- the latter case. ++ ++#if ALCMAKECONTEXTCURRENT_VOID ++ ++foreign import CALLCONV unsafe "alcMakeContextCurrent" ++ alcMakeContextCurrent :: ALCcontext -> IO () ++ ++#else ++ ++foreign import CALLCONV unsafe "alcMakeContextCurrent" ++ alcMakeContextCurrent :: ALCcontext -> IO ALCenum ++ ++#endif ++ ++-------------------------------------------------------------------------------- ++-- In OpenAL 1.1, alcDestroyContext() returns void, before it returned ALCenum ++-- on Linux. ++ ++#if ALCDESTROYCONTEXT_VOID ++ ++foreign import CALLCONV unsafe "alcDestroyContext" ++ alcDestroyContext :: ALCcontext -> IO () ++ ++#else ++ ++foreign import CALLCONV unsafe "alcDestroyContext" ++ alcDestroyContext :: ALCcontext -> IO ALCenum ++ ++#endif +diff -uNr --exclude=autom4te.cache --exclude=.cvsignore hugs98-Mar2005-patched/fptools/libraries/OpenAL/Sound/OpenAL/Constants.hs ghc-6.4.2/libraries/OpenAL/Sound/OpenAL/Constants.hs +--- hugs98-Mar2005-patched/fptools/libraries/OpenAL/Sound/OpenAL/Constants.hs 1970-01-01 09:00:00.000000000 +0900 ++++ ghc-6.4.2/libraries/OpenAL/Sound/OpenAL/Constants.hs 2006-03-22 00:58:03.000000000 +0900 +@@ -0,0 +1,166 @@ ++-- #hide ++-------------------------------------------------------------------------------- ++-- | ++-- Module : Sound.OpenAL.Constants ++-- Copyright : (c) Sven Panne 2005 ++-- License : BSD-style (see the file libraries/OpenAL/LICENSE) ++-- ++-- Maintainer : sven.panne@aedion.de ++-- Stability : provisional ++-- Portability : portable ++-- ++-- This purely internal module defines all AL\/ALC constants, which have been ++-- figured out by configure. In contrast to OpenGL and GLUT, these constants ++-- varied on different platforms in the past and have evolved quite a bit. ++-- ++-------------------------------------------------------------------------------- ++ ++module Sound.OpenAL.Constants where ++ ++import Sound.OpenAL.Config ( ++ ALboolean, ALint, ALenum, ALCboolean, ALCint, ALCenum ) ++ ++-------------------------------------------------------------------------------- ++ ++#include "HsOpenALConfig.h" ++ ++-------------------------------------------------------------------------------- ++ ++al_FALSE, al_TRUE :: ALboolean ++al_FALSE = CONST_AL_FALSE ++al_TRUE = CONST_AL_TRUE ++ ++al_NO_ERROR, al_INVALID_NAME, al_INVALID_ENUM, al_INVALID_VALUE, ++ al_INVALID_OPERATION, al_OUT_OF_MEMORY :: ALenum ++al_NO_ERROR = CONST_AL_NO_ERROR ++al_INVALID_NAME = CONST_AL_INVALID_NAME ++al_INVALID_ENUM = CONST_AL_INVALID_ENUM ++al_INVALID_VALUE = CONST_AL_INVALID_VALUE ++al_INVALID_OPERATION = CONST_AL_INVALID_OPERATION ++al_OUT_OF_MEMORY = CONST_AL_OUT_OF_MEMORY ++ ++-------------------------------------------------------------------------------- ++ ++al_DISTANCE_MODEL, al_DOPPLER_FACTOR, al_SPEED_OF_SOUND :: ALenum ++al_DISTANCE_MODEL = CONST_AL_DISTANCE_MODEL ++al_DOPPLER_FACTOR = CONST_AL_DOPPLER_FACTOR ++al_SPEED_OF_SOUND = CONST_AL_SPEED_OF_SOUND ++ ++al_VERSION, al_RENDERER, al_VENDOR, al_EXTENSIONS :: ALenum ++al_VERSION = CONST_AL_VERSION ++al_RENDERER = CONST_AL_RENDERER ++al_VENDOR = CONST_AL_VENDOR ++al_EXTENSIONS = CONST_AL_EXTENSIONS ++ ++al_NONE, al_INVERSE_DISTANCE, al_INVERSE_DISTANCE_CLAMPED, al_LINEAR_DISTANCE, ++ al_LINEAR_DISTANCE_CLAMPED, al_EXPONENT_DISTANCE, ++ al_EXPONENT_DISTANCE_CLAMPED :: ALenum ++al_NONE = CONST_AL_NONE ++al_INVERSE_DISTANCE = CONST_AL_INVERSE_DISTANCE ++al_INVERSE_DISTANCE_CLAMPED = CONST_AL_INVERSE_DISTANCE_CLAMPED ++al_LINEAR_DISTANCE = CONST_AL_LINEAR_DISTANCE ++al_LINEAR_DISTANCE_CLAMPED = CONST_AL_LINEAR_DISTANCE_CLAMPED ++al_EXPONENT_DISTANCE = CONST_AL_EXPONENT_DISTANCE ++al_EXPONENT_DISTANCE_CLAMPED = CONST_AL_EXPONENT_DISTANCE_CLAMPED ++ ++-------------------------------------------------------------------------------- ++ ++al_POSITION, al_VELOCITY, al_GAIN :: ALenum ++al_POSITION = CONST_AL_POSITION ++al_VELOCITY = CONST_AL_VELOCITY ++al_GAIN = CONST_AL_GAIN ++ ++al_ORIENTATION :: ALenum ++al_ORIENTATION = CONST_AL_ORIENTATION ++ ++al_SOURCE_RELATIVE, al_SOURCE_TYPE, al_LOOPING, al_BUFFER, al_BUFFERS_QUEUED, ++ al_BUFFERS_PROCESSED, al_MIN_GAIN, al_MAX_GAIN, al_REFERENCE_DISTANCE, ++ al_ROLLOFF_FACTOR, al_MAX_DISTANCE, al_PITCH, al_DIRECTION, ++ al_CONE_INNER_ANGLE, al_CONE_OUTER_ANGLE, al_CONE_OUTER_GAIN, al_SEC_OFFSET, ++ al_SAMPLE_OFFSET, al_BYTE_OFFSET, al_SOURCE_STATE :: ALenum ++al_SOURCE_RELATIVE = CONST_AL_SOURCE_RELATIVE ++al_SOURCE_TYPE = CONST_AL_SOURCE_TYPE ++al_LOOPING = CONST_AL_LOOPING ++al_BUFFER = CONST_AL_BUFFER ++al_BUFFERS_QUEUED = CONST_AL_BUFFERS_QUEUED ++al_BUFFERS_PROCESSED = CONST_AL_BUFFERS_PROCESSED ++al_MIN_GAIN = CONST_AL_MIN_GAIN ++al_MAX_GAIN = CONST_AL_MAX_GAIN ++al_REFERENCE_DISTANCE = CONST_AL_REFERENCE_DISTANCE ++al_ROLLOFF_FACTOR = CONST_AL_ROLLOFF_FACTOR ++al_MAX_DISTANCE = CONST_AL_MAX_DISTANCE ++al_PITCH = CONST_AL_PITCH ++al_DIRECTION = CONST_AL_DIRECTION ++al_CONE_INNER_ANGLE = CONST_AL_CONE_INNER_ANGLE ++al_CONE_OUTER_ANGLE = CONST_AL_CONE_OUTER_ANGLE ++al_CONE_OUTER_GAIN = CONST_AL_CONE_OUTER_GAIN ++al_SEC_OFFSET = CONST_AL_SEC_OFFSET ++al_SAMPLE_OFFSET = CONST_AL_SAMPLE_OFFSET ++al_BYTE_OFFSET = CONST_AL_BYTE_OFFSET ++al_SOURCE_STATE = CONST_AL_SOURCE_STATE ++ ++al_UNDETERMINED, al_STATIC, al_STREAMING :: ALint ++al_UNDETERMINED = CONST_AL_UNDETERMINED ++al_STATIC = CONST_AL_STATIC ++al_STREAMING = CONST_AL_STREAMING ++ ++al_INITIAL, al_PLAYING, al_PAUSED, al_STOPPED :: ALint ++al_INITIAL = CONST_AL_INITIAL ++al_PLAYING = CONST_AL_PLAYING ++al_PAUSED = CONST_AL_PAUSED ++al_STOPPED = CONST_AL_STOPPED ++ ++-------------------------------------------------------------------------------- ++ ++al_FREQUENCY, al_SIZE, al_BITS, al_CHANNELS :: ALenum ++al_FREQUENCY = CONST_AL_FREQUENCY ++al_SIZE = CONST_AL_SIZE ++al_BITS = CONST_AL_BITS ++al_CHANNELS = CONST_AL_CHANNELS ++ ++al_FORMAT_MONO8, al_FORMAT_MONO16, al_FORMAT_STEREO8, ++ al_FORMAT_STEREO16 :: ALenum ++al_FORMAT_MONO8 = CONST_AL_FORMAT_MONO8 ++al_FORMAT_MONO16 = CONST_AL_FORMAT_MONO16 ++al_FORMAT_STEREO8 = CONST_AL_FORMAT_STEREO8 ++al_FORMAT_STEREO16 = CONST_AL_FORMAT_STEREO16 ++ ++-------------------------------------------------------------------------------- ++ ++alc_FALSE, alc_TRUE :: ALCboolean ++alc_FALSE = CONST_ALC_FALSE ++alc_TRUE = CONST_ALC_TRUE ++ ++alc_FREQUENCY, alc_REFRESH, alc_SYNC, alc_MONO_SOURCES, ++ alc_STEREO_SOURCES :: ALCint ++alc_FREQUENCY = CONST_ALC_FREQUENCY ++alc_REFRESH = CONST_ALC_REFRESH ++alc_SYNC = CONST_ALC_SYNC ++alc_MONO_SOURCES = CONST_ALC_MONO_SOURCES ++alc_STEREO_SOURCES = CONST_ALC_STEREO_SOURCES ++ ++alc_NO_ERROR, alc_INVALID_DEVICE, alc_INVALID_CONTEXT, alc_INVALID_ENUM, ++ alc_INVALID_VALUE, alc_INVALID_OPERATION, alc_OUT_OF_MEMORY :: ALCenum ++alc_NO_ERROR = CONST_ALC_NO_ERROR ++alc_INVALID_DEVICE = CONST_ALC_INVALID_DEVICE ++alc_INVALID_CONTEXT = CONST_ALC_INVALID_CONTEXT ++alc_INVALID_ENUM = CONST_ALC_INVALID_ENUM ++alc_INVALID_VALUE = CONST_ALC_INVALID_VALUE ++alc_INVALID_OPERATION = CONST_ALC_INVALID_OPERATION ++alc_OUT_OF_MEMORY = CONST_ALC_OUT_OF_MEMORY ++ ++alc_DEFAULT_DEVICE_SPECIFIER, alc_DEVICE_SPECIFIER, alc_EXTENSIONS, ++ alc_CAPTURE_DEFAULT_DEVICE_SPECIFIER, alc_CAPTURE_DEVICE_SPECIFIER :: ALCenum ++alc_DEFAULT_DEVICE_SPECIFIER = CONST_ALC_DEFAULT_DEVICE_SPECIFIER ++alc_DEVICE_SPECIFIER = CONST_ALC_DEVICE_SPECIFIER ++alc_EXTENSIONS = CONST_ALC_EXTENSIONS ++alc_CAPTURE_DEFAULT_DEVICE_SPECIFIER= CONST_ALC_CAPTURE_DEFAULT_DEVICE_SPECIFIER ++alc_CAPTURE_DEVICE_SPECIFIER = CONST_ALC_CAPTURE_DEVICE_SPECIFIER ++ ++alc_ATTRIBUTES_SIZE, alc_ALL_ATTRIBUTES, alc_MAJOR_VERSION, alc_MINOR_VERSION, ++ alc_CAPTURE_SAMPLES :: ALCenum ++alc_ATTRIBUTES_SIZE = CONST_ALC_ATTRIBUTES_SIZE ++alc_ALL_ATTRIBUTES = CONST_ALC_ALL_ATTRIBUTES ++alc_MAJOR_VERSION = CONST_ALC_MAJOR_VERSION ++alc_MINOR_VERSION = CONST_ALC_MINOR_VERSION ++alc_CAPTURE_SAMPLES = CONST_ALC_CAPTURE_SAMPLES +diff -uNr --exclude=autom4te.cache --exclude=.cvsignore hugs98-Mar2005-patched/fptools/libraries/OpenAL/Sound/OpenAL.hs ghc-6.4.2/libraries/OpenAL/Sound/OpenAL.hs +--- hugs98-Mar2005-patched/fptools/libraries/OpenAL/Sound/OpenAL.hs 2004-01-03 04:03:07.000000000 +0900 ++++ ghc-6.4.2/libraries/OpenAL/Sound/OpenAL.hs 2006-03-22 00:58:03.000000000 +0900 +@@ -1,23 +1,181 @@ + -------------------------------------------------------------------------------- + -- | + -- Module : Sound.OpenAL +--- Copyright : (c) Sven Panne 2003-2004 ++-- Copyright : (c) Sven Panne 2003-2005 + -- License : BSD-style (see the file libraries/OpenAL/LICENSE) +--- ++-- + -- Maintainer : sven.panne@aedion.de + -- Stability : provisional + -- Portability : portable + -- +--- A convenience module, combining the Haskell bindings for AL, ALC and ALUT. ++-- A convenience module, combining the Haskell bindings for AL and ALC. + -- + -------------------------------------------------------------------------------- + + module Sound.OpenAL ( ++ -- * A Brief History of OpenAL ++ -- $ABriefHistoryOfOpenAL ++ ++ -- * What is the OpenAL Audio System? ++ -- $WhatIsTheOpenALAudioSystem ++ ++ -- * Different Views of OpenAL ++ ++ -- ** Programmer\'s View of OpenAL ++ -- $ProgrammersViewOfOpenAL ++ ++ -- ** Implementor\'s View of OpenAL ++ -- $ImplementorsViewOfOpenAL ++ ++ -- ** The Specification\'s View of OpenAL ++ -- $TheSpecificationsViewOfOpenAL ++ ++ -- * Legal stuff ++ -- $LegalStuff ++ + module Sound.OpenAL.AL + , module Sound.OpenAL.ALC +- , module Sound.OpenAL.ALUT ++ ++ -- * Convenience Re-exports from the OpenGL Package ++ , module Graphics.Rendering.OpenGL.GL.StateVar ++ , ObjectName(..), Vector3(..), Vertex3(..) + ) where + + import Sound.OpenAL.AL + import Sound.OpenAL.ALC +-import Sound.OpenAL.ALUT ++ ++import Graphics.Rendering.OpenGL.GL.StateVar ++import Graphics.Rendering.OpenGL.GL.BufferObjects ( ObjectName(..) ) ++import Graphics.Rendering.OpenGL.GL.CoordTrans ( Vector3(..) ) ++import Graphics.Rendering.OpenGL.GL.VertexSpec ( Vertex3(..) ) ++ ++-------------------------------------------------------------------------------- ++-- $ABriefHistoryOfOpenAL ++-- The first discussions about implementing OpenAL as an audio API complimentary ++-- to OpenGL started around 1998. There were a few aborted attempts at creating ++-- the headers and a specification, but by late 1999 Loki Entertainment Software ++-- was in need for an API of exactly this type and pursued both a specification ++-- and a Linux implementation. At around that time, Loki started talking with ++-- Creative Labs about standardizing the API and expanding platform support. The ++-- OpenAL 1.0 specification was released in early 2000 and compliant OpenAL ++-- libraries were released in the same year for Linux, MacOS 8\/9, Windows, and ++-- BeOS. Loki Entertainment also shipped several games using OpenAL in 2000: ++-- Heavy Gear 2 and Heretic 2 (both under Linux). In 2001, Creative Labs ++-- released the first hardware-accelerated OpenAL libraries. The libraries ++-- supported the SoundBlaster Live on MacOS 8\/9 and Windows. ++-- ++-- Since 2001, there has been continuous improvement in OpenAL. Some platforms ++-- are less relevant than in 2000 (BeOS and MacOS 8\/9 for instance), but more ++-- platforms have been added as well (BSD, Solaris, IRIX, Mac OS X, and the ++-- popular console gaming platforms). Hardware support is enabled for many ++-- Creative and NVIDIA audio devices under Windows as well. ++-- ++-- In terms of product support, OpenAL has been used in a large number of titles ++-- over the years, on many platforms (for a list of many of the titles, see ++-- ). ++ ++-------------------------------------------------------------------------------- ++-- $WhatIsTheOpenALAudioSystem ++-- OpenAL (for /Open Audio Library/) is a software interface to audio hardware. ++-- The interface consists of a number of functions that allow a programmer to ++-- specify the objects and operations in producing high-quality audio output, ++-- specifically multichannel output of 3D arrangements of sound sources around a ++-- listener. ++-- ++-- The OpenAL API is designed to be cross-platform and easy to use. It resembles ++-- the OpenGL API in coding style and conventions. OpenAL uses a syntax ++-- resembling that of OpenGL where applicable. For more information on OpenGL, ++-- see and the "Graphics.Rendering.OpenGL" module. ++-- ++-- OpenAL is foremost a means to generate audio in a simulated three-dimensional ++-- space. Consequently, legacy audio concepts such as panning and left\/right ++-- channels are not directly supported. OpenAL does include extensions ++-- compatible with the IA-SIG 3D Level 1 and Level 2 rendering guidelines to ++-- handle sound-source directivity and distancerelated attenuation and Doppler ++-- effects, as well as environmental effects such as reflection, obstruction, ++-- transmission, reverberation. For more information on IA-SIG 3D, see ++-- . ++-- ++-- Like OpenGL, the OpenAL core API has no notion of an explicit rendering ++-- context, and operates on an implied current OpenAL Context. Unlike the OpenGL ++-- specification, the OpenAL specification includes both the core API (the ++-- actual OpenAL API, see "Sound.OpenAL.AL") and the operating system bindings ++-- of the ALC API (the /Audio Library Context/, see "Sound.OpenAL.ALC"). Unlike ++-- OpenGL\'s GLX, WGL and other OS-specific bindings, the ALC API is portable ++-- across platforms as well. ++ ++-------------------------------------------------------------------------------- ++-- $ProgrammersViewOfOpenAL ++-- To the programmer, OpenAL is a set of commands that allow the specification ++-- of sound sources and a listener in three dimensions, combined with commands ++-- that control how these sound sources are rendered into the output buffer. The ++-- effect of OpenAL commands is not guaranteed to be immediate, as there are ++-- latencies depending on the implementation, but ideally such latency should ++-- not be noticeable to the user. ++-- ++-- A typical program that uses OpenAL begins with calls to open a sound device ++-- which is used to process output and play it on attached hardware (speakers or ++-- headphones). Then, calls are made to allocate an AL context and associate it ++-- with the device. Once an AL context is allocated, the programmer is free to ++-- issue AL commands. Some calls are used to render sources (point and ++-- directional sources, looping or not), while others affect the rendering of ++-- these sources including how they are attenuated by distance and relative ++-- orientation. ++ ++-------------------------------------------------------------------------------- ++-- $ImplementorsViewOfOpenAL ++-- To the implementor, OpenAL is a set of commands that affect the operation of ++-- CPU and sound hardware. If the hardware consists only of an addressable ++-- output buffer, then OpenAL must be implemented almost entirely on the host ++-- CPU. In some cases audio hardware provides DSP-based and other acceleration ++-- in various degrees. The OpenAL implementor\'s task is to provide the CPU ++-- software interface while dividing the work for each AL command between the ++-- CPU and the audio hardware. This division should be tailored to the available ++-- audio hardware to obtain optimum performance in carrying out AL calls. ++-- ++-- OpenAL maintains a considerable amount of state information. This state ++-- controls how the sources are rendered into the output buffer. Some of this ++-- state is directly available to the user: he or she can make calls to obtain ++-- its value. Some of it, however, is visible only by the effect it has on what ++-- is rendered. One of the main goals of the OpenAL specification is to make ++-- OpenAL state information explicit, to elucidate how it changes, and to ++-- indicate what its effects are. ++ ++-------------------------------------------------------------------------------- ++-- $TheSpecificationsViewOfOpenAL ++-- The OpenAL specification (see ) ++-- views OpenAL as a state machine that controls a multichannel processing ++-- system to synthesize a digital stream, passing sample data through a chain of ++-- parametrized digital audio signal processing operations. This model should ++-- engender a specification that satisfies the needs of both programmers and ++-- implementors. It does not, however, necessarily provide a model for ++-- implementation. Any proper implementation must produce results conforming to ++-- those produced by the methods specified in the OpenAL specification, but ++-- there may be ways to carry out a particular computation that are more ++-- efficient than the one specified. ++ ++-------------------------------------------------------------------------------- ++-- $LegalStuff ++-- The documentation is more or less based upon the OpenAL 1.1 Specification and ++-- Reference, which is in turn based upon the older OpenAL Specification and ++-- Reference (1.0), published in June 2000. Both copyright notices are presented ++-- below: ++-- ++-- Version 1.1: Published June 2005, Copyright (c) 2005 by authors ++-- ++-- Version 1.0 Draft Edition: Published June 2000, Copyright (c) 1999-2000 by ++-- Loki Software ++-- ++-- Permission is granted to make and distribute verbatim copies of this manual ++-- provided the copyright notice and this permission notice are preserved on all ++-- copies. Permission is granted to copy and distribute translations of this ++-- manual into another language, under the above conditions for modified ++-- versions, except that this permission notice may be stated in a translation ++-- approved by the copyright owners. ++-- ++-- BeOS is a trademark of PalmSource, Inc. Linux is a trademark of Linus ++-- Torvalds. Macintosh and Apple are trademarks of Apple Computer, Inc. OpenAL ++-- is a trademark of Creative Labs, Inc. OpenGL is a trademark of Silicon ++-- Graphics, Inc. UNIX is a trademark of X\/Open Group. Windows is a trademark ++-- of Microsoft Corp. X Window System is a trademark of X Consortium, Inc. All ++-- other trademarks are property of their respective owners. +diff -uNr --exclude=autom4te.cache --exclude=.cvsignore hugs98-Mar2005-patched/fptools/libraries/OpenAL/aclocal.m4 ghc-6.4.2/libraries/OpenAL/aclocal.m4 +--- hugs98-Mar2005-patched/fptools/libraries/OpenAL/aclocal.m4 2004-11-22 07:53:36.000000000 +0900 ++++ ghc-6.4.2/libraries/OpenAL/aclocal.m4 2006-03-22 00:58:03.000000000 +0900 +@@ -1,7 +1,7 @@ + # FPTOOLS_CHECK_HTYPE(TYPE [, DEFAULT_VALUE, [, VALUE-FOR-CROSS-COMPILATION]) + # + # This test should *really* be rewritten!!! +-AC_DEFUN(FPTOOLS_CHECK_HTYPE, ++AC_DEFUN([FPTOOLS_CHECK_HTYPE], + [changequote(<<, >>)dnl + dnl The name to #define. + define(<>, translit(htype_$1, [a-z *], [A-Z_P]))dnl +@@ -59,6 +59,12 @@ + # include + #endif + ++#if defined(HAVE_AL_AL_H) ++# include ++#elif defined(HAVE_OPENAL_AL_H) ++# include ++#endif ++ + #if defined(HAVE_AL_ALC_H) + # include + #elif defined(HAVE_OPENAL_ALC_H) +@@ -87,8 +93,8 @@ + exit(0); + }]])],[AC_CV_NAME=`cat conftestval`], + [ifelse([$2], , [AC_CV_NAME=NotReallyAType; AC_CV_NAME_supported=no], [AC_CV_NAME=$2])], +-[ifelse([$3], , [AC_CV_NAME=NotReallyATypeCross; AC_CV_NAME_supported=no], [AC_CV_NAME=$3])])]) dnl +-CPPFLAGS="$fp_check_htype_save_cppflags" ++[ifelse([$3], , [AC_CV_NAME=NotReallyATypeCross; AC_CV_NAME_supported=no], [AC_CV_NAME=$3])]) ++CPPFLAGS="$fp_check_htype_save_cppflags"]) dnl + if test "$AC_CV_NAME_supported" = yes; then + AC_MSG_RESULT($AC_CV_NAME) + AC_DEFINE_UNQUOTED(AC_TYPE_NAME, $AC_CV_NAME, [Define to Haskell type for $1]) +@@ -100,6 +106,7 @@ + undefine([AC_CV_NAME_supported])dnl + ]) + ++ + # FP_COMPUTE_INT(EXPRESSION, VARIABLE, INCLUDES, IF-FAILS) + # --------------------------------------------------------- + # Assign VARIABLE the value of the compile-time EXPRESSION using INCLUDES for +@@ -113,6 +120,7 @@ + [_AC_COMPUTE_INT([$1], [$2], [$3], [$4])[]dnl + ])# FP_COMPUTE_INT + ++ + # FP_CHECK_CONST(EXPRESSION, [INCLUDES = DEFAULT-INCLUDES], [VALUE-IF-FAIL = -1]) + # ------------------------------------------------------------------------------- + # Defines CONST_EXPRESSION to the value of the compile-time EXPRESSION, using +@@ -141,7 +149,7 @@ + # FP_CHECK_CONSTS(EXPRESSION..., [INCLUDES = DEFAULT-INCLUDES], [VALUE-IF-FAIL = -1]) + # ----------------------------------------------------------------------------------- + # List version of FP_CHECK_CONST +-AC_DEFUN(FP_CHECK_CONSTS, ++AC_DEFUN([FP_CHECK_CONSTS], + [FP_CHECK_CONSTS_TEMPLATE([$1])dnl + for fp_const_name in $1 + do +@@ -159,3 +167,119 @@ + [enable_openal=$enableval], + [enable_openal=yes]) + ])# FP_ARG_OPENAL ++ ++ ++# FP_HEADER_AL ++# ------------ ++# Check for an AL header, setting the variable fp_found_al_header to no/yes, ++# depending on the outcome. ++AC_DEFUN([FP_HEADER_AL], ++[if test -z "$fp_found_al_header"; then ++ fp_found_al_header=no ++ AC_CHECK_HEADERS([AL/al.h OpenAL/al.h], [fp_found_al_header=yes; break]) ++fi ++]) # FP_HEADER_AL ++ ++ ++# FP_HEADER_ALC ++# ------------- ++# Check for an ALC header, setting the variable fp_found_alc_header to no/yes, ++# depending on the outcome. ++AC_DEFUN([FP_HEADER_ALC], ++[if test -z "$fp_found_alc_header"; then ++ fp_found_alc_header=no ++ AC_CHECK_HEADERS([AL/alc.h OpenAL/alc.h], [fp_found_alc_header=yes; break]) ++fi ++]) # FP_HEADER_ALC ++ ++ ++# FP_FUNC_ALCCLOSEDEVICE_VOID ++# --------------------------- ++# Defines ALCCLOSEDEVICE_VOID to 1 if `alcCloseDevice' returns void. ++AC_DEFUN([FP_FUNC_ALCCLOSEDEVICE_VOID], ++[AC_REQUIRE([FP_HEADER_ALC]) ++AC_CACHE_CHECK([whether alcCloseDevice returns void], ++ [fp_cv_func_alcclosedevice_void], ++ [AC_COMPILE_IFELSE([AC_LANG_PROGRAM([AC_INCLUDES_DEFAULT ++#if defined(HAVE_AL_ALC_H) ++#include ++#elif defined(HAVE_OPENAL_ALC_H) ++#include ++#endif ++], ++ [[int x = (int)alcCloseDevice(NULL);]])], ++ [fp_cv_func_alcclosedevice_void=no], ++ [fp_cv_func_alcclosedevice_void=yes])]) ++if test x"$fp_cv_func_alcclosedevice_void" = xyes; then ++ AC_DEFINE([ALCCLOSEDEVICE_VOID], [1], [Define to 1 if `alcCloseDevice' returns void.]) ++fi ++]) # FP_FUNC_ALCCLOSEDEVICE_VOID ++ ++ ++# FP_FUNC_ALCMAKECONTEXTCURRENT_VOID ++# ---------------------------------- ++# Defines ALCMAKECONTEXTCURRENT_VOID to 1 if `alcMakeContextCurrent' returns void. ++AC_DEFUN([FP_FUNC_ALCMAKECONTEXTCURRENT_VOID], ++[AC_REQUIRE([FP_HEADER_ALC]) ++AC_CACHE_CHECK([whether alcMakeContextCurrent returns void], ++ [fp_cv_func_alcmakecontextcurrent_void], ++ [AC_COMPILE_IFELSE([AC_LANG_PROGRAM([AC_INCLUDES_DEFAULT ++#if defined(HAVE_AL_ALC_H) ++#include ++#elif defined(HAVE_OPENAL_ALC_H) ++#include ++#endif ++], ++ [[int x = (int)alcMakeContextCurrent(NULL);]])], ++ [fp_cv_func_alcmakecontextcurrent_void=no], ++ [fp_cv_func_alcmakecontextcurrent_void=yes])]) ++if test x"$fp_cv_func_alcmakecontextcurrent_void)" = xyes; then ++ AC_DEFINE([ALCMAKECONTEXTCURRENT_VOID], [1], [Define to 1 if `alcMakeContextCurrent' returns void.]) ++fi ++]) # FP_FUNC_ALCMAKECONTEXTCURRENT_VOID ++ ++ ++# FP_FUNC_ALCPROCESSCONTEXT_VOID ++# ------------------------------ ++# Defines ALCPROCESSCONTEXT_VOID to 1 if `alcProcessContext' returns void. ++AC_DEFUN([FP_FUNC_ALCPROCESSCONTEXT_VOID], ++[AC_REQUIRE([FP_HEADER_ALC]) ++AC_CACHE_CHECK([whether alcProcessContext returns void], ++ [fp_cv_func_alcprocesscontext_void], ++ [AC_COMPILE_IFELSE([AC_LANG_PROGRAM([AC_INCLUDES_DEFAULT ++#if defined(HAVE_AL_ALC_H) ++#include ++#elif defined(HAVE_OPENAL_ALC_H) ++#include ++#endif ++], ++ [[int x = (int)alcProcessContext(NULL);]])], ++ [fp_cv_func_alcprocesscontext_void=no], ++ [fp_cv_func_alcprocesscontext_void=yes])]) ++if test x"$fp_cv_func_alcprocesscontext_void" = xyes; then ++ AC_DEFINE([ALCPROCESSCONTEXT_VOID], [1], [Define to 1 if `alcProcessContext' returns void.]) ++fi ++]) # FP_FUNC_ALCPROCESSCONTEXT_VOID ++ ++ ++# FP_FUNC_ALCDESTROYCONTEXT_VOID ++# ------------------------------ ++# Defines ALCDESTROYCONTEXT_VOID to 1 if `alcDestroyContext' returns void. ++AC_DEFUN([FP_FUNC_ALCDESTROYCONTEXT_VOID], ++[AC_REQUIRE([FP_HEADER_ALC]) ++AC_CACHE_CHECK([whether alcDestroyContext returns void], ++ [fp_cv_func_alcdestroycontext_void], ++ [AC_COMPILE_IFELSE([AC_LANG_PROGRAM([AC_INCLUDES_DEFAULT ++#if defined(HAVE_AL_ALC_H) ++#include ++#elif defined(HAVE_OPENAL_ALC_H) ++#include ++#endif ++], ++ [[int x = (int)alcDestroyContext(NULL);]])], ++ [fp_cv_func_alcdestroycontext_void=no], ++ [fp_cv_func_alcdestroycontext_void=yes])]) ++if test x"$fp_cv_func_alcdestroycontext_void" = xyes; then ++ AC_DEFINE([ALCDESTROYCONTEXT_VOID], [1], [Define to 1 if `alcDestroyContext' returns void.]) ++fi ++]) # FP_FUNC_ALCDESTROYCONTEXT_VOID +diff -uNr --exclude=autom4te.cache --exclude=.cvsignore hugs98-Mar2005-patched/fptools/libraries/OpenAL/configure ghc-6.4.2/libraries/OpenAL/configure +--- hugs98-Mar2005-patched/fptools/libraries/OpenAL/configure 2005-03-12 08:13:20.000000000 +0900 ++++ ghc-6.4.2/libraries/OpenAL/configure 2006-04-19 04:36:53.000000000 +0900 +@@ -1,6 +1,6 @@ + #! /bin/sh + # Guess values for system-dependent variables and create Makefiles. +-# Generated by GNU Autoconf 2.57 for Haskell HOpenAL package 1.0. ++# Generated by GNU Autoconf 2.57 for Haskell HOpenAL package 1.2. + # + # Report bugs to . + # +@@ -268,8 +268,8 @@ + # Identity of this package. + PACKAGE_NAME='Haskell HOpenAL package' + PACKAGE_TARNAME='OpenAL' +-PACKAGE_VERSION='1.0' +-PACKAGE_STRING='Haskell HOpenAL package 1.0' ++PACKAGE_VERSION='1.2' ++PACKAGE_STRING='Haskell HOpenAL package 1.2' + PACKAGE_BUGREPORT='sven.panne@aedion.de' + + ac_unique_file="include/HsOpenAL.h.in" +@@ -310,7 +310,7 @@ + # include + #endif" + +-ac_subst_vars='SHELL PATH_SEPARATOR PACKAGE_NAME PACKAGE_TARNAME PACKAGE_VERSION PACKAGE_STRING PACKAGE_BUGREPORT exec_prefix prefix program_transform_name bindir sbindir libexecdir datadir sysconfdir sharedstatedir localstatedir libdir includedir oldincludedir infodir mandir build_alias host_alias target_alias DEFS ECHO_C ECHO_N ECHO_T LIBS AL_BUILD_PACKAGE CC CFLAGS LDFLAGS CPPFLAGS ac_ct_CC EXEEXT OBJEXT AL_LIBS CPP EGREP AL_FRAMEWORKS BUILD_PACKAGE_BOOL CALLCONV LIBOBJS LTLIBOBJS' ++ac_subst_vars='SHELL PATH_SEPARATOR PACKAGE_NAME PACKAGE_TARNAME PACKAGE_VERSION PACKAGE_STRING PACKAGE_BUGREPORT exec_prefix prefix program_transform_name bindir sbindir libexecdir datadir sysconfdir sharedstatedir localstatedir libdir includedir oldincludedir infodir mandir build_alias host_alias target_alias DEFS ECHO_C ECHO_N ECHO_T LIBS AL_BUILD_PACKAGE CC CFLAGS LDFLAGS CPPFLAGS ac_ct_CC EXEEXT OBJEXT AL_LIBS AL_FRAMEWORKS CPP EGREP BUILD_PACKAGE_BOOL CALLCONV LIBOBJS LTLIBOBJS' + ac_subst_files='' + + # Initialize some variables set by options. +@@ -779,7 +779,7 @@ + # Omit some internal or obsolete options to make the list less imposing. + # This message is too long to be a string in the A/UX 3.1 sh. + cat <<_ACEOF +-\`configure' configures Haskell HOpenAL package 1.0 to adapt to many kinds of systems. ++\`configure' configures Haskell HOpenAL package 1.2 to adapt to many kinds of systems. + + Usage: $0 [OPTION]... [VAR=VALUE]... + +@@ -836,7 +836,7 @@ + + if test -n "$ac_init_help"; then + case $ac_init_help in +- short | recursive ) echo "Configuration of Haskell HOpenAL package 1.0:";; ++ short | recursive ) echo "Configuration of Haskell HOpenAL package 1.2:";; + esac + cat <<\_ACEOF + +@@ -921,7 +921,7 @@ + test -n "$ac_init_help" && exit 0 + if $ac_init_version; then + cat <<\_ACEOF +-Haskell HOpenAL package configure 1.0 ++Haskell HOpenAL package configure 1.2 + generated by GNU Autoconf 2.57 + + Copyright 1992, 1993, 1994, 1995, 1996, 1998, 1999, 2000, 2001, 2002 +@@ -936,7 +936,7 @@ + This file contains any messages produced by compilers while + running configure, to aid debugging if configure makes a mistake. + +-It was created by Haskell HOpenAL package $as_me 1.0, which was ++It was created by Haskell HOpenAL package $as_me 1.2, which was + generated by GNU Autoconf 2.57. Invocation command line was + + $ $0 $@ +@@ -2219,7 +2219,7 @@ + fi + rm -f conftest.$ac_objext conftest$ac_exeext conftest.$ac_ext + if test "$ac_cv_search_alGenSources" = no; then +- for ac_lib in openal; do ++ for ac_lib in openal openal32; do + LIBS="-l$ac_lib $ac_func_search_save_LIBS" + cat >conftest.$ac_ext <<_ACEOF + #line $LINENO "configure" +@@ -2283,7 +2283,15 @@ + echo "$as_me: WARNING: no OpenAL library found, so this package will not be built" >&2;} + else + +-al_found_header=no ++# Ugly... ++AL_FRAMEWORKS= ++case $host_os in ++darwin*) ++ AL_FRAMEWORKS=OpenAL ++ ;; ++esac ++ ++ + ac_ext=c + ac_cpp='$CPP $CPPFLAGS' + ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' +@@ -2757,9 +2765,11 @@ + done + + ++if test -z "$fp_found_al_header"; then ++ fp_found_al_header=no + + +-for ac_header in AL/alc.h OpenAL/alc.h ++for ac_header in AL/al.h OpenAL/al.h + do + as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh` + if eval "test \"\${$as_ac_Header+set}\" = set"; then +@@ -2895,30 +2905,18 @@ + cat >>confdefs.h <<_ACEOF + #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1 + _ACEOF +- al_found_header=yes; break ++ fp_found_al_header=yes; break + fi + + done + +-if test "$al_found_header" = no; then +- { echo "$as_me:$LINENO: WARNING: no OpenAL header found, so this package will not be built" >&5 +-echo "$as_me: WARNING: no OpenAL header found, so this package will not be built" >&2;} +-else +- +-AL_BUILD_PACKAGE=yes +- +-# Ugly... +-AL_FRAMEWORKS= +-case $target_os in +-darwin*) +- AL_FRAMEWORKS=OpenAL +- ;; +-esac +- ++fi + ++if test -z "$fp_found_alc_header"; then ++ fp_found_alc_header=no + + +-for ac_header in AL/alext.h OpenAL/alext.h ++for ac_header in AL/alc.h OpenAL/alc.h + do + as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh` + if eval "test \"\${$as_ac_Header+set}\" = set"; then +@@ -3054,133 +3052,1600 @@ + cat >>confdefs.h <<_ACEOF + #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1 + _ACEOF +- break ++ fp_found_alc_header=yes; break + fi + + done + ++fi + +-echo "$as_me:$LINENO: checking Haskell type for ALboolean" >&5 +-echo $ECHO_N "checking Haskell type for ALboolean... $ECHO_C" >&6 +-if test "${fptools_cv_htype_ALboolean+set}" = set; then +- echo $ECHO_N "(cached) $ECHO_C" >&6 ++if test -z "$AL_FRAMEWORKS" && test x"$fp_found_al_header$fp_found_alc_header" != xyesyes; then ++ { echo "$as_me:$LINENO: WARNING: no OpenAL headers found, so this package will not be built" >&5 ++echo "$as_me: WARNING: no OpenAL headers found, so this package will not be built" >&2;} + else +- fptools_cv_htype_sup_ALboolean=yes +-fp_check_htype_save_cppflags="$CPPFLAGS" +-CPPFLAGS="$CPPFLAGS $X_CFLAGS" +-if test "$cross_compiling" = yes; then +- fptools_cv_htype_ALboolean=NotReallyATypeCross; fptools_cv_htype_sup_ALboolean=no ++ ++AL_BUILD_PACKAGE=yes ++ ++ ++ ++for ac_header in AL/alext.h OpenAL/alext.h ++do ++as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh` ++if eval "test \"\${$as_ac_Header+set}\" = set"; then ++ echo "$as_me:$LINENO: checking for $ac_header" >&5 ++echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6 ++if eval "test \"\${$as_ac_Header+set}\" = set"; then ++ echo $ECHO_N "(cached) $ECHO_C" >&6 ++fi ++echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5 ++echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6 + else +- cat >conftest.$ac_ext <<_ACEOF ++ # Is the header compilable? ++echo "$as_me:$LINENO: checking $ac_header usability" >&5 ++echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6 ++cat >conftest.$ac_ext <<_ACEOF + #line $LINENO "configure" + /* confdefs.h. */ + _ACEOF + cat confdefs.h >>conftest.$ac_ext + cat >>conftest.$ac_ext <<_ACEOF + /* end confdefs.h. */ +-#include +-#include +- +-#if HAVE_SYS_TYPES_H +-# include +-#endif +- +-#if HAVE_UNISTD_H +-# include +-#endif ++$ac_includes_default ++#include <$ac_header> ++_ACEOF ++rm -f conftest.$ac_objext ++if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 ++ (eval $ac_compile) 2>&5 ++ ac_status=$? ++ echo "$as_me:$LINENO: \$? = $ac_status" >&5 ++ (exit $ac_status); } && ++ { ac_try='test -s conftest.$ac_objext' ++ { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 ++ (eval $ac_try) 2>&5 ++ ac_status=$? ++ echo "$as_me:$LINENO: \$? = $ac_status" >&5 ++ (exit $ac_status); }; }; then ++ ac_header_compiler=yes ++else ++ echo "$as_me: failed program was:" >&5 ++sed 's/^/| /' conftest.$ac_ext >&5 + +-#if HAVE_SYS_STAT_H +-# include +-#endif ++ac_header_compiler=no ++fi ++rm -f conftest.$ac_objext conftest.$ac_ext ++echo "$as_me:$LINENO: result: $ac_header_compiler" >&5 ++echo "${ECHO_T}$ac_header_compiler" >&6 + +-#if HAVE_FCNTL_H +-# include +-#endif ++# Is the header present? ++echo "$as_me:$LINENO: checking $ac_header presence" >&5 ++echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6 ++cat >conftest.$ac_ext <<_ACEOF ++#line $LINENO "configure" ++/* confdefs.h. */ ++_ACEOF ++cat confdefs.h >>conftest.$ac_ext ++cat >>conftest.$ac_ext <<_ACEOF ++/* end confdefs.h. */ ++#include <$ac_header> ++_ACEOF ++if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5 ++ (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1 ++ ac_status=$? ++ grep -v '^ *+' conftest.er1 >conftest.err ++ rm -f conftest.er1 ++ cat conftest.err >&5 ++ echo "$as_me:$LINENO: \$? = $ac_status" >&5 ++ (exit $ac_status); } >/dev/null; then ++ if test -s conftest.err; then ++ ac_cpp_err=$ac_c_preproc_warn_flag ++ else ++ ac_cpp_err= ++ fi ++else ++ ac_cpp_err=yes ++fi ++if test -z "$ac_cpp_err"; then ++ ac_header_preproc=yes ++else ++ echo "$as_me: failed program was:" >&5 ++sed 's/^/| /' conftest.$ac_ext >&5 + +-#if HAVE_SIGNAL_H +-# include +-#endif ++ ac_header_preproc=no ++fi ++rm -f conftest.err conftest.$ac_ext ++echo "$as_me:$LINENO: result: $ac_header_preproc" >&5 ++echo "${ECHO_T}$ac_header_preproc" >&6 + +-#if HAVE_TIME_H +-# include +-#endif ++# So? What about this header? ++case $ac_header_compiler:$ac_header_preproc in ++ yes:no ) ++ { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5 ++echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;} ++ { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5 ++echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;} ++ ( ++ cat <<\_ASBOX ++## ------------------------------------ ## ++## Report this to bug-autoconf@gnu.org. ## ++## ------------------------------------ ## ++_ASBOX ++ ) | ++ sed "s/^/$as_me: WARNING: /" >&2 ++ ;; ++ no:yes ) ++ { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5 ++echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;} ++ { echo "$as_me:$LINENO: WARNING: $ac_header: check for missing prerequisite headers?" >&5 ++echo "$as_me: WARNING: $ac_header: check for missing prerequisite headers?" >&2;} ++ { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5 ++echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;} ++ ( ++ cat <<\_ASBOX ++## ------------------------------------ ## ++## Report this to bug-autoconf@gnu.org. ## ++## ------------------------------------ ## ++_ASBOX ++ ) | ++ sed "s/^/$as_me: WARNING: /" >&2 ++ ;; ++esac ++echo "$as_me:$LINENO: checking for $ac_header" >&5 ++echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6 ++if eval "test \"\${$as_ac_Header+set}\" = set"; then ++ echo $ECHO_N "(cached) $ECHO_C" >&6 ++else ++ eval "$as_ac_Header=$ac_header_preproc" ++fi ++echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5 ++echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6 + +-#if HAVE_TERMIOS_H +-# include +-#endif ++fi ++if test `eval echo '${'$as_ac_Header'}'` = yes; then ++ cat >>confdefs.h <<_ACEOF ++#define `echo "HAVE_$ac_header" | $as_tr_cpp` 1 ++_ACEOF ++ break ++fi + +-#if HAVE_STRING_H +-# include +-#endif ++done + +-#if HAVE_CTYPE_H +-# include +-#endif + +-#if defined(HAVE_GL_GL_H) +-# include +-#elif defined(HAVE_OPENGL_GL_H) +-# include +-#endif + ++echo "$as_me:$LINENO: checking whether alcCloseDevice returns void" >&5 ++echo $ECHO_N "checking whether alcCloseDevice returns void... $ECHO_C" >&6 ++if test "${fp_cv_func_alcclosedevice_void+set}" = set; then ++ echo $ECHO_N "(cached) $ECHO_C" >&6 ++else ++ cat >conftest.$ac_ext <<_ACEOF ++#line $LINENO "configure" ++/* confdefs.h. */ ++_ACEOF ++cat confdefs.h >>conftest.$ac_ext ++cat >>conftest.$ac_ext <<_ACEOF ++/* end confdefs.h. */ ++$ac_includes_default + #if defined(HAVE_AL_ALC_H) +-# include ++#include + #elif defined(HAVE_OPENAL_ALC_H) +-# include +-#endif +- +-#if HAVE_SYS_RESOURCE_H +-# include ++#include + #endif + +-typedef ALboolean testing; +- +-main() { +- FILE *f=fopen("conftestval", "w"); +- if (!f) exit(1); +- if (((testing)((int)((testing)1.4))) == ((testing)1.4)) { +- fprintf(f, "%s%d\n", +- ((testing)(-1) < (testing)0) ? "Int" : "Word", +- sizeof(testing)*8); +- } else { +- fprintf(f,"%s\n", +- (sizeof(testing) > sizeof(double)) ? "LDouble" : +- (sizeof(testing) == sizeof(double)) ? "Double" : "Float"); +- } +- fclose(f); +- exit(0); ++int ++main () ++{ ++int x = (int)alcCloseDevice(NULL); ++ ; ++ return 0; + } + _ACEOF +-rm -f conftest$ac_exeext +-if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5 +- (eval $ac_link) 2>&5 ++rm -f conftest.$ac_objext ++if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 ++ (eval $ac_compile) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 +- (exit $ac_status); } && { ac_try='./conftest$ac_exeext' ++ (exit $ac_status); } && ++ { ac_try='test -s conftest.$ac_objext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then +- fptools_cv_htype_ALboolean=`cat conftestval` ++ fp_cv_func_alcclosedevice_void=no + else +- echo "$as_me: program exited with status $ac_status" >&5 +-echo "$as_me: failed program was:" >&5 ++ echo "$as_me: failed program was:" >&5 + sed 's/^/| /' conftest.$ac_ext >&5 + +-( exit $ac_status ) ++fp_cv_func_alcclosedevice_void=yes ++fi ++rm -f conftest.$ac_objext conftest.$ac_ext ++fi ++echo "$as_me:$LINENO: result: $fp_cv_func_alcclosedevice_void" >&5 ++echo "${ECHO_T}$fp_cv_func_alcclosedevice_void" >&6 ++if test x"$fp_cv_func_alcclosedevice_void" = xyes; then ++ ++cat >>confdefs.h <<\_ACEOF ++#define ALCCLOSEDEVICE_VOID 1 ++_ACEOF ++ ++fi ++ ++ ++echo "$as_me:$LINENO: checking whether alcMakeContextCurrent returns void" >&5 ++echo $ECHO_N "checking whether alcMakeContextCurrent returns void... $ECHO_C" >&6 ++if test "${fp_cv_func_alcmakecontextcurrent_void+set}" = set; then ++ echo $ECHO_N "(cached) $ECHO_C" >&6 ++else ++ cat >conftest.$ac_ext <<_ACEOF ++#line $LINENO "configure" ++/* confdefs.h. */ ++_ACEOF ++cat confdefs.h >>conftest.$ac_ext ++cat >>conftest.$ac_ext <<_ACEOF ++/* end confdefs.h. */ ++$ac_includes_default ++#if defined(HAVE_AL_ALC_H) ++#include ++#elif defined(HAVE_OPENAL_ALC_H) ++#include ++#endif ++ ++int ++main () ++{ ++int x = (int)alcMakeContextCurrent(NULL); ++ ; ++ return 0; ++} ++_ACEOF ++rm -f conftest.$ac_objext ++if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 ++ (eval $ac_compile) 2>&5 ++ ac_status=$? ++ echo "$as_me:$LINENO: \$? = $ac_status" >&5 ++ (exit $ac_status); } && ++ { ac_try='test -s conftest.$ac_objext' ++ { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 ++ (eval $ac_try) 2>&5 ++ ac_status=$? ++ echo "$as_me:$LINENO: \$? = $ac_status" >&5 ++ (exit $ac_status); }; }; then ++ fp_cv_func_alcmakecontextcurrent_void=no ++else ++ echo "$as_me: failed program was:" >&5 ++sed 's/^/| /' conftest.$ac_ext >&5 ++ ++fp_cv_func_alcmakecontextcurrent_void=yes ++fi ++rm -f conftest.$ac_objext conftest.$ac_ext ++fi ++echo "$as_me:$LINENO: result: $fp_cv_func_alcmakecontextcurrent_void" >&5 ++echo "${ECHO_T}$fp_cv_func_alcmakecontextcurrent_void" >&6 ++if test x"$fp_cv_func_alcmakecontextcurrent_void)" = xyes; then ++ ++cat >>confdefs.h <<\_ACEOF ++#define ALCMAKECONTEXTCURRENT_VOID 1 ++_ACEOF ++ ++fi ++ ++ ++echo "$as_me:$LINENO: checking whether alcProcessContext returns void" >&5 ++echo $ECHO_N "checking whether alcProcessContext returns void... $ECHO_C" >&6 ++if test "${fp_cv_func_alcprocesscontext_void+set}" = set; then ++ echo $ECHO_N "(cached) $ECHO_C" >&6 ++else ++ cat >conftest.$ac_ext <<_ACEOF ++#line $LINENO "configure" ++/* confdefs.h. */ ++_ACEOF ++cat confdefs.h >>conftest.$ac_ext ++cat >>conftest.$ac_ext <<_ACEOF ++/* end confdefs.h. */ ++$ac_includes_default ++#if defined(HAVE_AL_ALC_H) ++#include ++#elif defined(HAVE_OPENAL_ALC_H) ++#include ++#endif ++ ++int ++main () ++{ ++int x = (int)alcProcessContext(NULL); ++ ; ++ return 0; ++} ++_ACEOF ++rm -f conftest.$ac_objext ++if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 ++ (eval $ac_compile) 2>&5 ++ ac_status=$? ++ echo "$as_me:$LINENO: \$? = $ac_status" >&5 ++ (exit $ac_status); } && ++ { ac_try='test -s conftest.$ac_objext' ++ { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 ++ (eval $ac_try) 2>&5 ++ ac_status=$? ++ echo "$as_me:$LINENO: \$? = $ac_status" >&5 ++ (exit $ac_status); }; }; then ++ fp_cv_func_alcprocesscontext_void=no ++else ++ echo "$as_me: failed program was:" >&5 ++sed 's/^/| /' conftest.$ac_ext >&5 ++ ++fp_cv_func_alcprocesscontext_void=yes ++fi ++rm -f conftest.$ac_objext conftest.$ac_ext ++fi ++echo "$as_me:$LINENO: result: $fp_cv_func_alcprocesscontext_void" >&5 ++echo "${ECHO_T}$fp_cv_func_alcprocesscontext_void" >&6 ++if test x"$fp_cv_func_alcprocesscontext_void" = xyes; then ++ ++cat >>confdefs.h <<\_ACEOF ++#define ALCPROCESSCONTEXT_VOID 1 ++_ACEOF ++ ++fi ++ ++ ++echo "$as_me:$LINENO: checking whether alcDestroyContext returns void" >&5 ++echo $ECHO_N "checking whether alcDestroyContext returns void... $ECHO_C" >&6 ++if test "${fp_cv_func_alcdestroycontext_void+set}" = set; then ++ echo $ECHO_N "(cached) $ECHO_C" >&6 ++else ++ cat >conftest.$ac_ext <<_ACEOF ++#line $LINENO "configure" ++/* confdefs.h. */ ++_ACEOF ++cat confdefs.h >>conftest.$ac_ext ++cat >>conftest.$ac_ext <<_ACEOF ++/* end confdefs.h. */ ++$ac_includes_default ++#if defined(HAVE_AL_ALC_H) ++#include ++#elif defined(HAVE_OPENAL_ALC_H) ++#include ++#endif ++ ++int ++main () ++{ ++int x = (int)alcDestroyContext(NULL); ++ ; ++ return 0; ++} ++_ACEOF ++rm -f conftest.$ac_objext ++if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 ++ (eval $ac_compile) 2>&5 ++ ac_status=$? ++ echo "$as_me:$LINENO: \$? = $ac_status" >&5 ++ (exit $ac_status); } && ++ { ac_try='test -s conftest.$ac_objext' ++ { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 ++ (eval $ac_try) 2>&5 ++ ac_status=$? ++ echo "$as_me:$LINENO: \$? = $ac_status" >&5 ++ (exit $ac_status); }; }; then ++ fp_cv_func_alcdestroycontext_void=no ++else ++ echo "$as_me: failed program was:" >&5 ++sed 's/^/| /' conftest.$ac_ext >&5 ++ ++fp_cv_func_alcdestroycontext_void=yes ++fi ++rm -f conftest.$ac_objext conftest.$ac_ext ++fi ++echo "$as_me:$LINENO: result: $fp_cv_func_alcdestroycontext_void" >&5 ++echo "${ECHO_T}$fp_cv_func_alcdestroycontext_void" >&6 ++if test x"$fp_cv_func_alcdestroycontext_void" = xyes; then ++ ++cat >>confdefs.h <<\_ACEOF ++#define ALCDESTROYCONTEXT_VOID 1 ++_ACEOF ++ ++fi ++ ++ ++echo "$as_me:$LINENO: checking Haskell type for ALboolean" >&5 ++echo $ECHO_N "checking Haskell type for ALboolean... $ECHO_C" >&6 ++if test "${fptools_cv_htype_ALboolean+set}" = set; then ++ echo $ECHO_N "(cached) $ECHO_C" >&6 ++else ++ fptools_cv_htype_sup_ALboolean=yes ++fp_check_htype_save_cppflags="$CPPFLAGS" ++CPPFLAGS="$CPPFLAGS $X_CFLAGS" ++if test "$cross_compiling" = yes; then ++ fptools_cv_htype_ALboolean=NotReallyATypeCross; fptools_cv_htype_sup_ALboolean=no ++else ++ cat >conftest.$ac_ext <<_ACEOF ++#line $LINENO "configure" ++/* confdefs.h. */ ++_ACEOF ++cat confdefs.h >>conftest.$ac_ext ++cat >>conftest.$ac_ext <<_ACEOF ++/* end confdefs.h. */ ++#include ++#include ++ ++#if HAVE_SYS_TYPES_H ++# include ++#endif ++ ++#if HAVE_UNISTD_H ++# include ++#endif ++ ++#if HAVE_SYS_STAT_H ++# include ++#endif ++ ++#if HAVE_FCNTL_H ++# include ++#endif ++ ++#if HAVE_SIGNAL_H ++# include ++#endif ++ ++#if HAVE_TIME_H ++# include ++#endif ++ ++#if HAVE_TERMIOS_H ++# include ++#endif ++ ++#if HAVE_STRING_H ++# include ++#endif ++ ++#if HAVE_CTYPE_H ++# include ++#endif ++ ++#if defined(HAVE_GL_GL_H) ++# include ++#elif defined(HAVE_OPENGL_GL_H) ++# include ++#endif ++ ++#if defined(HAVE_AL_AL_H) ++# include ++#elif defined(HAVE_OPENAL_AL_H) ++# include ++#endif ++ ++#if defined(HAVE_AL_ALC_H) ++# include ++#elif defined(HAVE_OPENAL_ALC_H) ++# include ++#endif ++ ++#if HAVE_SYS_RESOURCE_H ++# include ++#endif ++ ++typedef ALboolean testing; ++ ++main() { ++ FILE *f=fopen("conftestval", "w"); ++ if (!f) exit(1); ++ if (((testing)((int)((testing)1.4))) == ((testing)1.4)) { ++ fprintf(f, "%s%d\n", ++ ((testing)(-1) < (testing)0) ? "Int" : "Word", ++ sizeof(testing)*8); ++ } else { ++ fprintf(f,"%s\n", ++ (sizeof(testing) > sizeof(double)) ? "LDouble" : ++ (sizeof(testing) == sizeof(double)) ? "Double" : "Float"); ++ } ++ fclose(f); ++ exit(0); ++} ++_ACEOF ++rm -f conftest$ac_exeext ++if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5 ++ (eval $ac_link) 2>&5 ++ ac_status=$? ++ echo "$as_me:$LINENO: \$? = $ac_status" >&5 ++ (exit $ac_status); } && { ac_try='./conftest$ac_exeext' ++ { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 ++ (eval $ac_try) 2>&5 ++ ac_status=$? ++ echo "$as_me:$LINENO: \$? = $ac_status" >&5 ++ (exit $ac_status); }; }; then ++ fptools_cv_htype_ALboolean=`cat conftestval` ++else ++ echo "$as_me: program exited with status $ac_status" >&5 ++echo "$as_me: failed program was:" >&5 ++sed 's/^/| /' conftest.$ac_ext >&5 ++ ++( exit $ac_status ) + fptools_cv_htype_ALboolean=NotReallyAType; fptools_cv_htype_sup_ALboolean=no + fi + rm -f core core.* *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext + fi ++CPPFLAGS="$fp_check_htype_save_cppflags" ++fi ++ if test "$fptools_cv_htype_sup_ALboolean" = yes; then ++ echo "$as_me:$LINENO: result: $fptools_cv_htype_ALboolean" >&5 ++echo "${ECHO_T}$fptools_cv_htype_ALboolean" >&6 ++ ++cat >>confdefs.h <<_ACEOF ++#define HTYPE_ALBOOLEAN $fptools_cv_htype_ALboolean ++_ACEOF ++ ++else ++ echo "$as_me:$LINENO: result: not supported" >&5 ++echo "${ECHO_T}not supported" >&6 ++fi ++ ++echo "$as_me:$LINENO: checking Haskell type for ALchar" >&5 ++echo $ECHO_N "checking Haskell type for ALchar... $ECHO_C" >&6 ++if test "${fptools_cv_htype_ALchar+set}" = set; then ++ echo $ECHO_N "(cached) $ECHO_C" >&6 ++else ++ fptools_cv_htype_sup_ALchar=yes ++fp_check_htype_save_cppflags="$CPPFLAGS" ++CPPFLAGS="$CPPFLAGS $X_CFLAGS" ++if test "$cross_compiling" = yes; then ++ fptools_cv_htype_ALchar=NotReallyATypeCross; fptools_cv_htype_sup_ALchar=no ++else ++ cat >conftest.$ac_ext <<_ACEOF ++#line $LINENO "configure" ++/* confdefs.h. */ ++_ACEOF ++cat confdefs.h >>conftest.$ac_ext ++cat >>conftest.$ac_ext <<_ACEOF ++/* end confdefs.h. */ ++#include ++#include ++ ++#if HAVE_SYS_TYPES_H ++# include ++#endif ++ ++#if HAVE_UNISTD_H ++# include ++#endif ++ ++#if HAVE_SYS_STAT_H ++# include ++#endif ++ ++#if HAVE_FCNTL_H ++# include ++#endif ++ ++#if HAVE_SIGNAL_H ++# include ++#endif ++ ++#if HAVE_TIME_H ++# include ++#endif ++ ++#if HAVE_TERMIOS_H ++# include ++#endif ++ ++#if HAVE_STRING_H ++# include ++#endif ++ ++#if HAVE_CTYPE_H ++# include ++#endif ++ ++#if defined(HAVE_GL_GL_H) ++# include ++#elif defined(HAVE_OPENGL_GL_H) ++# include ++#endif ++ ++#if defined(HAVE_AL_AL_H) ++# include ++#elif defined(HAVE_OPENAL_AL_H) ++# include ++#endif ++ ++#if defined(HAVE_AL_ALC_H) ++# include ++#elif defined(HAVE_OPENAL_ALC_H) ++# include ++#endif ++ ++#if HAVE_SYS_RESOURCE_H ++# include ++#endif ++ ++typedef ALchar testing; ++ ++main() { ++ FILE *f=fopen("conftestval", "w"); ++ if (!f) exit(1); ++ if (((testing)((int)((testing)1.4))) == ((testing)1.4)) { ++ fprintf(f, "%s%d\n", ++ ((testing)(-1) < (testing)0) ? "Int" : "Word", ++ sizeof(testing)*8); ++ } else { ++ fprintf(f,"%s\n", ++ (sizeof(testing) > sizeof(double)) ? "LDouble" : ++ (sizeof(testing) == sizeof(double)) ? "Double" : "Float"); ++ } ++ fclose(f); ++ exit(0); ++} ++_ACEOF ++rm -f conftest$ac_exeext ++if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5 ++ (eval $ac_link) 2>&5 ++ ac_status=$? ++ echo "$as_me:$LINENO: \$? = $ac_status" >&5 ++ (exit $ac_status); } && { ac_try='./conftest$ac_exeext' ++ { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 ++ (eval $ac_try) 2>&5 ++ ac_status=$? ++ echo "$as_me:$LINENO: \$? = $ac_status" >&5 ++ (exit $ac_status); }; }; then ++ fptools_cv_htype_ALchar=`cat conftestval` ++else ++ echo "$as_me: program exited with status $ac_status" >&5 ++echo "$as_me: failed program was:" >&5 ++sed 's/^/| /' conftest.$ac_ext >&5 ++ ++( exit $ac_status ) ++fptools_cv_htype_ALchar=Int8 ++fi ++rm -f core core.* *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext ++fi ++CPPFLAGS="$fp_check_htype_save_cppflags" ++fi ++ if test "$fptools_cv_htype_sup_ALchar" = yes; then ++ echo "$as_me:$LINENO: result: $fptools_cv_htype_ALchar" >&5 ++echo "${ECHO_T}$fptools_cv_htype_ALchar" >&6 ++ ++cat >>confdefs.h <<_ACEOF ++#define HTYPE_ALCHAR $fptools_cv_htype_ALchar ++_ACEOF ++ ++else ++ echo "$as_me:$LINENO: result: not supported" >&5 ++echo "${ECHO_T}not supported" >&6 ++fi ++ ++echo "$as_me:$LINENO: checking Haskell type for ALbyte" >&5 ++echo $ECHO_N "checking Haskell type for ALbyte... $ECHO_C" >&6 ++if test "${fptools_cv_htype_ALbyte+set}" = set; then ++ echo $ECHO_N "(cached) $ECHO_C" >&6 ++else ++ fptools_cv_htype_sup_ALbyte=yes ++fp_check_htype_save_cppflags="$CPPFLAGS" ++CPPFLAGS="$CPPFLAGS $X_CFLAGS" ++if test "$cross_compiling" = yes; then ++ fptools_cv_htype_ALbyte=NotReallyATypeCross; fptools_cv_htype_sup_ALbyte=no ++else ++ cat >conftest.$ac_ext <<_ACEOF ++#line $LINENO "configure" ++/* confdefs.h. */ ++_ACEOF ++cat confdefs.h >>conftest.$ac_ext ++cat >>conftest.$ac_ext <<_ACEOF ++/* end confdefs.h. */ ++#include ++#include ++ ++#if HAVE_SYS_TYPES_H ++# include ++#endif ++ ++#if HAVE_UNISTD_H ++# include ++#endif ++ ++#if HAVE_SYS_STAT_H ++# include ++#endif ++ ++#if HAVE_FCNTL_H ++# include ++#endif ++ ++#if HAVE_SIGNAL_H ++# include ++#endif ++ ++#if HAVE_TIME_H ++# include ++#endif ++ ++#if HAVE_TERMIOS_H ++# include ++#endif ++ ++#if HAVE_STRING_H ++# include ++#endif ++ ++#if HAVE_CTYPE_H ++# include ++#endif ++ ++#if defined(HAVE_GL_GL_H) ++# include ++#elif defined(HAVE_OPENGL_GL_H) ++# include ++#endif ++ ++#if defined(HAVE_AL_AL_H) ++# include ++#elif defined(HAVE_OPENAL_AL_H) ++# include ++#endif ++ ++#if defined(HAVE_AL_ALC_H) ++# include ++#elif defined(HAVE_OPENAL_ALC_H) ++# include ++#endif ++ ++#if HAVE_SYS_RESOURCE_H ++# include ++#endif ++ ++typedef ALbyte testing; ++ ++main() { ++ FILE *f=fopen("conftestval", "w"); ++ if (!f) exit(1); ++ if (((testing)((int)((testing)1.4))) == ((testing)1.4)) { ++ fprintf(f, "%s%d\n", ++ ((testing)(-1) < (testing)0) ? "Int" : "Word", ++ sizeof(testing)*8); ++ } else { ++ fprintf(f,"%s\n", ++ (sizeof(testing) > sizeof(double)) ? "LDouble" : ++ (sizeof(testing) == sizeof(double)) ? "Double" : "Float"); ++ } ++ fclose(f); ++ exit(0); ++} ++_ACEOF ++rm -f conftest$ac_exeext ++if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5 ++ (eval $ac_link) 2>&5 ++ ac_status=$? ++ echo "$as_me:$LINENO: \$? = $ac_status" >&5 ++ (exit $ac_status); } && { ac_try='./conftest$ac_exeext' ++ { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 ++ (eval $ac_try) 2>&5 ++ ac_status=$? ++ echo "$as_me:$LINENO: \$? = $ac_status" >&5 ++ (exit $ac_status); }; }; then ++ fptools_cv_htype_ALbyte=`cat conftestval` ++else ++ echo "$as_me: program exited with status $ac_status" >&5 ++echo "$as_me: failed program was:" >&5 ++sed 's/^/| /' conftest.$ac_ext >&5 ++ ++( exit $ac_status ) ++fptools_cv_htype_ALbyte=NotReallyAType; fptools_cv_htype_sup_ALbyte=no ++fi ++rm -f core core.* *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext ++fi ++CPPFLAGS="$fp_check_htype_save_cppflags" ++fi ++ if test "$fptools_cv_htype_sup_ALbyte" = yes; then ++ echo "$as_me:$LINENO: result: $fptools_cv_htype_ALbyte" >&5 ++echo "${ECHO_T}$fptools_cv_htype_ALbyte" >&6 ++ ++cat >>confdefs.h <<_ACEOF ++#define HTYPE_ALBYTE $fptools_cv_htype_ALbyte ++_ACEOF ++ ++else ++ echo "$as_me:$LINENO: result: not supported" >&5 ++echo "${ECHO_T}not supported" >&6 ++fi ++ ++echo "$as_me:$LINENO: checking Haskell type for ALubyte" >&5 ++echo $ECHO_N "checking Haskell type for ALubyte... $ECHO_C" >&6 ++if test "${fptools_cv_htype_ALubyte+set}" = set; then ++ echo $ECHO_N "(cached) $ECHO_C" >&6 ++else ++ fptools_cv_htype_sup_ALubyte=yes ++fp_check_htype_save_cppflags="$CPPFLAGS" ++CPPFLAGS="$CPPFLAGS $X_CFLAGS" ++if test "$cross_compiling" = yes; then ++ fptools_cv_htype_ALubyte=NotReallyATypeCross; fptools_cv_htype_sup_ALubyte=no ++else ++ cat >conftest.$ac_ext <<_ACEOF ++#line $LINENO "configure" ++/* confdefs.h. */ ++_ACEOF ++cat confdefs.h >>conftest.$ac_ext ++cat >>conftest.$ac_ext <<_ACEOF ++/* end confdefs.h. */ ++#include ++#include ++ ++#if HAVE_SYS_TYPES_H ++# include ++#endif ++ ++#if HAVE_UNISTD_H ++# include ++#endif ++ ++#if HAVE_SYS_STAT_H ++# include ++#endif ++ ++#if HAVE_FCNTL_H ++# include ++#endif ++ ++#if HAVE_SIGNAL_H ++# include ++#endif ++ ++#if HAVE_TIME_H ++# include ++#endif ++ ++#if HAVE_TERMIOS_H ++# include ++#endif ++ ++#if HAVE_STRING_H ++# include ++#endif ++ ++#if HAVE_CTYPE_H ++# include ++#endif ++ ++#if defined(HAVE_GL_GL_H) ++# include ++#elif defined(HAVE_OPENGL_GL_H) ++# include ++#endif ++ ++#if defined(HAVE_AL_AL_H) ++# include ++#elif defined(HAVE_OPENAL_AL_H) ++# include ++#endif ++ ++#if defined(HAVE_AL_ALC_H) ++# include ++#elif defined(HAVE_OPENAL_ALC_H) ++# include ++#endif ++ ++#if HAVE_SYS_RESOURCE_H ++# include ++#endif ++ ++typedef ALubyte testing; ++ ++main() { ++ FILE *f=fopen("conftestval", "w"); ++ if (!f) exit(1); ++ if (((testing)((int)((testing)1.4))) == ((testing)1.4)) { ++ fprintf(f, "%s%d\n", ++ ((testing)(-1) < (testing)0) ? "Int" : "Word", ++ sizeof(testing)*8); ++ } else { ++ fprintf(f,"%s\n", ++ (sizeof(testing) > sizeof(double)) ? "LDouble" : ++ (sizeof(testing) == sizeof(double)) ? "Double" : "Float"); ++ } ++ fclose(f); ++ exit(0); ++} ++_ACEOF ++rm -f conftest$ac_exeext ++if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5 ++ (eval $ac_link) 2>&5 ++ ac_status=$? ++ echo "$as_me:$LINENO: \$? = $ac_status" >&5 ++ (exit $ac_status); } && { ac_try='./conftest$ac_exeext' ++ { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 ++ (eval $ac_try) 2>&5 ++ ac_status=$? ++ echo "$as_me:$LINENO: \$? = $ac_status" >&5 ++ (exit $ac_status); }; }; then ++ fptools_cv_htype_ALubyte=`cat conftestval` ++else ++ echo "$as_me: program exited with status $ac_status" >&5 ++echo "$as_me: failed program was:" >&5 ++sed 's/^/| /' conftest.$ac_ext >&5 ++ ++( exit $ac_status ) ++fptools_cv_htype_ALubyte=NotReallyAType; fptools_cv_htype_sup_ALubyte=no ++fi ++rm -f core core.* *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext ++fi ++CPPFLAGS="$fp_check_htype_save_cppflags" ++fi ++ if test "$fptools_cv_htype_sup_ALubyte" = yes; then ++ echo "$as_me:$LINENO: result: $fptools_cv_htype_ALubyte" >&5 ++echo "${ECHO_T}$fptools_cv_htype_ALubyte" >&6 ++ ++cat >>confdefs.h <<_ACEOF ++#define HTYPE_ALUBYTE $fptools_cv_htype_ALubyte ++_ACEOF ++ ++else ++ echo "$as_me:$LINENO: result: not supported" >&5 ++echo "${ECHO_T}not supported" >&6 ++fi ++ ++echo "$as_me:$LINENO: checking Haskell type for ALshort" >&5 ++echo $ECHO_N "checking Haskell type for ALshort... $ECHO_C" >&6 ++if test "${fptools_cv_htype_ALshort+set}" = set; then ++ echo $ECHO_N "(cached) $ECHO_C" >&6 ++else ++ fptools_cv_htype_sup_ALshort=yes ++fp_check_htype_save_cppflags="$CPPFLAGS" ++CPPFLAGS="$CPPFLAGS $X_CFLAGS" ++if test "$cross_compiling" = yes; then ++ fptools_cv_htype_ALshort=NotReallyATypeCross; fptools_cv_htype_sup_ALshort=no ++else ++ cat >conftest.$ac_ext <<_ACEOF ++#line $LINENO "configure" ++/* confdefs.h. */ ++_ACEOF ++cat confdefs.h >>conftest.$ac_ext ++cat >>conftest.$ac_ext <<_ACEOF ++/* end confdefs.h. */ ++#include ++#include ++ ++#if HAVE_SYS_TYPES_H ++# include ++#endif ++ ++#if HAVE_UNISTD_H ++# include ++#endif ++ ++#if HAVE_SYS_STAT_H ++# include ++#endif ++ ++#if HAVE_FCNTL_H ++# include ++#endif ++ ++#if HAVE_SIGNAL_H ++# include ++#endif ++ ++#if HAVE_TIME_H ++# include ++#endif ++ ++#if HAVE_TERMIOS_H ++# include ++#endif ++ ++#if HAVE_STRING_H ++# include ++#endif ++ ++#if HAVE_CTYPE_H ++# include ++#endif ++ ++#if defined(HAVE_GL_GL_H) ++# include ++#elif defined(HAVE_OPENGL_GL_H) ++# include ++#endif ++ ++#if defined(HAVE_AL_AL_H) ++# include ++#elif defined(HAVE_OPENAL_AL_H) ++# include ++#endif ++ ++#if defined(HAVE_AL_ALC_H) ++# include ++#elif defined(HAVE_OPENAL_ALC_H) ++# include ++#endif ++ ++#if HAVE_SYS_RESOURCE_H ++# include ++#endif ++ ++typedef ALshort testing; ++ ++main() { ++ FILE *f=fopen("conftestval", "w"); ++ if (!f) exit(1); ++ if (((testing)((int)((testing)1.4))) == ((testing)1.4)) { ++ fprintf(f, "%s%d\n", ++ ((testing)(-1) < (testing)0) ? "Int" : "Word", ++ sizeof(testing)*8); ++ } else { ++ fprintf(f,"%s\n", ++ (sizeof(testing) > sizeof(double)) ? "LDouble" : ++ (sizeof(testing) == sizeof(double)) ? "Double" : "Float"); ++ } ++ fclose(f); ++ exit(0); ++} ++_ACEOF ++rm -f conftest$ac_exeext ++if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5 ++ (eval $ac_link) 2>&5 ++ ac_status=$? ++ echo "$as_me:$LINENO: \$? = $ac_status" >&5 ++ (exit $ac_status); } && { ac_try='./conftest$ac_exeext' ++ { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 ++ (eval $ac_try) 2>&5 ++ ac_status=$? ++ echo "$as_me:$LINENO: \$? = $ac_status" >&5 ++ (exit $ac_status); }; }; then ++ fptools_cv_htype_ALshort=`cat conftestval` ++else ++ echo "$as_me: program exited with status $ac_status" >&5 ++echo "$as_me: failed program was:" >&5 ++sed 's/^/| /' conftest.$ac_ext >&5 ++ ++( exit $ac_status ) ++fptools_cv_htype_ALshort=NotReallyAType; fptools_cv_htype_sup_ALshort=no ++fi ++rm -f core core.* *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext ++fi ++CPPFLAGS="$fp_check_htype_save_cppflags" ++fi ++ if test "$fptools_cv_htype_sup_ALshort" = yes; then ++ echo "$as_me:$LINENO: result: $fptools_cv_htype_ALshort" >&5 ++echo "${ECHO_T}$fptools_cv_htype_ALshort" >&6 ++ ++cat >>confdefs.h <<_ACEOF ++#define HTYPE_ALSHORT $fptools_cv_htype_ALshort ++_ACEOF ++ ++else ++ echo "$as_me:$LINENO: result: not supported" >&5 ++echo "${ECHO_T}not supported" >&6 ++fi ++ ++echo "$as_me:$LINENO: checking Haskell type for ALushort" >&5 ++echo $ECHO_N "checking Haskell type for ALushort... $ECHO_C" >&6 ++if test "${fptools_cv_htype_ALushort+set}" = set; then ++ echo $ECHO_N "(cached) $ECHO_C" >&6 ++else ++ fptools_cv_htype_sup_ALushort=yes ++fp_check_htype_save_cppflags="$CPPFLAGS" ++CPPFLAGS="$CPPFLAGS $X_CFLAGS" ++if test "$cross_compiling" = yes; then ++ fptools_cv_htype_ALushort=NotReallyATypeCross; fptools_cv_htype_sup_ALushort=no ++else ++ cat >conftest.$ac_ext <<_ACEOF ++#line $LINENO "configure" ++/* confdefs.h. */ ++_ACEOF ++cat confdefs.h >>conftest.$ac_ext ++cat >>conftest.$ac_ext <<_ACEOF ++/* end confdefs.h. */ ++#include ++#include ++ ++#if HAVE_SYS_TYPES_H ++# include ++#endif ++ ++#if HAVE_UNISTD_H ++# include ++#endif ++ ++#if HAVE_SYS_STAT_H ++# include ++#endif ++ ++#if HAVE_FCNTL_H ++# include ++#endif ++ ++#if HAVE_SIGNAL_H ++# include ++#endif ++ ++#if HAVE_TIME_H ++# include ++#endif ++ ++#if HAVE_TERMIOS_H ++# include ++#endif ++ ++#if HAVE_STRING_H ++# include ++#endif ++ ++#if HAVE_CTYPE_H ++# include ++#endif ++ ++#if defined(HAVE_GL_GL_H) ++# include ++#elif defined(HAVE_OPENGL_GL_H) ++# include ++#endif ++ ++#if defined(HAVE_AL_AL_H) ++# include ++#elif defined(HAVE_OPENAL_AL_H) ++# include ++#endif ++ ++#if defined(HAVE_AL_ALC_H) ++# include ++#elif defined(HAVE_OPENAL_ALC_H) ++# include ++#endif ++ ++#if HAVE_SYS_RESOURCE_H ++# include ++#endif ++ ++typedef ALushort testing; ++ ++main() { ++ FILE *f=fopen("conftestval", "w"); ++ if (!f) exit(1); ++ if (((testing)((int)((testing)1.4))) == ((testing)1.4)) { ++ fprintf(f, "%s%d\n", ++ ((testing)(-1) < (testing)0) ? "Int" : "Word", ++ sizeof(testing)*8); ++ } else { ++ fprintf(f,"%s\n", ++ (sizeof(testing) > sizeof(double)) ? "LDouble" : ++ (sizeof(testing) == sizeof(double)) ? "Double" : "Float"); ++ } ++ fclose(f); ++ exit(0); ++} ++_ACEOF ++rm -f conftest$ac_exeext ++if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5 ++ (eval $ac_link) 2>&5 ++ ac_status=$? ++ echo "$as_me:$LINENO: \$? = $ac_status" >&5 ++ (exit $ac_status); } && { ac_try='./conftest$ac_exeext' ++ { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 ++ (eval $ac_try) 2>&5 ++ ac_status=$? ++ echo "$as_me:$LINENO: \$? = $ac_status" >&5 ++ (exit $ac_status); }; }; then ++ fptools_cv_htype_ALushort=`cat conftestval` ++else ++ echo "$as_me: program exited with status $ac_status" >&5 ++echo "$as_me: failed program was:" >&5 ++sed 's/^/| /' conftest.$ac_ext >&5 ++ ++( exit $ac_status ) ++fptools_cv_htype_ALushort=NotReallyAType; fptools_cv_htype_sup_ALushort=no ++fi ++rm -f core core.* *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext ++fi ++CPPFLAGS="$fp_check_htype_save_cppflags" ++fi ++ if test "$fptools_cv_htype_sup_ALushort" = yes; then ++ echo "$as_me:$LINENO: result: $fptools_cv_htype_ALushort" >&5 ++echo "${ECHO_T}$fptools_cv_htype_ALushort" >&6 ++ ++cat >>confdefs.h <<_ACEOF ++#define HTYPE_ALUSHORT $fptools_cv_htype_ALushort ++_ACEOF ++ ++else ++ echo "$as_me:$LINENO: result: not supported" >&5 ++echo "${ECHO_T}not supported" >&6 ++fi ++ ++echo "$as_me:$LINENO: checking Haskell type for ALint" >&5 ++echo $ECHO_N "checking Haskell type for ALint... $ECHO_C" >&6 ++if test "${fptools_cv_htype_ALint+set}" = set; then ++ echo $ECHO_N "(cached) $ECHO_C" >&6 ++else ++ fptools_cv_htype_sup_ALint=yes ++fp_check_htype_save_cppflags="$CPPFLAGS" ++CPPFLAGS="$CPPFLAGS $X_CFLAGS" ++if test "$cross_compiling" = yes; then ++ fptools_cv_htype_ALint=NotReallyATypeCross; fptools_cv_htype_sup_ALint=no ++else ++ cat >conftest.$ac_ext <<_ACEOF ++#line $LINENO "configure" ++/* confdefs.h. */ ++_ACEOF ++cat confdefs.h >>conftest.$ac_ext ++cat >>conftest.$ac_ext <<_ACEOF ++/* end confdefs.h. */ ++#include ++#include ++ ++#if HAVE_SYS_TYPES_H ++# include ++#endif ++ ++#if HAVE_UNISTD_H ++# include ++#endif ++ ++#if HAVE_SYS_STAT_H ++# include ++#endif ++ ++#if HAVE_FCNTL_H ++# include ++#endif ++ ++#if HAVE_SIGNAL_H ++# include ++#endif ++ ++#if HAVE_TIME_H ++# include ++#endif ++ ++#if HAVE_TERMIOS_H ++# include ++#endif ++ ++#if HAVE_STRING_H ++# include ++#endif ++ ++#if HAVE_CTYPE_H ++# include ++#endif ++ ++#if defined(HAVE_GL_GL_H) ++# include ++#elif defined(HAVE_OPENGL_GL_H) ++# include ++#endif ++ ++#if defined(HAVE_AL_AL_H) ++# include ++#elif defined(HAVE_OPENAL_AL_H) ++# include ++#endif ++ ++#if defined(HAVE_AL_ALC_H) ++# include ++#elif defined(HAVE_OPENAL_ALC_H) ++# include ++#endif ++ ++#if HAVE_SYS_RESOURCE_H ++# include ++#endif ++ ++typedef ALint testing; ++ ++main() { ++ FILE *f=fopen("conftestval", "w"); ++ if (!f) exit(1); ++ if (((testing)((int)((testing)1.4))) == ((testing)1.4)) { ++ fprintf(f, "%s%d\n", ++ ((testing)(-1) < (testing)0) ? "Int" : "Word", ++ sizeof(testing)*8); ++ } else { ++ fprintf(f,"%s\n", ++ (sizeof(testing) > sizeof(double)) ? "LDouble" : ++ (sizeof(testing) == sizeof(double)) ? "Double" : "Float"); ++ } ++ fclose(f); ++ exit(0); ++} ++_ACEOF ++rm -f conftest$ac_exeext ++if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5 ++ (eval $ac_link) 2>&5 ++ ac_status=$? ++ echo "$as_me:$LINENO: \$? = $ac_status" >&5 ++ (exit $ac_status); } && { ac_try='./conftest$ac_exeext' ++ { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 ++ (eval $ac_try) 2>&5 ++ ac_status=$? ++ echo "$as_me:$LINENO: \$? = $ac_status" >&5 ++ (exit $ac_status); }; }; then ++ fptools_cv_htype_ALint=`cat conftestval` ++else ++ echo "$as_me: program exited with status $ac_status" >&5 ++echo "$as_me: failed program was:" >&5 ++sed 's/^/| /' conftest.$ac_ext >&5 ++ ++( exit $ac_status ) ++fptools_cv_htype_ALint=NotReallyAType; fptools_cv_htype_sup_ALint=no ++fi ++rm -f core core.* *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext ++fi ++CPPFLAGS="$fp_check_htype_save_cppflags" ++fi ++ if test "$fptools_cv_htype_sup_ALint" = yes; then ++ echo "$as_me:$LINENO: result: $fptools_cv_htype_ALint" >&5 ++echo "${ECHO_T}$fptools_cv_htype_ALint" >&6 ++ ++cat >>confdefs.h <<_ACEOF ++#define HTYPE_ALINT $fptools_cv_htype_ALint ++_ACEOF ++ ++else ++ echo "$as_me:$LINENO: result: not supported" >&5 ++echo "${ECHO_T}not supported" >&6 ++fi ++ ++echo "$as_me:$LINENO: checking Haskell type for ALuint" >&5 ++echo $ECHO_N "checking Haskell type for ALuint... $ECHO_C" >&6 ++if test "${fptools_cv_htype_ALuint+set}" = set; then ++ echo $ECHO_N "(cached) $ECHO_C" >&6 ++else ++ fptools_cv_htype_sup_ALuint=yes ++fp_check_htype_save_cppflags="$CPPFLAGS" ++CPPFLAGS="$CPPFLAGS $X_CFLAGS" ++if test "$cross_compiling" = yes; then ++ fptools_cv_htype_ALuint=NotReallyATypeCross; fptools_cv_htype_sup_ALuint=no ++else ++ cat >conftest.$ac_ext <<_ACEOF ++#line $LINENO "configure" ++/* confdefs.h. */ ++_ACEOF ++cat confdefs.h >>conftest.$ac_ext ++cat >>conftest.$ac_ext <<_ACEOF ++/* end confdefs.h. */ ++#include ++#include ++ ++#if HAVE_SYS_TYPES_H ++# include ++#endif ++ ++#if HAVE_UNISTD_H ++# include ++#endif ++ ++#if HAVE_SYS_STAT_H ++# include ++#endif ++ ++#if HAVE_FCNTL_H ++# include ++#endif ++ ++#if HAVE_SIGNAL_H ++# include ++#endif ++ ++#if HAVE_TIME_H ++# include ++#endif ++ ++#if HAVE_TERMIOS_H ++# include ++#endif ++ ++#if HAVE_STRING_H ++# include ++#endif ++ ++#if HAVE_CTYPE_H ++# include ++#endif ++ ++#if defined(HAVE_GL_GL_H) ++# include ++#elif defined(HAVE_OPENGL_GL_H) ++# include ++#endif ++ ++#if defined(HAVE_AL_AL_H) ++# include ++#elif defined(HAVE_OPENAL_AL_H) ++# include ++#endif ++ ++#if defined(HAVE_AL_ALC_H) ++# include ++#elif defined(HAVE_OPENAL_ALC_H) ++# include ++#endif ++ ++#if HAVE_SYS_RESOURCE_H ++# include ++#endif ++ ++typedef ALuint testing; ++ ++main() { ++ FILE *f=fopen("conftestval", "w"); ++ if (!f) exit(1); ++ if (((testing)((int)((testing)1.4))) == ((testing)1.4)) { ++ fprintf(f, "%s%d\n", ++ ((testing)(-1) < (testing)0) ? "Int" : "Word", ++ sizeof(testing)*8); ++ } else { ++ fprintf(f,"%s\n", ++ (sizeof(testing) > sizeof(double)) ? "LDouble" : ++ (sizeof(testing) == sizeof(double)) ? "Double" : "Float"); ++ } ++ fclose(f); ++ exit(0); ++} ++_ACEOF ++rm -f conftest$ac_exeext ++if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5 ++ (eval $ac_link) 2>&5 ++ ac_status=$? ++ echo "$as_me:$LINENO: \$? = $ac_status" >&5 ++ (exit $ac_status); } && { ac_try='./conftest$ac_exeext' ++ { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 ++ (eval $ac_try) 2>&5 ++ ac_status=$? ++ echo "$as_me:$LINENO: \$? = $ac_status" >&5 ++ (exit $ac_status); }; }; then ++ fptools_cv_htype_ALuint=`cat conftestval` ++else ++ echo "$as_me: program exited with status $ac_status" >&5 ++echo "$as_me: failed program was:" >&5 ++sed 's/^/| /' conftest.$ac_ext >&5 ++ ++( exit $ac_status ) ++fptools_cv_htype_ALuint=NotReallyAType; fptools_cv_htype_sup_ALuint=no ++fi ++rm -f core core.* *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext ++fi ++CPPFLAGS="$fp_check_htype_save_cppflags" ++fi ++ if test "$fptools_cv_htype_sup_ALuint" = yes; then ++ echo "$as_me:$LINENO: result: $fptools_cv_htype_ALuint" >&5 ++echo "${ECHO_T}$fptools_cv_htype_ALuint" >&6 ++ ++cat >>confdefs.h <<_ACEOF ++#define HTYPE_ALUINT $fptools_cv_htype_ALuint ++_ACEOF ++ ++else ++ echo "$as_me:$LINENO: result: not supported" >&5 ++echo "${ECHO_T}not supported" >&6 ++fi ++ ++echo "$as_me:$LINENO: checking Haskell type for ALsizei" >&5 ++echo $ECHO_N "checking Haskell type for ALsizei... $ECHO_C" >&6 ++if test "${fptools_cv_htype_ALsizei+set}" = set; then ++ echo $ECHO_N "(cached) $ECHO_C" >&6 ++else ++ fptools_cv_htype_sup_ALsizei=yes ++fp_check_htype_save_cppflags="$CPPFLAGS" ++CPPFLAGS="$CPPFLAGS $X_CFLAGS" ++if test "$cross_compiling" = yes; then ++ fptools_cv_htype_ALsizei=NotReallyATypeCross; fptools_cv_htype_sup_ALsizei=no ++else ++ cat >conftest.$ac_ext <<_ACEOF ++#line $LINENO "configure" ++/* confdefs.h. */ ++_ACEOF ++cat confdefs.h >>conftest.$ac_ext ++cat >>conftest.$ac_ext <<_ACEOF ++/* end confdefs.h. */ ++#include ++#include ++ ++#if HAVE_SYS_TYPES_H ++# include ++#endif ++ ++#if HAVE_UNISTD_H ++# include ++#endif ++ ++#if HAVE_SYS_STAT_H ++# include ++#endif ++ ++#if HAVE_FCNTL_H ++# include ++#endif ++ ++#if HAVE_SIGNAL_H ++# include ++#endif ++ ++#if HAVE_TIME_H ++# include ++#endif ++ ++#if HAVE_TERMIOS_H ++# include ++#endif ++ ++#if HAVE_STRING_H ++# include ++#endif ++ ++#if HAVE_CTYPE_H ++# include ++#endif ++ ++#if defined(HAVE_GL_GL_H) ++# include ++#elif defined(HAVE_OPENGL_GL_H) ++# include ++#endif ++ ++#if defined(HAVE_AL_AL_H) ++# include ++#elif defined(HAVE_OPENAL_AL_H) ++# include ++#endif ++ ++#if defined(HAVE_AL_ALC_H) ++# include ++#elif defined(HAVE_OPENAL_ALC_H) ++# include ++#endif ++ ++#if HAVE_SYS_RESOURCE_H ++# include ++#endif ++ ++typedef ALsizei testing; ++ ++main() { ++ FILE *f=fopen("conftestval", "w"); ++ if (!f) exit(1); ++ if (((testing)((int)((testing)1.4))) == ((testing)1.4)) { ++ fprintf(f, "%s%d\n", ++ ((testing)(-1) < (testing)0) ? "Int" : "Word", ++ sizeof(testing)*8); ++ } else { ++ fprintf(f,"%s\n", ++ (sizeof(testing) > sizeof(double)) ? "LDouble" : ++ (sizeof(testing) == sizeof(double)) ? "Double" : "Float"); ++ } ++ fclose(f); ++ exit(0); ++} ++_ACEOF ++rm -f conftest$ac_exeext ++if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5 ++ (eval $ac_link) 2>&5 ++ ac_status=$? ++ echo "$as_me:$LINENO: \$? = $ac_status" >&5 ++ (exit $ac_status); } && { ac_try='./conftest$ac_exeext' ++ { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 ++ (eval $ac_try) 2>&5 ++ ac_status=$? ++ echo "$as_me:$LINENO: \$? = $ac_status" >&5 ++ (exit $ac_status); }; }; then ++ fptools_cv_htype_ALsizei=`cat conftestval` ++else ++ echo "$as_me: program exited with status $ac_status" >&5 ++echo "$as_me: failed program was:" >&5 ++sed 's/^/| /' conftest.$ac_ext >&5 ++ ++( exit $ac_status ) ++fptools_cv_htype_ALsizei=NotReallyAType; fptools_cv_htype_sup_ALsizei=no ++fi ++rm -f core core.* *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext ++fi ++CPPFLAGS="$fp_check_htype_save_cppflags" + fi +- CPPFLAGS="$fp_check_htype_save_cppflags" +-if test "$fptools_cv_htype_sup_ALboolean" = yes; then +- echo "$as_me:$LINENO: result: $fptools_cv_htype_ALboolean" >&5 +-echo "${ECHO_T}$fptools_cv_htype_ALboolean" >&6 ++ if test "$fptools_cv_htype_sup_ALsizei" = yes; then ++ echo "$as_me:$LINENO: result: $fptools_cv_htype_ALsizei" >&5 ++echo "${ECHO_T}$fptools_cv_htype_ALsizei" >&6 + + cat >>confdefs.h <<_ACEOF +-#define HTYPE_ALBOOLEAN $fptools_cv_htype_ALboolean ++#define HTYPE_ALSIZEI $fptools_cv_htype_ALsizei + _ACEOF + + else +@@ -3188,16 +4653,150 @@ + echo "${ECHO_T}not supported" >&6 + fi + +-echo "$as_me:$LINENO: checking Haskell type for ALbyte" >&5 +-echo $ECHO_N "checking Haskell type for ALbyte... $ECHO_C" >&6 +-if test "${fptools_cv_htype_ALbyte+set}" = set; then ++echo "$as_me:$LINENO: checking Haskell type for ALenum" >&5 ++echo $ECHO_N "checking Haskell type for ALenum... $ECHO_C" >&6 ++if test "${fptools_cv_htype_ALenum+set}" = set; then ++ echo $ECHO_N "(cached) $ECHO_C" >&6 ++else ++ fptools_cv_htype_sup_ALenum=yes ++fp_check_htype_save_cppflags="$CPPFLAGS" ++CPPFLAGS="$CPPFLAGS $X_CFLAGS" ++if test "$cross_compiling" = yes; then ++ fptools_cv_htype_ALenum=NotReallyATypeCross; fptools_cv_htype_sup_ALenum=no ++else ++ cat >conftest.$ac_ext <<_ACEOF ++#line $LINENO "configure" ++/* confdefs.h. */ ++_ACEOF ++cat confdefs.h >>conftest.$ac_ext ++cat >>conftest.$ac_ext <<_ACEOF ++/* end confdefs.h. */ ++#include ++#include ++ ++#if HAVE_SYS_TYPES_H ++# include ++#endif ++ ++#if HAVE_UNISTD_H ++# include ++#endif ++ ++#if HAVE_SYS_STAT_H ++# include ++#endif ++ ++#if HAVE_FCNTL_H ++# include ++#endif ++ ++#if HAVE_SIGNAL_H ++# include ++#endif ++ ++#if HAVE_TIME_H ++# include ++#endif ++ ++#if HAVE_TERMIOS_H ++# include ++#endif ++ ++#if HAVE_STRING_H ++# include ++#endif ++ ++#if HAVE_CTYPE_H ++# include ++#endif ++ ++#if defined(HAVE_GL_GL_H) ++# include ++#elif defined(HAVE_OPENGL_GL_H) ++# include ++#endif ++ ++#if defined(HAVE_AL_AL_H) ++# include ++#elif defined(HAVE_OPENAL_AL_H) ++# include ++#endif ++ ++#if defined(HAVE_AL_ALC_H) ++# include ++#elif defined(HAVE_OPENAL_ALC_H) ++# include ++#endif ++ ++#if HAVE_SYS_RESOURCE_H ++# include ++#endif ++ ++typedef ALenum testing; ++ ++main() { ++ FILE *f=fopen("conftestval", "w"); ++ if (!f) exit(1); ++ if (((testing)((int)((testing)1.4))) == ((testing)1.4)) { ++ fprintf(f, "%s%d\n", ++ ((testing)(-1) < (testing)0) ? "Int" : "Word", ++ sizeof(testing)*8); ++ } else { ++ fprintf(f,"%s\n", ++ (sizeof(testing) > sizeof(double)) ? "LDouble" : ++ (sizeof(testing) == sizeof(double)) ? "Double" : "Float"); ++ } ++ fclose(f); ++ exit(0); ++} ++_ACEOF ++rm -f conftest$ac_exeext ++if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5 ++ (eval $ac_link) 2>&5 ++ ac_status=$? ++ echo "$as_me:$LINENO: \$? = $ac_status" >&5 ++ (exit $ac_status); } && { ac_try='./conftest$ac_exeext' ++ { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 ++ (eval $ac_try) 2>&5 ++ ac_status=$? ++ echo "$as_me:$LINENO: \$? = $ac_status" >&5 ++ (exit $ac_status); }; }; then ++ fptools_cv_htype_ALenum=`cat conftestval` ++else ++ echo "$as_me: program exited with status $ac_status" >&5 ++echo "$as_me: failed program was:" >&5 ++sed 's/^/| /' conftest.$ac_ext >&5 ++ ++( exit $ac_status ) ++fptools_cv_htype_ALenum=NotReallyAType; fptools_cv_htype_sup_ALenum=no ++fi ++rm -f core core.* *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext ++fi ++CPPFLAGS="$fp_check_htype_save_cppflags" ++fi ++ if test "$fptools_cv_htype_sup_ALenum" = yes; then ++ echo "$as_me:$LINENO: result: $fptools_cv_htype_ALenum" >&5 ++echo "${ECHO_T}$fptools_cv_htype_ALenum" >&6 ++ ++cat >>confdefs.h <<_ACEOF ++#define HTYPE_ALENUM $fptools_cv_htype_ALenum ++_ACEOF ++ ++else ++ echo "$as_me:$LINENO: result: not supported" >&5 ++echo "${ECHO_T}not supported" >&6 ++fi ++ ++echo "$as_me:$LINENO: checking Haskell type for ALfloat" >&5 ++echo $ECHO_N "checking Haskell type for ALfloat... $ECHO_C" >&6 ++if test "${fptools_cv_htype_ALfloat+set}" = set; then + echo $ECHO_N "(cached) $ECHO_C" >&6 + else +- fptools_cv_htype_sup_ALbyte=yes ++ fptools_cv_htype_sup_ALfloat=yes + fp_check_htype_save_cppflags="$CPPFLAGS" + CPPFLAGS="$CPPFLAGS $X_CFLAGS" + if test "$cross_compiling" = yes; then +- fptools_cv_htype_ALbyte=NotReallyATypeCross; fptools_cv_htype_sup_ALbyte=no ++ fptools_cv_htype_ALfloat=NotReallyATypeCross; fptools_cv_htype_sup_ALfloat=no + else + cat >conftest.$ac_ext <<_ACEOF + #line $LINENO "configure" +@@ -3251,6 +4850,12 @@ + # include + #endif + ++#if defined(HAVE_AL_AL_H) ++# include ++#elif defined(HAVE_OPENAL_AL_H) ++# include ++#endif ++ + #if defined(HAVE_AL_ALC_H) + # include + #elif defined(HAVE_OPENAL_ALC_H) +@@ -3261,7 +4866,7 @@ + # include + #endif + +-typedef ALbyte testing; ++typedef ALfloat testing; + + main() { + FILE *f=fopen("conftestval", "w"); +@@ -3290,25 +4895,25 @@ + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then +- fptools_cv_htype_ALbyte=`cat conftestval` ++ fptools_cv_htype_ALfloat=`cat conftestval` + else + echo "$as_me: program exited with status $ac_status" >&5 + echo "$as_me: failed program was:" >&5 + sed 's/^/| /' conftest.$ac_ext >&5 + + ( exit $ac_status ) +-fptools_cv_htype_ALbyte=NotReallyAType; fptools_cv_htype_sup_ALbyte=no ++fptools_cv_htype_ALfloat=NotReallyAType; fptools_cv_htype_sup_ALfloat=no + fi + rm -f core core.* *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext + fi ++CPPFLAGS="$fp_check_htype_save_cppflags" + fi +- CPPFLAGS="$fp_check_htype_save_cppflags" +-if test "$fptools_cv_htype_sup_ALbyte" = yes; then +- echo "$as_me:$LINENO: result: $fptools_cv_htype_ALbyte" >&5 +-echo "${ECHO_T}$fptools_cv_htype_ALbyte" >&6 ++ if test "$fptools_cv_htype_sup_ALfloat" = yes; then ++ echo "$as_me:$LINENO: result: $fptools_cv_htype_ALfloat" >&5 ++echo "${ECHO_T}$fptools_cv_htype_ALfloat" >&6 + + cat >>confdefs.h <<_ACEOF +-#define HTYPE_ALBYTE $fptools_cv_htype_ALbyte ++#define HTYPE_ALFLOAT $fptools_cv_htype_ALfloat + _ACEOF + + else +@@ -3316,16 +4921,16 @@ + echo "${ECHO_T}not supported" >&6 + fi + +-echo "$as_me:$LINENO: checking Haskell type for ALubyte" >&5 +-echo $ECHO_N "checking Haskell type for ALubyte... $ECHO_C" >&6 +-if test "${fptools_cv_htype_ALubyte+set}" = set; then ++echo "$as_me:$LINENO: checking Haskell type for ALdouble" >&5 ++echo $ECHO_N "checking Haskell type for ALdouble... $ECHO_C" >&6 ++if test "${fptools_cv_htype_ALdouble+set}" = set; then + echo $ECHO_N "(cached) $ECHO_C" >&6 + else +- fptools_cv_htype_sup_ALubyte=yes ++ fptools_cv_htype_sup_ALdouble=yes + fp_check_htype_save_cppflags="$CPPFLAGS" + CPPFLAGS="$CPPFLAGS $X_CFLAGS" + if test "$cross_compiling" = yes; then +- fptools_cv_htype_ALubyte=NotReallyATypeCross; fptools_cv_htype_sup_ALubyte=no ++ fptools_cv_htype_ALdouble=NotReallyATypeCross; fptools_cv_htype_sup_ALdouble=no + else + cat >conftest.$ac_ext <<_ACEOF + #line $LINENO "configure" +@@ -3379,6 +4984,12 @@ + # include + #endif + ++#if defined(HAVE_AL_AL_H) ++# include ++#elif defined(HAVE_OPENAL_AL_H) ++# include ++#endif ++ + #if defined(HAVE_AL_ALC_H) + # include + #elif defined(HAVE_OPENAL_ALC_H) +@@ -3389,7 +5000,7 @@ + # include + #endif + +-typedef ALubyte testing; ++typedef ALdouble testing; + + main() { + FILE *f=fopen("conftestval", "w"); +@@ -3418,25 +5029,25 @@ + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then +- fptools_cv_htype_ALubyte=`cat conftestval` ++ fptools_cv_htype_ALdouble=`cat conftestval` + else + echo "$as_me: program exited with status $ac_status" >&5 + echo "$as_me: failed program was:" >&5 + sed 's/^/| /' conftest.$ac_ext >&5 + + ( exit $ac_status ) +-fptools_cv_htype_ALubyte=NotReallyAType; fptools_cv_htype_sup_ALubyte=no ++fptools_cv_htype_ALdouble=NotReallyAType; fptools_cv_htype_sup_ALdouble=no + fi + rm -f core core.* *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext + fi ++CPPFLAGS="$fp_check_htype_save_cppflags" + fi +- CPPFLAGS="$fp_check_htype_save_cppflags" +-if test "$fptools_cv_htype_sup_ALubyte" = yes; then +- echo "$as_me:$LINENO: result: $fptools_cv_htype_ALubyte" >&5 +-echo "${ECHO_T}$fptools_cv_htype_ALubyte" >&6 ++ if test "$fptools_cv_htype_sup_ALdouble" = yes; then ++ echo "$as_me:$LINENO: result: $fptools_cv_htype_ALdouble" >&5 ++echo "${ECHO_T}$fptools_cv_htype_ALdouble" >&6 + + cat >>confdefs.h <<_ACEOF +-#define HTYPE_ALUBYTE $fptools_cv_htype_ALubyte ++#define HTYPE_ALDOUBLE $fptools_cv_htype_ALdouble + _ACEOF + + else +@@ -3444,16 +5055,17 @@ + echo "${ECHO_T}not supported" >&6 + fi + +-echo "$as_me:$LINENO: checking Haskell type for ALshort" >&5 +-echo $ECHO_N "checking Haskell type for ALshort... $ECHO_C" >&6 +-if test "${fptools_cv_htype_ALshort+set}" = set; then ++ ++echo "$as_me:$LINENO: checking Haskell type for ALCboolean" >&5 ++echo $ECHO_N "checking Haskell type for ALCboolean... $ECHO_C" >&6 ++if test "${fptools_cv_htype_ALCboolean+set}" = set; then + echo $ECHO_N "(cached) $ECHO_C" >&6 + else +- fptools_cv_htype_sup_ALshort=yes ++ fptools_cv_htype_sup_ALCboolean=yes + fp_check_htype_save_cppflags="$CPPFLAGS" + CPPFLAGS="$CPPFLAGS $X_CFLAGS" + if test "$cross_compiling" = yes; then +- fptools_cv_htype_ALshort=NotReallyATypeCross; fptools_cv_htype_sup_ALshort=no ++ fptools_cv_htype_ALCboolean=NotReallyATypeCross; fptools_cv_htype_sup_ALCboolean=no + else + cat >conftest.$ac_ext <<_ACEOF + #line $LINENO "configure" +@@ -3507,6 +5119,12 @@ + # include + #endif + ++#if defined(HAVE_AL_AL_H) ++# include ++#elif defined(HAVE_OPENAL_AL_H) ++# include ++#endif ++ + #if defined(HAVE_AL_ALC_H) + # include + #elif defined(HAVE_OPENAL_ALC_H) +@@ -3517,7 +5135,7 @@ + # include + #endif + +-typedef ALshort testing; ++typedef ALCboolean testing; + + main() { + FILE *f=fopen("conftestval", "w"); +@@ -3546,25 +5164,25 @@ + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then +- fptools_cv_htype_ALshort=`cat conftestval` ++ fptools_cv_htype_ALCboolean=`cat conftestval` + else + echo "$as_me: program exited with status $ac_status" >&5 + echo "$as_me: failed program was:" >&5 + sed 's/^/| /' conftest.$ac_ext >&5 + + ( exit $ac_status ) +-fptools_cv_htype_ALshort=NotReallyAType; fptools_cv_htype_sup_ALshort=no ++fptools_cv_htype_ALCboolean=Int8 + fi + rm -f core core.* *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext + fi ++CPPFLAGS="$fp_check_htype_save_cppflags" + fi +- CPPFLAGS="$fp_check_htype_save_cppflags" +-if test "$fptools_cv_htype_sup_ALshort" = yes; then +- echo "$as_me:$LINENO: result: $fptools_cv_htype_ALshort" >&5 +-echo "${ECHO_T}$fptools_cv_htype_ALshort" >&6 ++ if test "$fptools_cv_htype_sup_ALCboolean" = yes; then ++ echo "$as_me:$LINENO: result: $fptools_cv_htype_ALCboolean" >&5 ++echo "${ECHO_T}$fptools_cv_htype_ALCboolean" >&6 + + cat >>confdefs.h <<_ACEOF +-#define HTYPE_ALSHORT $fptools_cv_htype_ALshort ++#define HTYPE_ALCBOOLEAN $fptools_cv_htype_ALCboolean + _ACEOF + + else +@@ -3572,16 +5190,16 @@ + echo "${ECHO_T}not supported" >&6 + fi + +-echo "$as_me:$LINENO: checking Haskell type for ALushort" >&5 +-echo $ECHO_N "checking Haskell type for ALushort... $ECHO_C" >&6 +-if test "${fptools_cv_htype_ALushort+set}" = set; then ++echo "$as_me:$LINENO: checking Haskell type for ALCchar" >&5 ++echo $ECHO_N "checking Haskell type for ALCchar... $ECHO_C" >&6 ++if test "${fptools_cv_htype_ALCchar+set}" = set; then + echo $ECHO_N "(cached) $ECHO_C" >&6 + else +- fptools_cv_htype_sup_ALushort=yes ++ fptools_cv_htype_sup_ALCchar=yes + fp_check_htype_save_cppflags="$CPPFLAGS" + CPPFLAGS="$CPPFLAGS $X_CFLAGS" + if test "$cross_compiling" = yes; then +- fptools_cv_htype_ALushort=NotReallyATypeCross; fptools_cv_htype_sup_ALushort=no ++ fptools_cv_htype_ALCchar=NotReallyATypeCross; fptools_cv_htype_sup_ALCchar=no + else + cat >conftest.$ac_ext <<_ACEOF + #line $LINENO "configure" +@@ -3635,6 +5253,12 @@ + # include + #endif + ++#if defined(HAVE_AL_AL_H) ++# include ++#elif defined(HAVE_OPENAL_AL_H) ++# include ++#endif ++ + #if defined(HAVE_AL_ALC_H) + # include + #elif defined(HAVE_OPENAL_ALC_H) +@@ -3645,7 +5269,7 @@ + # include + #endif + +-typedef ALushort testing; ++typedef ALCchar testing; + + main() { + FILE *f=fopen("conftestval", "w"); +@@ -3674,25 +5298,25 @@ + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then +- fptools_cv_htype_ALushort=`cat conftestval` ++ fptools_cv_htype_ALCchar=`cat conftestval` + else + echo "$as_me: program exited with status $ac_status" >&5 + echo "$as_me: failed program was:" >&5 + sed 's/^/| /' conftest.$ac_ext >&5 + + ( exit $ac_status ) +-fptools_cv_htype_ALushort=NotReallyAType; fptools_cv_htype_sup_ALushort=no ++fptools_cv_htype_ALCchar=Int8 + fi + rm -f core core.* *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext + fi ++CPPFLAGS="$fp_check_htype_save_cppflags" + fi +- CPPFLAGS="$fp_check_htype_save_cppflags" +-if test "$fptools_cv_htype_sup_ALushort" = yes; then +- echo "$as_me:$LINENO: result: $fptools_cv_htype_ALushort" >&5 +-echo "${ECHO_T}$fptools_cv_htype_ALushort" >&6 ++ if test "$fptools_cv_htype_sup_ALCchar" = yes; then ++ echo "$as_me:$LINENO: result: $fptools_cv_htype_ALCchar" >&5 ++echo "${ECHO_T}$fptools_cv_htype_ALCchar" >&6 + + cat >>confdefs.h <<_ACEOF +-#define HTYPE_ALUSHORT $fptools_cv_htype_ALushort ++#define HTYPE_ALCCHAR $fptools_cv_htype_ALCchar + _ACEOF + + else +@@ -3700,16 +5324,16 @@ + echo "${ECHO_T}not supported" >&6 + fi + +-echo "$as_me:$LINENO: checking Haskell type for ALint" >&5 +-echo $ECHO_N "checking Haskell type for ALint... $ECHO_C" >&6 +-if test "${fptools_cv_htype_ALint+set}" = set; then ++echo "$as_me:$LINENO: checking Haskell type for ALCbyte" >&5 ++echo $ECHO_N "checking Haskell type for ALCbyte... $ECHO_C" >&6 ++if test "${fptools_cv_htype_ALCbyte+set}" = set; then + echo $ECHO_N "(cached) $ECHO_C" >&6 + else +- fptools_cv_htype_sup_ALint=yes ++ fptools_cv_htype_sup_ALCbyte=yes + fp_check_htype_save_cppflags="$CPPFLAGS" + CPPFLAGS="$CPPFLAGS $X_CFLAGS" + if test "$cross_compiling" = yes; then +- fptools_cv_htype_ALint=NotReallyATypeCross; fptools_cv_htype_sup_ALint=no ++ fptools_cv_htype_ALCbyte=NotReallyATypeCross; fptools_cv_htype_sup_ALCbyte=no + else + cat >conftest.$ac_ext <<_ACEOF + #line $LINENO "configure" +@@ -3763,6 +5387,12 @@ + # include + #endif + ++#if defined(HAVE_AL_AL_H) ++# include ++#elif defined(HAVE_OPENAL_AL_H) ++# include ++#endif ++ + #if defined(HAVE_AL_ALC_H) + # include + #elif defined(HAVE_OPENAL_ALC_H) +@@ -3773,7 +5403,7 @@ + # include + #endif + +-typedef ALint testing; ++typedef ALCbyte testing; + + main() { + FILE *f=fopen("conftestval", "w"); +@@ -3802,25 +5432,25 @@ + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then +- fptools_cv_htype_ALint=`cat conftestval` ++ fptools_cv_htype_ALCbyte=`cat conftestval` + else + echo "$as_me: program exited with status $ac_status" >&5 + echo "$as_me: failed program was:" >&5 + sed 's/^/| /' conftest.$ac_ext >&5 + + ( exit $ac_status ) +-fptools_cv_htype_ALint=NotReallyAType; fptools_cv_htype_sup_ALint=no ++fptools_cv_htype_ALCbyte=Int8 + fi + rm -f core core.* *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext + fi ++CPPFLAGS="$fp_check_htype_save_cppflags" + fi +- CPPFLAGS="$fp_check_htype_save_cppflags" +-if test "$fptools_cv_htype_sup_ALint" = yes; then +- echo "$as_me:$LINENO: result: $fptools_cv_htype_ALint" >&5 +-echo "${ECHO_T}$fptools_cv_htype_ALint" >&6 ++ if test "$fptools_cv_htype_sup_ALCbyte" = yes; then ++ echo "$as_me:$LINENO: result: $fptools_cv_htype_ALCbyte" >&5 ++echo "${ECHO_T}$fptools_cv_htype_ALCbyte" >&6 + + cat >>confdefs.h <<_ACEOF +-#define HTYPE_ALINT $fptools_cv_htype_ALint ++#define HTYPE_ALCBYTE $fptools_cv_htype_ALCbyte + _ACEOF + + else +@@ -3828,16 +5458,16 @@ + echo "${ECHO_T}not supported" >&6 + fi + +-echo "$as_me:$LINENO: checking Haskell type for ALuint" >&5 +-echo $ECHO_N "checking Haskell type for ALuint... $ECHO_C" >&6 +-if test "${fptools_cv_htype_ALuint+set}" = set; then ++echo "$as_me:$LINENO: checking Haskell type for ALCubyte" >&5 ++echo $ECHO_N "checking Haskell type for ALCubyte... $ECHO_C" >&6 ++if test "${fptools_cv_htype_ALCubyte+set}" = set; then + echo $ECHO_N "(cached) $ECHO_C" >&6 + else +- fptools_cv_htype_sup_ALuint=yes ++ fptools_cv_htype_sup_ALCubyte=yes + fp_check_htype_save_cppflags="$CPPFLAGS" + CPPFLAGS="$CPPFLAGS $X_CFLAGS" + if test "$cross_compiling" = yes; then +- fptools_cv_htype_ALuint=NotReallyATypeCross; fptools_cv_htype_sup_ALuint=no ++ fptools_cv_htype_ALCubyte=NotReallyATypeCross; fptools_cv_htype_sup_ALCubyte=no + else + cat >conftest.$ac_ext <<_ACEOF + #line $LINENO "configure" +@@ -3891,6 +5521,12 @@ + # include + #endif + ++#if defined(HAVE_AL_AL_H) ++# include ++#elif defined(HAVE_OPENAL_AL_H) ++# include ++#endif ++ + #if defined(HAVE_AL_ALC_H) + # include + #elif defined(HAVE_OPENAL_ALC_H) +@@ -3901,7 +5537,7 @@ + # include + #endif + +-typedef ALuint testing; ++typedef ALCubyte testing; + + main() { + FILE *f=fopen("conftestval", "w"); +@@ -3930,25 +5566,25 @@ + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then +- fptools_cv_htype_ALuint=`cat conftestval` ++ fptools_cv_htype_ALCubyte=`cat conftestval` + else + echo "$as_me: program exited with status $ac_status" >&5 + echo "$as_me: failed program was:" >&5 + sed 's/^/| /' conftest.$ac_ext >&5 + + ( exit $ac_status ) +-fptools_cv_htype_ALuint=NotReallyAType; fptools_cv_htype_sup_ALuint=no ++fptools_cv_htype_ALCubyte=Word8 + fi + rm -f core core.* *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext + fi ++CPPFLAGS="$fp_check_htype_save_cppflags" + fi +- CPPFLAGS="$fp_check_htype_save_cppflags" +-if test "$fptools_cv_htype_sup_ALuint" = yes; then +- echo "$as_me:$LINENO: result: $fptools_cv_htype_ALuint" >&5 +-echo "${ECHO_T}$fptools_cv_htype_ALuint" >&6 ++ if test "$fptools_cv_htype_sup_ALCubyte" = yes; then ++ echo "$as_me:$LINENO: result: $fptools_cv_htype_ALCubyte" >&5 ++echo "${ECHO_T}$fptools_cv_htype_ALCubyte" >&6 + + cat >>confdefs.h <<_ACEOF +-#define HTYPE_ALUINT $fptools_cv_htype_ALuint ++#define HTYPE_ALCUBYTE $fptools_cv_htype_ALCubyte + _ACEOF + + else +@@ -3956,16 +5592,16 @@ + echo "${ECHO_T}not supported" >&6 + fi + +-echo "$as_me:$LINENO: checking Haskell type for ALsizei" >&5 +-echo $ECHO_N "checking Haskell type for ALsizei... $ECHO_C" >&6 +-if test "${fptools_cv_htype_ALsizei+set}" = set; then ++echo "$as_me:$LINENO: checking Haskell type for ALCshort" >&5 ++echo $ECHO_N "checking Haskell type for ALCshort... $ECHO_C" >&6 ++if test "${fptools_cv_htype_ALCshort+set}" = set; then + echo $ECHO_N "(cached) $ECHO_C" >&6 + else +- fptools_cv_htype_sup_ALsizei=yes ++ fptools_cv_htype_sup_ALCshort=yes + fp_check_htype_save_cppflags="$CPPFLAGS" + CPPFLAGS="$CPPFLAGS $X_CFLAGS" + if test "$cross_compiling" = yes; then +- fptools_cv_htype_ALsizei=NotReallyATypeCross; fptools_cv_htype_sup_ALsizei=no ++ fptools_cv_htype_ALCshort=NotReallyATypeCross; fptools_cv_htype_sup_ALCshort=no + else + cat >conftest.$ac_ext <<_ACEOF + #line $LINENO "configure" +@@ -4019,6 +5655,12 @@ + # include + #endif + ++#if defined(HAVE_AL_AL_H) ++# include ++#elif defined(HAVE_OPENAL_AL_H) ++# include ++#endif ++ + #if defined(HAVE_AL_ALC_H) + # include + #elif defined(HAVE_OPENAL_ALC_H) +@@ -4029,7 +5671,7 @@ + # include + #endif + +-typedef ALsizei testing; ++typedef ALCshort testing; + + main() { + FILE *f=fopen("conftestval", "w"); +@@ -4058,25 +5700,25 @@ + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then +- fptools_cv_htype_ALsizei=`cat conftestval` ++ fptools_cv_htype_ALCshort=`cat conftestval` + else + echo "$as_me: program exited with status $ac_status" >&5 + echo "$as_me: failed program was:" >&5 + sed 's/^/| /' conftest.$ac_ext >&5 + + ( exit $ac_status ) +-fptools_cv_htype_ALsizei=NotReallyAType; fptools_cv_htype_sup_ALsizei=no ++fptools_cv_htype_ALCshort=Int16 + fi + rm -f core core.* *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext + fi ++CPPFLAGS="$fp_check_htype_save_cppflags" + fi +- CPPFLAGS="$fp_check_htype_save_cppflags" +-if test "$fptools_cv_htype_sup_ALsizei" = yes; then +- echo "$as_me:$LINENO: result: $fptools_cv_htype_ALsizei" >&5 +-echo "${ECHO_T}$fptools_cv_htype_ALsizei" >&6 ++ if test "$fptools_cv_htype_sup_ALCshort" = yes; then ++ echo "$as_me:$LINENO: result: $fptools_cv_htype_ALCshort" >&5 ++echo "${ECHO_T}$fptools_cv_htype_ALCshort" >&6 + + cat >>confdefs.h <<_ACEOF +-#define HTYPE_ALSIZEI $fptools_cv_htype_ALsizei ++#define HTYPE_ALCSHORT $fptools_cv_htype_ALCshort + _ACEOF + + else +@@ -4084,16 +5726,16 @@ + echo "${ECHO_T}not supported" >&6 + fi + +-echo "$as_me:$LINENO: checking Haskell type for ALenum" >&5 +-echo $ECHO_N "checking Haskell type for ALenum... $ECHO_C" >&6 +-if test "${fptools_cv_htype_ALenum+set}" = set; then ++echo "$as_me:$LINENO: checking Haskell type for ALCushort" >&5 ++echo $ECHO_N "checking Haskell type for ALCushort... $ECHO_C" >&6 ++if test "${fptools_cv_htype_ALCushort+set}" = set; then + echo $ECHO_N "(cached) $ECHO_C" >&6 + else +- fptools_cv_htype_sup_ALenum=yes ++ fptools_cv_htype_sup_ALCushort=yes + fp_check_htype_save_cppflags="$CPPFLAGS" + CPPFLAGS="$CPPFLAGS $X_CFLAGS" + if test "$cross_compiling" = yes; then +- fptools_cv_htype_ALenum=NotReallyATypeCross; fptools_cv_htype_sup_ALenum=no ++ fptools_cv_htype_ALCushort=NotReallyATypeCross; fptools_cv_htype_sup_ALCushort=no + else + cat >conftest.$ac_ext <<_ACEOF + #line $LINENO "configure" +@@ -4147,6 +5789,12 @@ + # include + #endif + ++#if defined(HAVE_AL_AL_H) ++# include ++#elif defined(HAVE_OPENAL_AL_H) ++# include ++#endif ++ + #if defined(HAVE_AL_ALC_H) + # include + #elif defined(HAVE_OPENAL_ALC_H) +@@ -4157,7 +5805,7 @@ + # include + #endif + +-typedef ALenum testing; ++typedef ALCushort testing; + + main() { + FILE *f=fopen("conftestval", "w"); +@@ -4186,25 +5834,25 @@ + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then +- fptools_cv_htype_ALenum=`cat conftestval` ++ fptools_cv_htype_ALCushort=`cat conftestval` + else + echo "$as_me: program exited with status $ac_status" >&5 + echo "$as_me: failed program was:" >&5 + sed 's/^/| /' conftest.$ac_ext >&5 + + ( exit $ac_status ) +-fptools_cv_htype_ALenum=NotReallyAType; fptools_cv_htype_sup_ALenum=no ++fptools_cv_htype_ALCushort=Word16 + fi + rm -f core core.* *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext + fi ++CPPFLAGS="$fp_check_htype_save_cppflags" + fi +- CPPFLAGS="$fp_check_htype_save_cppflags" +-if test "$fptools_cv_htype_sup_ALenum" = yes; then +- echo "$as_me:$LINENO: result: $fptools_cv_htype_ALenum" >&5 +-echo "${ECHO_T}$fptools_cv_htype_ALenum" >&6 ++ if test "$fptools_cv_htype_sup_ALCushort" = yes; then ++ echo "$as_me:$LINENO: result: $fptools_cv_htype_ALCushort" >&5 ++echo "${ECHO_T}$fptools_cv_htype_ALCushort" >&6 + + cat >>confdefs.h <<_ACEOF +-#define HTYPE_ALENUM $fptools_cv_htype_ALenum ++#define HTYPE_ALCUSHORT $fptools_cv_htype_ALCushort + _ACEOF + + else +@@ -4212,16 +5860,16 @@ + echo "${ECHO_T}not supported" >&6 + fi + +-echo "$as_me:$LINENO: checking Haskell type for ALbitfield" >&5 +-echo $ECHO_N "checking Haskell type for ALbitfield... $ECHO_C" >&6 +-if test "${fptools_cv_htype_ALbitfield+set}" = set; then ++echo "$as_me:$LINENO: checking Haskell type for ALCint" >&5 ++echo $ECHO_N "checking Haskell type for ALCint... $ECHO_C" >&6 ++if test "${fptools_cv_htype_ALCint+set}" = set; then + echo $ECHO_N "(cached) $ECHO_C" >&6 + else +- fptools_cv_htype_sup_ALbitfield=yes ++ fptools_cv_htype_sup_ALCint=yes + fp_check_htype_save_cppflags="$CPPFLAGS" + CPPFLAGS="$CPPFLAGS $X_CFLAGS" + if test "$cross_compiling" = yes; then +- fptools_cv_htype_ALbitfield=NotReallyATypeCross; fptools_cv_htype_sup_ALbitfield=no ++ fptools_cv_htype_ALCint=NotReallyATypeCross; fptools_cv_htype_sup_ALCint=no + else + cat >conftest.$ac_ext <<_ACEOF + #line $LINENO "configure" +@@ -4275,6 +5923,12 @@ + # include + #endif + ++#if defined(HAVE_AL_AL_H) ++# include ++#elif defined(HAVE_OPENAL_AL_H) ++# include ++#endif ++ + #if defined(HAVE_AL_ALC_H) + # include + #elif defined(HAVE_OPENAL_ALC_H) +@@ -4285,7 +5939,7 @@ + # include + #endif + +-typedef ALbitfield testing; ++typedef ALCint testing; + + main() { + FILE *f=fopen("conftestval", "w"); +@@ -4314,25 +5968,25 @@ + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then +- fptools_cv_htype_ALbitfield=`cat conftestval` ++ fptools_cv_htype_ALCint=`cat conftestval` + else + echo "$as_me: program exited with status $ac_status" >&5 + echo "$as_me: failed program was:" >&5 + sed 's/^/| /' conftest.$ac_ext >&5 + + ( exit $ac_status ) +-fptools_cv_htype_ALbitfield=NotReallyAType; fptools_cv_htype_sup_ALbitfield=no ++fptools_cv_htype_ALCint=Int32 + fi + rm -f core core.* *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext + fi ++CPPFLAGS="$fp_check_htype_save_cppflags" + fi +- CPPFLAGS="$fp_check_htype_save_cppflags" +-if test "$fptools_cv_htype_sup_ALbitfield" = yes; then +- echo "$as_me:$LINENO: result: $fptools_cv_htype_ALbitfield" >&5 +-echo "${ECHO_T}$fptools_cv_htype_ALbitfield" >&6 ++ if test "$fptools_cv_htype_sup_ALCint" = yes; then ++ echo "$as_me:$LINENO: result: $fptools_cv_htype_ALCint" >&5 ++echo "${ECHO_T}$fptools_cv_htype_ALCint" >&6 + + cat >>confdefs.h <<_ACEOF +-#define HTYPE_ALBITFIELD $fptools_cv_htype_ALbitfield ++#define HTYPE_ALCINT $fptools_cv_htype_ALCint + _ACEOF + + else +@@ -4340,16 +5994,16 @@ + echo "${ECHO_T}not supported" >&6 + fi + +-echo "$as_me:$LINENO: checking Haskell type for ALfloat" >&5 +-echo $ECHO_N "checking Haskell type for ALfloat... $ECHO_C" >&6 +-if test "${fptools_cv_htype_ALfloat+set}" = set; then ++echo "$as_me:$LINENO: checking Haskell type for ALCuint" >&5 ++echo $ECHO_N "checking Haskell type for ALCuint... $ECHO_C" >&6 ++if test "${fptools_cv_htype_ALCuint+set}" = set; then + echo $ECHO_N "(cached) $ECHO_C" >&6 + else +- fptools_cv_htype_sup_ALfloat=yes ++ fptools_cv_htype_sup_ALCuint=yes + fp_check_htype_save_cppflags="$CPPFLAGS" + CPPFLAGS="$CPPFLAGS $X_CFLAGS" + if test "$cross_compiling" = yes; then +- fptools_cv_htype_ALfloat=NotReallyATypeCross; fptools_cv_htype_sup_ALfloat=no ++ fptools_cv_htype_ALCuint=NotReallyATypeCross; fptools_cv_htype_sup_ALCuint=no + else + cat >conftest.$ac_ext <<_ACEOF + #line $LINENO "configure" +@@ -4403,6 +6057,12 @@ + # include + #endif + ++#if defined(HAVE_AL_AL_H) ++# include ++#elif defined(HAVE_OPENAL_AL_H) ++# include ++#endif ++ + #if defined(HAVE_AL_ALC_H) + # include + #elif defined(HAVE_OPENAL_ALC_H) +@@ -4413,7 +6073,7 @@ + # include + #endif + +-typedef ALfloat testing; ++typedef ALCuint testing; + + main() { + FILE *f=fopen("conftestval", "w"); +@@ -4442,25 +6102,25 @@ + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then +- fptools_cv_htype_ALfloat=`cat conftestval` ++ fptools_cv_htype_ALCuint=`cat conftestval` + else + echo "$as_me: program exited with status $ac_status" >&5 + echo "$as_me: failed program was:" >&5 + sed 's/^/| /' conftest.$ac_ext >&5 + + ( exit $ac_status ) +-fptools_cv_htype_ALfloat=NotReallyAType; fptools_cv_htype_sup_ALfloat=no ++fptools_cv_htype_ALCuint=Word32 + fi + rm -f core core.* *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext + fi ++CPPFLAGS="$fp_check_htype_save_cppflags" + fi +- CPPFLAGS="$fp_check_htype_save_cppflags" +-if test "$fptools_cv_htype_sup_ALfloat" = yes; then +- echo "$as_me:$LINENO: result: $fptools_cv_htype_ALfloat" >&5 +-echo "${ECHO_T}$fptools_cv_htype_ALfloat" >&6 ++ if test "$fptools_cv_htype_sup_ALCuint" = yes; then ++ echo "$as_me:$LINENO: result: $fptools_cv_htype_ALCuint" >&5 ++echo "${ECHO_T}$fptools_cv_htype_ALCuint" >&6 + + cat >>confdefs.h <<_ACEOF +-#define HTYPE_ALFLOAT $fptools_cv_htype_ALfloat ++#define HTYPE_ALCUINT $fptools_cv_htype_ALCuint + _ACEOF + + else +@@ -4468,16 +6128,16 @@ + echo "${ECHO_T}not supported" >&6 + fi + +-echo "$as_me:$LINENO: checking Haskell type for ALclampf" >&5 +-echo $ECHO_N "checking Haskell type for ALclampf... $ECHO_C" >&6 +-if test "${fptools_cv_htype_ALclampf+set}" = set; then ++echo "$as_me:$LINENO: checking Haskell type for ALCsizei" >&5 ++echo $ECHO_N "checking Haskell type for ALCsizei... $ECHO_C" >&6 ++if test "${fptools_cv_htype_ALCsizei+set}" = set; then + echo $ECHO_N "(cached) $ECHO_C" >&6 + else +- fptools_cv_htype_sup_ALclampf=yes ++ fptools_cv_htype_sup_ALCsizei=yes + fp_check_htype_save_cppflags="$CPPFLAGS" + CPPFLAGS="$CPPFLAGS $X_CFLAGS" + if test "$cross_compiling" = yes; then +- fptools_cv_htype_ALclampf=NotReallyATypeCross; fptools_cv_htype_sup_ALclampf=no ++ fptools_cv_htype_ALCsizei=NotReallyATypeCross; fptools_cv_htype_sup_ALCsizei=no + else + cat >conftest.$ac_ext <<_ACEOF + #line $LINENO "configure" +@@ -4531,6 +6191,12 @@ + # include + #endif + ++#if defined(HAVE_AL_AL_H) ++# include ++#elif defined(HAVE_OPENAL_AL_H) ++# include ++#endif ++ + #if defined(HAVE_AL_ALC_H) + # include + #elif defined(HAVE_OPENAL_ALC_H) +@@ -4541,7 +6207,7 @@ + # include + #endif + +-typedef ALclampf testing; ++typedef ALCsizei testing; + + main() { + FILE *f=fopen("conftestval", "w"); +@@ -4570,25 +6236,25 @@ + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then +- fptools_cv_htype_ALclampf=`cat conftestval` ++ fptools_cv_htype_ALCsizei=`cat conftestval` + else + echo "$as_me: program exited with status $ac_status" >&5 + echo "$as_me: failed program was:" >&5 + sed 's/^/| /' conftest.$ac_ext >&5 + + ( exit $ac_status ) +-fptools_cv_htype_ALclampf=NotReallyAType; fptools_cv_htype_sup_ALclampf=no ++fptools_cv_htype_ALCsizei=Int32 + fi + rm -f core core.* *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext + fi ++CPPFLAGS="$fp_check_htype_save_cppflags" + fi +- CPPFLAGS="$fp_check_htype_save_cppflags" +-if test "$fptools_cv_htype_sup_ALclampf" = yes; then +- echo "$as_me:$LINENO: result: $fptools_cv_htype_ALclampf" >&5 +-echo "${ECHO_T}$fptools_cv_htype_ALclampf" >&6 ++ if test "$fptools_cv_htype_sup_ALCsizei" = yes; then ++ echo "$as_me:$LINENO: result: $fptools_cv_htype_ALCsizei" >&5 ++echo "${ECHO_T}$fptools_cv_htype_ALCsizei" >&6 + + cat >>confdefs.h <<_ACEOF +-#define HTYPE_ALCLAMPF $fptools_cv_htype_ALclampf ++#define HTYPE_ALCSIZEI $fptools_cv_htype_ALCsizei + _ACEOF + + else +@@ -4596,16 +6262,16 @@ + echo "${ECHO_T}not supported" >&6 + fi + +-echo "$as_me:$LINENO: checking Haskell type for ALdouble" >&5 +-echo $ECHO_N "checking Haskell type for ALdouble... $ECHO_C" >&6 +-if test "${fptools_cv_htype_ALdouble+set}" = set; then ++echo "$as_me:$LINENO: checking Haskell type for ALCenum" >&5 ++echo $ECHO_N "checking Haskell type for ALCenum... $ECHO_C" >&6 ++if test "${fptools_cv_htype_ALCenum+set}" = set; then + echo $ECHO_N "(cached) $ECHO_C" >&6 + else +- fptools_cv_htype_sup_ALdouble=yes ++ fptools_cv_htype_sup_ALCenum=yes + fp_check_htype_save_cppflags="$CPPFLAGS" + CPPFLAGS="$CPPFLAGS $X_CFLAGS" + if test "$cross_compiling" = yes; then +- fptools_cv_htype_ALdouble=NotReallyATypeCross; fptools_cv_htype_sup_ALdouble=no ++ fptools_cv_htype_ALCenum=NotReallyATypeCross; fptools_cv_htype_sup_ALCenum=no + else + cat >conftest.$ac_ext <<_ACEOF + #line $LINENO "configure" +@@ -4659,6 +6325,12 @@ + # include + #endif + ++#if defined(HAVE_AL_AL_H) ++# include ++#elif defined(HAVE_OPENAL_AL_H) ++# include ++#endif ++ + #if defined(HAVE_AL_ALC_H) + # include + #elif defined(HAVE_OPENAL_ALC_H) +@@ -4669,7 +6341,7 @@ + # include + #endif + +-typedef ALdouble testing; ++typedef ALCenum testing; + + main() { + FILE *f=fopen("conftestval", "w"); +@@ -4698,25 +6370,25 @@ + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then +- fptools_cv_htype_ALdouble=`cat conftestval` ++ fptools_cv_htype_ALCenum=`cat conftestval` + else + echo "$as_me: program exited with status $ac_status" >&5 + echo "$as_me: failed program was:" >&5 + sed 's/^/| /' conftest.$ac_ext >&5 + + ( exit $ac_status ) +-fptools_cv_htype_ALdouble=NotReallyAType; fptools_cv_htype_sup_ALdouble=no ++fptools_cv_htype_ALCenum=Int32 + fi + rm -f core core.* *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext + fi ++CPPFLAGS="$fp_check_htype_save_cppflags" + fi +- CPPFLAGS="$fp_check_htype_save_cppflags" +-if test "$fptools_cv_htype_sup_ALdouble" = yes; then +- echo "$as_me:$LINENO: result: $fptools_cv_htype_ALdouble" >&5 +-echo "${ECHO_T}$fptools_cv_htype_ALdouble" >&6 ++ if test "$fptools_cv_htype_sup_ALCenum" = yes; then ++ echo "$as_me:$LINENO: result: $fptools_cv_htype_ALCenum" >&5 ++echo "${ECHO_T}$fptools_cv_htype_ALCenum" >&6 + + cat >>confdefs.h <<_ACEOF +-#define HTYPE_ALDOUBLE $fptools_cv_htype_ALdouble ++#define HTYPE_ALCENUM $fptools_cv_htype_ALCenum + _ACEOF + + else +@@ -4724,16 +6396,16 @@ + echo "${ECHO_T}not supported" >&6 + fi + +-echo "$as_me:$LINENO: checking Haskell type for ALclampd" >&5 +-echo $ECHO_N "checking Haskell type for ALclampd... $ECHO_C" >&6 +-if test "${fptools_cv_htype_ALclampd+set}" = set; then ++echo "$as_me:$LINENO: checking Haskell type for ALCfloat" >&5 ++echo $ECHO_N "checking Haskell type for ALCfloat... $ECHO_C" >&6 ++if test "${fptools_cv_htype_ALCfloat+set}" = set; then + echo $ECHO_N "(cached) $ECHO_C" >&6 + else +- fptools_cv_htype_sup_ALclampd=yes ++ fptools_cv_htype_sup_ALCfloat=yes + fp_check_htype_save_cppflags="$CPPFLAGS" + CPPFLAGS="$CPPFLAGS $X_CFLAGS" + if test "$cross_compiling" = yes; then +- fptools_cv_htype_ALclampd=NotReallyATypeCross; fptools_cv_htype_sup_ALclampd=no ++ fptools_cv_htype_ALCfloat=NotReallyATypeCross; fptools_cv_htype_sup_ALCfloat=no + else + cat >conftest.$ac_ext <<_ACEOF + #line $LINENO "configure" +@@ -4787,6 +6459,12 @@ + # include + #endif + ++#if defined(HAVE_AL_AL_H) ++# include ++#elif defined(HAVE_OPENAL_AL_H) ++# include ++#endif ++ + #if defined(HAVE_AL_ALC_H) + # include + #elif defined(HAVE_OPENAL_ALC_H) +@@ -4797,7 +6475,7 @@ + # include + #endif + +-typedef ALclampd testing; ++typedef ALCfloat testing; + + main() { + FILE *f=fopen("conftestval", "w"); +@@ -4826,25 +6504,25 @@ + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then +- fptools_cv_htype_ALclampd=`cat conftestval` ++ fptools_cv_htype_ALCfloat=`cat conftestval` + else + echo "$as_me: program exited with status $ac_status" >&5 + echo "$as_me: failed program was:" >&5 + sed 's/^/| /' conftest.$ac_ext >&5 + + ( exit $ac_status ) +-fptools_cv_htype_ALclampd=NotReallyAType; fptools_cv_htype_sup_ALclampd=no ++fptools_cv_htype_ALCfloat=Float + fi + rm -f core core.* *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext + fi ++CPPFLAGS="$fp_check_htype_save_cppflags" + fi +- CPPFLAGS="$fp_check_htype_save_cppflags" +-if test "$fptools_cv_htype_sup_ALclampd" = yes; then +- echo "$as_me:$LINENO: result: $fptools_cv_htype_ALclampd" >&5 +-echo "${ECHO_T}$fptools_cv_htype_ALclampd" >&6 ++ if test "$fptools_cv_htype_sup_ALCfloat" = yes; then ++ echo "$as_me:$LINENO: result: $fptools_cv_htype_ALCfloat" >&5 ++echo "${ECHO_T}$fptools_cv_htype_ALCfloat" >&6 + + cat >>confdefs.h <<_ACEOF +-#define HTYPE_ALCLAMPD $fptools_cv_htype_ALclampd ++#define HTYPE_ALCFLOAT $fptools_cv_htype_ALCfloat + _ACEOF + + else +@@ -4852,16 +6530,16 @@ + echo "${ECHO_T}not supported" >&6 + fi + +-echo "$as_me:$LINENO: checking Haskell type for ALCenum" >&5 +-echo $ECHO_N "checking Haskell type for ALCenum... $ECHO_C" >&6 +-if test "${fptools_cv_htype_ALCenum+set}" = set; then ++echo "$as_me:$LINENO: checking Haskell type for ALCdouble" >&5 ++echo $ECHO_N "checking Haskell type for ALCdouble... $ECHO_C" >&6 ++if test "${fptools_cv_htype_ALCdouble+set}" = set; then + echo $ECHO_N "(cached) $ECHO_C" >&6 + else +- fptools_cv_htype_sup_ALCenum=yes ++ fptools_cv_htype_sup_ALCdouble=yes + fp_check_htype_save_cppflags="$CPPFLAGS" + CPPFLAGS="$CPPFLAGS $X_CFLAGS" + if test "$cross_compiling" = yes; then +- fptools_cv_htype_ALCenum=NotReallyATypeCross; fptools_cv_htype_sup_ALCenum=no ++ fptools_cv_htype_ALCdouble=NotReallyATypeCross; fptools_cv_htype_sup_ALCdouble=no + else + cat >conftest.$ac_ext <<_ACEOF + #line $LINENO "configure" +@@ -4915,6 +6593,12 @@ + # include + #endif + ++#if defined(HAVE_AL_AL_H) ++# include ++#elif defined(HAVE_OPENAL_AL_H) ++# include ++#endif ++ + #if defined(HAVE_AL_ALC_H) + # include + #elif defined(HAVE_OPENAL_ALC_H) +@@ -4925,7 +6609,7 @@ + # include + #endif + +-typedef ALCenum testing; ++typedef ALCdouble testing; + + main() { + FILE *f=fopen("conftestval", "w"); +@@ -4954,31 +6638,99 @@ + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then +- fptools_cv_htype_ALCenum=`cat conftestval` ++ fptools_cv_htype_ALCdouble=`cat conftestval` + else + echo "$as_me: program exited with status $ac_status" >&5 + echo "$as_me: failed program was:" >&5 + sed 's/^/| /' conftest.$ac_ext >&5 + +-( exit $ac_status ) +-fptools_cv_htype_ALCenum=NotReallyAType; fptools_cv_htype_sup_ALCenum=no +-fi +-rm -f core core.* *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext +-fi +-fi +- CPPFLAGS="$fp_check_htype_save_cppflags" +-if test "$fptools_cv_htype_sup_ALCenum" = yes; then +- echo "$as_me:$LINENO: result: $fptools_cv_htype_ALCenum" >&5 +-echo "${ECHO_T}$fptools_cv_htype_ALCenum" >&6 ++( exit $ac_status ) ++fptools_cv_htype_ALCdouble=Double ++fi ++rm -f core core.* *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext ++fi ++CPPFLAGS="$fp_check_htype_save_cppflags" ++fi ++ if test "$fptools_cv_htype_sup_ALCdouble" = yes; then ++ echo "$as_me:$LINENO: result: $fptools_cv_htype_ALCdouble" >&5 ++echo "${ECHO_T}$fptools_cv_htype_ALCdouble" >&6 ++ ++cat >>confdefs.h <<_ACEOF ++#define HTYPE_ALCDOUBLE $fptools_cv_htype_ALCdouble ++_ACEOF ++ ++else ++ echo "$as_me:$LINENO: result: not supported" >&5 ++echo "${ECHO_T}not supported" >&6 ++fi ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ + +-cat >>confdefs.h <<_ACEOF +-#define HTYPE_ALCENUM $fptools_cv_htype_ALCenum +-_ACEOF + +-else +- echo "$as_me:$LINENO: result: not supported" >&5 +-echo "${ECHO_T}not supported" >&6 +-fi + + + +@@ -4998,7 +6750,7 @@ + + + +-for fp_const_name in AL_FORMAT_VORBIS_EXT ALC_FREQUENCY ALC_REFRESH ALC_SYNC ALC_NO_ERROR ALC_INVALID_DEVICE ALC_INVALID_CONTEXT ALC_INVALID_ENUM ALC_INVALID_VALUE ALC_OUT_OF_MEMORY ALC_DEFAULT_DEVICE_SPECIFIER ALC_DEVICE_SPECIFIER ALC_EXTENSIONS ALC_MAJOR_VERSION ALC_MINOR_VERSION ALC_ATTRIBUTES_SIZE ALC_ALL_ATTRIBUTES ++for fp_const_name in AL_FALSE AL_TRUE AL_NO_ERROR AL_INVALID_NAME AL_INVALID_ENUM AL_INVALID_VALUE AL_INVALID_OPERATION AL_OUT_OF_MEMORY AL_DOPPLER_FACTOR AL_SPEED_OF_SOUND AL_DISTANCE_MODEL AL_VERSION AL_RENDERER AL_VENDOR AL_EXTENSIONS AL_NONE AL_INVERSE_DISTANCE AL_INVERSE_DISTANCE_CLAMPED AL_LINEAR_DISTANCE AL_LINEAR_DISTANCE_CLAMPED AL_EXPONENT_DISTANCE AL_EXPONENT_DISTANCE_CLAMPED AL_POSITION AL_VELOCITY AL_GAIN AL_ORIENTATION AL_SOURCE_RELATIVE AL_SOURCE_TYPE AL_LOOPING AL_BUFFER AL_BUFFERS_QUEUED AL_BUFFERS_PROCESSED AL_MIN_GAIN AL_MAX_GAIN AL_REFERENCE_DISTANCE AL_ROLLOFF_FACTOR AL_MAX_DISTANCE AL_PITCH AL_DIRECTION AL_CONE_INNER_ANGLE AL_CONE_OUTER_ANGLE AL_CONE_OUTER_GAIN AL_SEC_OFFSET AL_SAMPLE_OFFSET AL_BYTE_OFFSET AL_SOURCE_STATE AL_UNDETERMINED AL_STATIC AL_STREAMING AL_INITIAL AL_PLAYING AL_PAUSED AL_STOPPED AL_FREQUENCY AL_SIZE AL_BITS AL_CHANNELS AL_FORMAT_MONO8 AL_FORMAT_MONO16 AL_FORMAT_STEREO8 AL_FORMAT_STEREO16 ALC_FALSE ALC_TRUE ALC_FREQUENCY ALC_REFRESH ALC_SYNC ALC_MONO_SOURCES ALC_STEREO_SOURCES ALC_NO_ERROR ALC_INVALID_DEVICE ALC_INVALID_CONTEXT ALC_INVALID_ENUM ALC_INVALID_VALUE ALC_INVALID_OPERATION ALC_OUT_OF_MEMORY ALC_DEFAULT_DEVICE_SPECIFIER ALC_DEVICE_SPECIFIER ALC_EXTENSIONS ALC_CAPTURE_DEFAULT_DEVICE_SPECIFIER ALC_CAPTURE_DEVICE_SPECIFIER ALC_ATTRIBUTES_SIZE ALC_ALL_ATTRIBUTES ALC_MAJOR_VERSION ALC_MINOR_VERSION ALC_CAPTURE_SAMPLES + do + as_fp_Cache=`echo "fp_cv_const_$fp_const_name" | $as_tr_sh` + echo "$as_me:$LINENO: checking value of $fp_const_name" >&5 +@@ -5028,6 +6780,87 @@ + #include + #endif + ++#ifndef AL_SPEED_OF_SOUND ++#define AL_SPEED_OF_SOUND 0xC003 ++#endif ++ ++#ifndef AL_LINEAR_DISTANCE ++#define AL_LINEAR_DISTANCE 0xD003 ++#endif ++ ++#ifndef AL_LINEAR_DISTANCE_CLAMPED ++#define AL_LINEAR_DISTANCE_CLAMPED 0xD004 ++#endif ++ ++#ifndef AL_EXPONENT_DISTANCE ++#define AL_EXPONENT_DISTANCE 0xD005 ++#endif ++ ++#ifndef AL_EXPONENT_DISTANCE_CLAMPED ++#define AL_EXPONENT_DISTANCE_CLAMPED 0xD006 ++#endif ++ ++#ifndef AL_SEC_OFFSET ++#define AL_SEC_OFFSET 0x1024 ++#endif ++ ++#ifndef AL_SAMPLE_OFFSET ++#define AL_SAMPLE_OFFSET 0x1025 ++#endif ++ ++#ifndef AL_BYTE_OFFSET ++#define AL_BYTE_OFFSET 0x1026 ++#endif ++ ++#ifndef AL_UNDETERMINED ++#define AL_UNDETERMINED 0x1030 ++#endif ++ ++#ifndef AL_STATIC ++#define AL_STATIC 0x1028 ++#endif ++ ++#ifndef ALC_MONO_SOURCES ++#define ALC_MONO_SOURCES 0x1010 ++#endif ++ ++#ifndef ALC_STEREO_SOURCES ++#define ALC_STEREO_SOURCES 0x1011 ++#endif ++ ++#ifndef AL_INVALID_ENUM ++#ifdef AL_ILLEGAL_ENUM ++#define AL_INVALID_ENUM AL_ILLEGAL_ENUM ++#else ++#define AL_INVALID_ENUM 0xA002 ++#endif ++#endif ++ ++#ifndef AL_INVALID_OPERATION ++#ifdef AL_ILLEGAL_COMMAND ++#define AL_INVALID_OPERATION AL_ILLEGAL_COMMAND ++#else ++#define AL_INVALID_OPERATION 0xA004 ++#endif ++#endif ++ ++/* NOTE: THIS IS NOT IN ANY HEADER */ ++#ifndef ALC_INVALID_OPERATION ++#define ALC_INVALID_OPERATION 0xA006 ++#endif ++ ++#ifndef ALC_CAPTURE_DEFAULT_DEVICE_SPECIFIER ++#define ALC_CAPTURE_DEFAULT_DEVICE_SPECIFIER 0x311 ++#endif ++ ++#ifndef ALC_CAPTURE_DEVICE_SPECIFIER ++#define ALC_CAPTURE_DEVICE_SPECIFIER 0x310 ++#endif ++ ++#ifndef ALC_CAPTURE_SAMPLES ++#define ALC_CAPTURE_SAMPLES 0x312 ++#endif ++ + + int + main () +@@ -5073,6 +6906,87 @@ + #include + #endif + ++#ifndef AL_SPEED_OF_SOUND ++#define AL_SPEED_OF_SOUND 0xC003 ++#endif ++ ++#ifndef AL_LINEAR_DISTANCE ++#define AL_LINEAR_DISTANCE 0xD003 ++#endif ++ ++#ifndef AL_LINEAR_DISTANCE_CLAMPED ++#define AL_LINEAR_DISTANCE_CLAMPED 0xD004 ++#endif ++ ++#ifndef AL_EXPONENT_DISTANCE ++#define AL_EXPONENT_DISTANCE 0xD005 ++#endif ++ ++#ifndef AL_EXPONENT_DISTANCE_CLAMPED ++#define AL_EXPONENT_DISTANCE_CLAMPED 0xD006 ++#endif ++ ++#ifndef AL_SEC_OFFSET ++#define AL_SEC_OFFSET 0x1024 ++#endif ++ ++#ifndef AL_SAMPLE_OFFSET ++#define AL_SAMPLE_OFFSET 0x1025 ++#endif ++ ++#ifndef AL_BYTE_OFFSET ++#define AL_BYTE_OFFSET 0x1026 ++#endif ++ ++#ifndef AL_UNDETERMINED ++#define AL_UNDETERMINED 0x1030 ++#endif ++ ++#ifndef AL_STATIC ++#define AL_STATIC 0x1028 ++#endif ++ ++#ifndef ALC_MONO_SOURCES ++#define ALC_MONO_SOURCES 0x1010 ++#endif ++ ++#ifndef ALC_STEREO_SOURCES ++#define ALC_STEREO_SOURCES 0x1011 ++#endif ++ ++#ifndef AL_INVALID_ENUM ++#ifdef AL_ILLEGAL_ENUM ++#define AL_INVALID_ENUM AL_ILLEGAL_ENUM ++#else ++#define AL_INVALID_ENUM 0xA002 ++#endif ++#endif ++ ++#ifndef AL_INVALID_OPERATION ++#ifdef AL_ILLEGAL_COMMAND ++#define AL_INVALID_OPERATION AL_ILLEGAL_COMMAND ++#else ++#define AL_INVALID_OPERATION 0xA004 ++#endif ++#endif ++ ++/* NOTE: THIS IS NOT IN ANY HEADER */ ++#ifndef ALC_INVALID_OPERATION ++#define ALC_INVALID_OPERATION 0xA006 ++#endif ++ ++#ifndef ALC_CAPTURE_DEFAULT_DEVICE_SPECIFIER ++#define ALC_CAPTURE_DEFAULT_DEVICE_SPECIFIER 0x311 ++#endif ++ ++#ifndef ALC_CAPTURE_DEVICE_SPECIFIER ++#define ALC_CAPTURE_DEVICE_SPECIFIER 0x310 ++#endif ++ ++#ifndef ALC_CAPTURE_SAMPLES ++#define ALC_CAPTURE_SAMPLES 0x312 ++#endif ++ + + int + main () +@@ -5134,6 +7048,87 @@ + #include + #endif + ++#ifndef AL_SPEED_OF_SOUND ++#define AL_SPEED_OF_SOUND 0xC003 ++#endif ++ ++#ifndef AL_LINEAR_DISTANCE ++#define AL_LINEAR_DISTANCE 0xD003 ++#endif ++ ++#ifndef AL_LINEAR_DISTANCE_CLAMPED ++#define AL_LINEAR_DISTANCE_CLAMPED 0xD004 ++#endif ++ ++#ifndef AL_EXPONENT_DISTANCE ++#define AL_EXPONENT_DISTANCE 0xD005 ++#endif ++ ++#ifndef AL_EXPONENT_DISTANCE_CLAMPED ++#define AL_EXPONENT_DISTANCE_CLAMPED 0xD006 ++#endif ++ ++#ifndef AL_SEC_OFFSET ++#define AL_SEC_OFFSET 0x1024 ++#endif ++ ++#ifndef AL_SAMPLE_OFFSET ++#define AL_SAMPLE_OFFSET 0x1025 ++#endif ++ ++#ifndef AL_BYTE_OFFSET ++#define AL_BYTE_OFFSET 0x1026 ++#endif ++ ++#ifndef AL_UNDETERMINED ++#define AL_UNDETERMINED 0x1030 ++#endif ++ ++#ifndef AL_STATIC ++#define AL_STATIC 0x1028 ++#endif ++ ++#ifndef ALC_MONO_SOURCES ++#define ALC_MONO_SOURCES 0x1010 ++#endif ++ ++#ifndef ALC_STEREO_SOURCES ++#define ALC_STEREO_SOURCES 0x1011 ++#endif ++ ++#ifndef AL_INVALID_ENUM ++#ifdef AL_ILLEGAL_ENUM ++#define AL_INVALID_ENUM AL_ILLEGAL_ENUM ++#else ++#define AL_INVALID_ENUM 0xA002 ++#endif ++#endif ++ ++#ifndef AL_INVALID_OPERATION ++#ifdef AL_ILLEGAL_COMMAND ++#define AL_INVALID_OPERATION AL_ILLEGAL_COMMAND ++#else ++#define AL_INVALID_OPERATION 0xA004 ++#endif ++#endif ++ ++/* NOTE: THIS IS NOT IN ANY HEADER */ ++#ifndef ALC_INVALID_OPERATION ++#define ALC_INVALID_OPERATION 0xA006 ++#endif ++ ++#ifndef ALC_CAPTURE_DEFAULT_DEVICE_SPECIFIER ++#define ALC_CAPTURE_DEFAULT_DEVICE_SPECIFIER 0x311 ++#endif ++ ++#ifndef ALC_CAPTURE_DEVICE_SPECIFIER ++#define ALC_CAPTURE_DEVICE_SPECIFIER 0x310 ++#endif ++ ++#ifndef ALC_CAPTURE_SAMPLES ++#define ALC_CAPTURE_SAMPLES 0x312 ++#endif ++ + + int + main () +@@ -5179,6 +7174,87 @@ + #include + #endif + ++#ifndef AL_SPEED_OF_SOUND ++#define AL_SPEED_OF_SOUND 0xC003 ++#endif ++ ++#ifndef AL_LINEAR_DISTANCE ++#define AL_LINEAR_DISTANCE 0xD003 ++#endif ++ ++#ifndef AL_LINEAR_DISTANCE_CLAMPED ++#define AL_LINEAR_DISTANCE_CLAMPED 0xD004 ++#endif ++ ++#ifndef AL_EXPONENT_DISTANCE ++#define AL_EXPONENT_DISTANCE 0xD005 ++#endif ++ ++#ifndef AL_EXPONENT_DISTANCE_CLAMPED ++#define AL_EXPONENT_DISTANCE_CLAMPED 0xD006 ++#endif ++ ++#ifndef AL_SEC_OFFSET ++#define AL_SEC_OFFSET 0x1024 ++#endif ++ ++#ifndef AL_SAMPLE_OFFSET ++#define AL_SAMPLE_OFFSET 0x1025 ++#endif ++ ++#ifndef AL_BYTE_OFFSET ++#define AL_BYTE_OFFSET 0x1026 ++#endif ++ ++#ifndef AL_UNDETERMINED ++#define AL_UNDETERMINED 0x1030 ++#endif ++ ++#ifndef AL_STATIC ++#define AL_STATIC 0x1028 ++#endif ++ ++#ifndef ALC_MONO_SOURCES ++#define ALC_MONO_SOURCES 0x1010 ++#endif ++ ++#ifndef ALC_STEREO_SOURCES ++#define ALC_STEREO_SOURCES 0x1011 ++#endif ++ ++#ifndef AL_INVALID_ENUM ++#ifdef AL_ILLEGAL_ENUM ++#define AL_INVALID_ENUM AL_ILLEGAL_ENUM ++#else ++#define AL_INVALID_ENUM 0xA002 ++#endif ++#endif ++ ++#ifndef AL_INVALID_OPERATION ++#ifdef AL_ILLEGAL_COMMAND ++#define AL_INVALID_OPERATION AL_ILLEGAL_COMMAND ++#else ++#define AL_INVALID_OPERATION 0xA004 ++#endif ++#endif ++ ++/* NOTE: THIS IS NOT IN ANY HEADER */ ++#ifndef ALC_INVALID_OPERATION ++#define ALC_INVALID_OPERATION 0xA006 ++#endif ++ ++#ifndef ALC_CAPTURE_DEFAULT_DEVICE_SPECIFIER ++#define ALC_CAPTURE_DEFAULT_DEVICE_SPECIFIER 0x311 ++#endif ++ ++#ifndef ALC_CAPTURE_DEVICE_SPECIFIER ++#define ALC_CAPTURE_DEVICE_SPECIFIER 0x310 ++#endif ++ ++#ifndef ALC_CAPTURE_SAMPLES ++#define ALC_CAPTURE_SAMPLES 0x312 ++#endif ++ + + int + main () +@@ -5248,6 +7324,87 @@ + #include + #endif + ++#ifndef AL_SPEED_OF_SOUND ++#define AL_SPEED_OF_SOUND 0xC003 ++#endif ++ ++#ifndef AL_LINEAR_DISTANCE ++#define AL_LINEAR_DISTANCE 0xD003 ++#endif ++ ++#ifndef AL_LINEAR_DISTANCE_CLAMPED ++#define AL_LINEAR_DISTANCE_CLAMPED 0xD004 ++#endif ++ ++#ifndef AL_EXPONENT_DISTANCE ++#define AL_EXPONENT_DISTANCE 0xD005 ++#endif ++ ++#ifndef AL_EXPONENT_DISTANCE_CLAMPED ++#define AL_EXPONENT_DISTANCE_CLAMPED 0xD006 ++#endif ++ ++#ifndef AL_SEC_OFFSET ++#define AL_SEC_OFFSET 0x1024 ++#endif ++ ++#ifndef AL_SAMPLE_OFFSET ++#define AL_SAMPLE_OFFSET 0x1025 ++#endif ++ ++#ifndef AL_BYTE_OFFSET ++#define AL_BYTE_OFFSET 0x1026 ++#endif ++ ++#ifndef AL_UNDETERMINED ++#define AL_UNDETERMINED 0x1030 ++#endif ++ ++#ifndef AL_STATIC ++#define AL_STATIC 0x1028 ++#endif ++ ++#ifndef ALC_MONO_SOURCES ++#define ALC_MONO_SOURCES 0x1010 ++#endif ++ ++#ifndef ALC_STEREO_SOURCES ++#define ALC_STEREO_SOURCES 0x1011 ++#endif ++ ++#ifndef AL_INVALID_ENUM ++#ifdef AL_ILLEGAL_ENUM ++#define AL_INVALID_ENUM AL_ILLEGAL_ENUM ++#else ++#define AL_INVALID_ENUM 0xA002 ++#endif ++#endif ++ ++#ifndef AL_INVALID_OPERATION ++#ifdef AL_ILLEGAL_COMMAND ++#define AL_INVALID_OPERATION AL_ILLEGAL_COMMAND ++#else ++#define AL_INVALID_OPERATION 0xA004 ++#endif ++#endif ++ ++/* NOTE: THIS IS NOT IN ANY HEADER */ ++#ifndef ALC_INVALID_OPERATION ++#define ALC_INVALID_OPERATION 0xA006 ++#endif ++ ++#ifndef ALC_CAPTURE_DEFAULT_DEVICE_SPECIFIER ++#define ALC_CAPTURE_DEFAULT_DEVICE_SPECIFIER 0x311 ++#endif ++ ++#ifndef ALC_CAPTURE_DEVICE_SPECIFIER ++#define ALC_CAPTURE_DEVICE_SPECIFIER 0x310 ++#endif ++ ++#ifndef ALC_CAPTURE_SAMPLES ++#define ALC_CAPTURE_SAMPLES 0x312 ++#endif ++ + + int + main () +@@ -5312,6 +7469,87 @@ + #include + #endif + ++#ifndef AL_SPEED_OF_SOUND ++#define AL_SPEED_OF_SOUND 0xC003 ++#endif ++ ++#ifndef AL_LINEAR_DISTANCE ++#define AL_LINEAR_DISTANCE 0xD003 ++#endif ++ ++#ifndef AL_LINEAR_DISTANCE_CLAMPED ++#define AL_LINEAR_DISTANCE_CLAMPED 0xD004 ++#endif ++ ++#ifndef AL_EXPONENT_DISTANCE ++#define AL_EXPONENT_DISTANCE 0xD005 ++#endif ++ ++#ifndef AL_EXPONENT_DISTANCE_CLAMPED ++#define AL_EXPONENT_DISTANCE_CLAMPED 0xD006 ++#endif ++ ++#ifndef AL_SEC_OFFSET ++#define AL_SEC_OFFSET 0x1024 ++#endif ++ ++#ifndef AL_SAMPLE_OFFSET ++#define AL_SAMPLE_OFFSET 0x1025 ++#endif ++ ++#ifndef AL_BYTE_OFFSET ++#define AL_BYTE_OFFSET 0x1026 ++#endif ++ ++#ifndef AL_UNDETERMINED ++#define AL_UNDETERMINED 0x1030 ++#endif ++ ++#ifndef AL_STATIC ++#define AL_STATIC 0x1028 ++#endif ++ ++#ifndef ALC_MONO_SOURCES ++#define ALC_MONO_SOURCES 0x1010 ++#endif ++ ++#ifndef ALC_STEREO_SOURCES ++#define ALC_STEREO_SOURCES 0x1011 ++#endif ++ ++#ifndef AL_INVALID_ENUM ++#ifdef AL_ILLEGAL_ENUM ++#define AL_INVALID_ENUM AL_ILLEGAL_ENUM ++#else ++#define AL_INVALID_ENUM 0xA002 ++#endif ++#endif ++ ++#ifndef AL_INVALID_OPERATION ++#ifdef AL_ILLEGAL_COMMAND ++#define AL_INVALID_OPERATION AL_ILLEGAL_COMMAND ++#else ++#define AL_INVALID_OPERATION 0xA004 ++#endif ++#endif ++ ++/* NOTE: THIS IS NOT IN ANY HEADER */ ++#ifndef ALC_INVALID_OPERATION ++#define ALC_INVALID_OPERATION 0xA006 ++#endif ++ ++#ifndef ALC_CAPTURE_DEFAULT_DEVICE_SPECIFIER ++#define ALC_CAPTURE_DEFAULT_DEVICE_SPECIFIER 0x311 ++#endif ++ ++#ifndef ALC_CAPTURE_DEVICE_SPECIFIER ++#define ALC_CAPTURE_DEVICE_SPECIFIER 0x310 ++#endif ++ ++#ifndef ALC_CAPTURE_SAMPLES ++#define ALC_CAPTURE_SAMPLES 0x312 ++#endif ++ + + long longval () { return $fp_const_name; } + unsigned long ulongval () { return $fp_const_name; } +@@ -5402,7 +7640,7 @@ + fi + + +-case "$target" in ++case "$host" in + *-mingw32) CALLCONV=stdcall ;; + *) CALLCONV=ccall ;; + esac +@@ -5770,7 +8008,7 @@ + } >&5 + cat >&5 <<_CSEOF + +-This file was extended by Haskell HOpenAL package $as_me 1.0, which was ++This file was extended by Haskell HOpenAL package $as_me 1.2, which was + generated by GNU Autoconf 2.57. Invocation command line was + + CONFIG_FILES = $CONFIG_FILES +@@ -5830,7 +8068,7 @@ + + cat >>$CONFIG_STATUS <<_ACEOF + ac_cs_version="\\ +-Haskell HOpenAL package config.status 1.0 ++Haskell HOpenAL package config.status 1.2 + configured by $0, generated by GNU Autoconf 2.57, + with options \\"`echo "$ac_configure_args" | sed 's/[\\""\`\$]/\\\\&/g'`\\" + +@@ -6030,9 +8268,9 @@ + s,@EXEEXT@,$EXEEXT,;t t + s,@OBJEXT@,$OBJEXT,;t t + s,@AL_LIBS@,$AL_LIBS,;t t ++s,@AL_FRAMEWORKS@,$AL_FRAMEWORKS,;t t + s,@CPP@,$CPP,;t t + s,@EGREP@,$EGREP,;t t +-s,@AL_FRAMEWORKS@,$AL_FRAMEWORKS,;t t + s,@BUILD_PACKAGE_BOOL@,$BUILD_PACKAGE_BOOL,;t t + s,@CALLCONV@,$CALLCONV,;t t + s,@LIBOBJS@,$LIBOBJS,;t t +diff -uNr --exclude=autom4te.cache --exclude=.cvsignore hugs98-Mar2005-patched/fptools/libraries/OpenAL/configure.ac ghc-6.4.2/libraries/OpenAL/configure.ac +--- hugs98-Mar2005-patched/fptools/libraries/OpenAL/configure.ac 2005-02-04 18:16:28.000000000 +0900 ++++ ghc-6.4.2/libraries/OpenAL/configure.ac 2006-03-22 00:58:03.000000000 +0900 +@@ -1,4 +1,4 @@ +-AC_INIT([Haskell HOpenAL package], [1.0], [sven.panne@aedion.de], [OpenAL]) ++AC_INIT([Haskell HOpenAL package], [1.2], [sven.panne@aedion.de], [OpenAL]) + + # Safety check: Ensure that we are in the correct source directory. + AC_CONFIG_SRCDIR([include/HsOpenAL.h.in]) +@@ -19,7 +19,7 @@ + # The following test for the OpenAL library is a bit of a hack, but gives nice + # feedback even for the case when no additional library is needed. (Mac OS X?) + AL_LIBS=no +-AC_SEARCH_LIBS([alGenSources], [openal], [AL_LIBS="$ac_cv_search_alGenSources"]) ++AC_SEARCH_LIBS([alGenSources], [openal openal32], [AL_LIBS="$ac_cv_search_alGenSources"]) + test x"$AL_LIBS" = x"none required" && AL_LIBS= + AC_SUBST([AL_LIBS]) + +@@ -27,42 +27,57 @@ + AC_MSG_WARN([no OpenAL library found, so this package will not be built]) + else + +-al_found_header=no +-AC_CHECK_HEADERS([AL/alc.h OpenAL/alc.h], [al_found_header=yes; break]) +-if test "$al_found_header" = no; then +- AC_MSG_WARN([no OpenAL header found, so this package will not be built]) +-else +- +-AL_BUILD_PACKAGE=yes +- + # Ugly... + AL_FRAMEWORKS= +-case $target_os in ++case $host_os in + darwin*) + AL_FRAMEWORKS=OpenAL + ;; + esac + AC_SUBST([AL_FRAMEWORKS]) + ++FP_HEADER_AL ++FP_HEADER_ALC ++if test -z "$AL_FRAMEWORKS" && test x"$fp_found_al_header$fp_found_alc_header" != xyesyes; then ++ AC_MSG_WARN([no OpenAL headers found, so this package will not be built]) ++else ++ ++AL_BUILD_PACKAGE=yes ++ + AC_CHECK_HEADERS([AL/alext.h OpenAL/alext.h], [break]) + +-FPTOOLS_CHECK_HTYPE(ALboolean) +-FPTOOLS_CHECK_HTYPE(ALbyte) +-FPTOOLS_CHECK_HTYPE(ALubyte) +-FPTOOLS_CHECK_HTYPE(ALshort) +-FPTOOLS_CHECK_HTYPE(ALushort) +-FPTOOLS_CHECK_HTYPE(ALint) +-FPTOOLS_CHECK_HTYPE(ALuint) +-FPTOOLS_CHECK_HTYPE(ALsizei) +-FPTOOLS_CHECK_HTYPE(ALenum) +-FPTOOLS_CHECK_HTYPE(ALbitfield) +-FPTOOLS_CHECK_HTYPE(ALfloat) +-FPTOOLS_CHECK_HTYPE(ALclampf) +-FPTOOLS_CHECK_HTYPE(ALdouble) +-FPTOOLS_CHECK_HTYPE(ALclampd) +-FPTOOLS_CHECK_HTYPE(ALCenum) ++FP_FUNC_ALCCLOSEDEVICE_VOID ++FP_FUNC_ALCMAKECONTEXTCURRENT_VOID ++FP_FUNC_ALCPROCESSCONTEXT_VOID ++FP_FUNC_ALCDESTROYCONTEXT_VOID ++ ++FPTOOLS_CHECK_HTYPE([ALboolean]) ++FPTOOLS_CHECK_HTYPE([ALchar], [Int8]) ++FPTOOLS_CHECK_HTYPE([ALbyte]) ++FPTOOLS_CHECK_HTYPE([ALubyte]) ++FPTOOLS_CHECK_HTYPE([ALshort]) ++FPTOOLS_CHECK_HTYPE([ALushort]) ++FPTOOLS_CHECK_HTYPE([ALint]) ++FPTOOLS_CHECK_HTYPE([ALuint]) ++FPTOOLS_CHECK_HTYPE([ALsizei]) ++FPTOOLS_CHECK_HTYPE([ALenum]) ++FPTOOLS_CHECK_HTYPE([ALfloat]) ++FPTOOLS_CHECK_HTYPE([ALdouble]) ++ ++FPTOOLS_CHECK_HTYPE([ALCboolean], [Int8]) ++FPTOOLS_CHECK_HTYPE([ALCchar], [Int8]) ++FPTOOLS_CHECK_HTYPE([ALCbyte], [Int8]) ++FPTOOLS_CHECK_HTYPE([ALCubyte], [Word8]) ++FPTOOLS_CHECK_HTYPE([ALCshort], [Int16]) ++FPTOOLS_CHECK_HTYPE([ALCushort], [Word16]) ++FPTOOLS_CHECK_HTYPE([ALCint], [Int32]) ++FPTOOLS_CHECK_HTYPE([ALCuint], [Word32]) ++FPTOOLS_CHECK_HTYPE([ALCsizei], [Int32]) ++FPTOOLS_CHECK_HTYPE([ALCenum], [Int32]) ++FPTOOLS_CHECK_HTYPE([ALCfloat], [Float]) ++FPTOOLS_CHECK_HTYPE([ALCdouble], [Double]) + +-FP_CHECK_CONSTS([AL_FORMAT_VORBIS_EXT ALC_FREQUENCY ALC_REFRESH ALC_SYNC ALC_NO_ERROR ALC_INVALID_DEVICE ALC_INVALID_CONTEXT ALC_INVALID_ENUM ALC_INVALID_VALUE ALC_OUT_OF_MEMORY ALC_DEFAULT_DEVICE_SPECIFIER ALC_DEVICE_SPECIFIER ALC_EXTENSIONS ALC_MAJOR_VERSION ALC_MINOR_VERSION ALC_ATTRIBUTES_SIZE ALC_ALL_ATTRIBUTES], [#include ++FP_CHECK_CONSTS([AL_FALSE AL_TRUE AL_NO_ERROR AL_INVALID_NAME AL_INVALID_ENUM AL_INVALID_VALUE AL_INVALID_OPERATION AL_OUT_OF_MEMORY AL_DOPPLER_FACTOR AL_SPEED_OF_SOUND AL_DISTANCE_MODEL AL_VERSION AL_RENDERER AL_VENDOR AL_EXTENSIONS AL_NONE AL_INVERSE_DISTANCE AL_INVERSE_DISTANCE_CLAMPED AL_LINEAR_DISTANCE AL_LINEAR_DISTANCE_CLAMPED AL_EXPONENT_DISTANCE AL_EXPONENT_DISTANCE_CLAMPED AL_POSITION AL_VELOCITY AL_GAIN AL_ORIENTATION AL_SOURCE_RELATIVE AL_SOURCE_TYPE AL_LOOPING AL_BUFFER AL_BUFFERS_QUEUED AL_BUFFERS_PROCESSED AL_MIN_GAIN AL_MAX_GAIN AL_REFERENCE_DISTANCE AL_ROLLOFF_FACTOR AL_MAX_DISTANCE AL_PITCH AL_DIRECTION AL_CONE_INNER_ANGLE AL_CONE_OUTER_ANGLE AL_CONE_OUTER_GAIN AL_SEC_OFFSET AL_SAMPLE_OFFSET AL_BYTE_OFFSET AL_SOURCE_STATE AL_UNDETERMINED AL_STATIC AL_STREAMING AL_INITIAL AL_PLAYING AL_PAUSED AL_STOPPED AL_FREQUENCY AL_SIZE AL_BITS AL_CHANNELS AL_FORMAT_MONO8 AL_FORMAT_MONO16 AL_FORMAT_STEREO8 AL_FORMAT_STEREO16 ALC_FALSE ALC_TRUE ALC_FREQUENCY ALC_REFRESH ALC_SYNC ALC_MONO_SOURCES ALC_STEREO_SOURCES ALC_NO_ERROR ALC_INVALID_DEVICE ALC_INVALID_CONTEXT ALC_INVALID_ENUM ALC_INVALID_VALUE ALC_INVALID_OPERATION ALC_OUT_OF_MEMORY ALC_DEFAULT_DEVICE_SPECIFIER ALC_DEVICE_SPECIFIER ALC_EXTENSIONS ALC_CAPTURE_DEFAULT_DEVICE_SPECIFIER ALC_CAPTURE_DEVICE_SPECIFIER ALC_ATTRIBUTES_SIZE ALC_ALL_ATTRIBUTES ALC_MAJOR_VERSION ALC_MINOR_VERSION ALC_CAPTURE_SAMPLES], [#include + #if defined(HAVE_AL_ALC_H) + #include + #elif defined(HAVE_OPENAL_ALC_H) +@@ -74,6 +89,87 @@ + #elif defined(HAVE_OPENAL_ALEXT_H) + #include + #endif ++ ++#ifndef AL_SPEED_OF_SOUND ++#define AL_SPEED_OF_SOUND 0xC003 ++#endif ++ ++#ifndef AL_LINEAR_DISTANCE ++#define AL_LINEAR_DISTANCE 0xD003 ++#endif ++ ++#ifndef AL_LINEAR_DISTANCE_CLAMPED ++#define AL_LINEAR_DISTANCE_CLAMPED 0xD004 ++#endif ++ ++#ifndef AL_EXPONENT_DISTANCE ++#define AL_EXPONENT_DISTANCE 0xD005 ++#endif ++ ++#ifndef AL_EXPONENT_DISTANCE_CLAMPED ++#define AL_EXPONENT_DISTANCE_CLAMPED 0xD006 ++#endif ++ ++#ifndef AL_SEC_OFFSET ++#define AL_SEC_OFFSET 0x1024 ++#endif ++ ++#ifndef AL_SAMPLE_OFFSET ++#define AL_SAMPLE_OFFSET 0x1025 ++#endif ++ ++#ifndef AL_BYTE_OFFSET ++#define AL_BYTE_OFFSET 0x1026 ++#endif ++ ++#ifndef AL_UNDETERMINED ++#define AL_UNDETERMINED 0x1030 ++#endif ++ ++#ifndef AL_STATIC ++#define AL_STATIC 0x1028 ++#endif ++ ++#ifndef ALC_MONO_SOURCES ++#define ALC_MONO_SOURCES 0x1010 ++#endif ++ ++#ifndef ALC_STEREO_SOURCES ++#define ALC_STEREO_SOURCES 0x1011 ++#endif ++ ++#ifndef AL_INVALID_ENUM ++#ifdef AL_ILLEGAL_ENUM ++#define AL_INVALID_ENUM AL_ILLEGAL_ENUM ++#else ++#define AL_INVALID_ENUM 0xA002 ++#endif ++#endif ++ ++#ifndef AL_INVALID_OPERATION ++#ifdef AL_ILLEGAL_COMMAND ++#define AL_INVALID_OPERATION AL_ILLEGAL_COMMAND ++#else ++#define AL_INVALID_OPERATION 0xA004 ++#endif ++#endif ++ ++/* NOTE: THIS IS NOT IN ANY HEADER */ ++#ifndef ALC_INVALID_OPERATION ++#define ALC_INVALID_OPERATION 0xA006 ++#endif ++ ++#ifndef ALC_CAPTURE_DEFAULT_DEVICE_SPECIFIER ++#define ALC_CAPTURE_DEFAULT_DEVICE_SPECIFIER 0x311 ++#endif ++ ++#ifndef ALC_CAPTURE_DEVICE_SPECIFIER ++#define ALC_CAPTURE_DEVICE_SPECIFIER 0x310 ++#endif ++ ++#ifndef ALC_CAPTURE_SAMPLES ++#define ALC_CAPTURE_SAMPLES 0x312 ++#endif + ]) + + AC_DEFINE_UNQUOTED([AL_LIBS], +@@ -95,7 +191,7 @@ + fi + AC_SUBST([BUILD_PACKAGE_BOOL]) + +-case "$target" in ++case "$host" in + *-mingw32) CALLCONV=stdcall ;; + *) CALLCONV=ccall ;; + esac +diff -uNr --exclude=autom4te.cache --exclude=.cvsignore hugs98-Mar2005-patched/fptools/libraries/OpenAL/examples/test/TestDevice.hs ghc-6.4.2/libraries/OpenAL/examples/test/TestDevice.hs +--- hugs98-Mar2005-patched/fptools/libraries/OpenAL/examples/test/TestDevice.hs 2004-04-05 23:15:54.000000000 +0900 ++++ ghc-6.4.2/libraries/OpenAL/examples/test/TestDevice.hs 2006-03-22 00:58:04.000000000 +0900 +@@ -1,8 +1,15 @@ +-import Sound.OpenAL ++import Control.Monad ( unless ) ++import System.IO ( hPutStrLn, stderr ) + import System.Posix.Unistd ( sleep ) ++import Sound.OpenAL + + main :: IO () + main = do +- dev <- openDevice (Just "'( ( devices '( native null ) ) )") +- sleep 1 +- closeDevice dev ++ maybeDevice <- openDevice (Just "'( ( devices '( native null ) ) )") ++ case maybeDevice of ++ Nothing -> hPutStrLn stderr "openDevice failed" ++ Just device -> do ++ sleep 1 ++ ok <- closeDevice device ++ unless ok $ ++ hPutStrLn stderr "closeDevice failed" +diff -uNr --exclude=autom4te.cache --exclude=.cvsignore hugs98-Mar2005-patched/fptools/libraries/OpenAL/include/HsOpenAL.h.in ghc-6.4.2/libraries/OpenAL/include/HsOpenAL.h.in +--- hugs98-Mar2005-patched/fptools/libraries/OpenAL/include/HsOpenAL.h.in 2004-01-03 04:03:10.000000000 +0900 ++++ ghc-6.4.2/libraries/OpenAL/include/HsOpenAL.h.in 2006-03-22 00:58:04.000000000 +0900 +@@ -1,7 +1,7 @@ + /* ----------------------------------------------------------------------------- + * + * Module : C support for Sound.OpenAL +- * Copyright : (c) Sven Panne 2003-2004 ++ * Copyright : (c) Sven Panne 2003-2005 + * License : BSD-style (see the file libraries/OpenAL/LICENSE) + * + * Maintainer : sven.panne@aedion.de +@@ -22,11 +22,9 @@ + #if defined(HAVE_AL_ALC_H) + #include + #include +-#include + #elif defined(HAVE_OPENAL_ALC_H) + #include + #include +-#include + #endif + + #endif +diff -uNr --exclude=autom4te.cache --exclude=.cvsignore hugs98-Mar2005-patched/fptools/libraries/OpenAL/include/HsOpenALConfig.h.in ghc-6.4.2/libraries/OpenAL/include/HsOpenALConfig.h.in +--- hugs98-Mar2005-patched/fptools/libraries/OpenAL/include/HsOpenALConfig.h.in 2005-03-12 08:13:22.000000000 +0900 ++++ ghc-6.4.2/libraries/OpenAL/include/HsOpenALConfig.h.in 2006-04-19 04:36:53.000000000 +0900 +@@ -1,5 +1,17 @@ + /* include/HsOpenALConfig.h.in. Generated from configure.ac by autoheader. */ + ++/* Define to 1 if `alcCloseDevice' returns void. */ ++#undef ALCCLOSEDEVICE_VOID ++ ++/* Define to 1 if `alcDestroyContext' returns void. */ ++#undef ALCDESTROYCONTEXT_VOID ++ ++/* Define to 1 if `alcMakeContextCurrent' returns void. */ ++#undef ALCMAKECONTEXTCURRENT_VOID ++ ++/* Define to 1 if `alcProcessContext' returns void. */ ++#undef ALCPROCESSCONTEXT_VOID ++ + /* Framework flags for AL, as a list of string literals. */ + #undef AL_FRAMEWORKS + +@@ -12,6 +24,15 @@ + /* The value of ALC_ATTRIBUTES_SIZE. */ + #undef CONST_ALC_ATTRIBUTES_SIZE + ++/* The value of ALC_CAPTURE_DEFAULT_DEVICE_SPECIFIER. */ ++#undef CONST_ALC_CAPTURE_DEFAULT_DEVICE_SPECIFIER ++ ++/* The value of ALC_CAPTURE_DEVICE_SPECIFIER. */ ++#undef CONST_ALC_CAPTURE_DEVICE_SPECIFIER ++ ++/* The value of ALC_CAPTURE_SAMPLES. */ ++#undef CONST_ALC_CAPTURE_SAMPLES ++ + /* The value of ALC_DEFAULT_DEVICE_SPECIFIER. */ + #undef CONST_ALC_DEFAULT_DEVICE_SPECIFIER + +@@ -21,6 +42,9 @@ + /* The value of ALC_EXTENSIONS. */ + #undef CONST_ALC_EXTENSIONS + ++/* The value of ALC_FALSE. */ ++#undef CONST_ALC_FALSE ++ + /* The value of ALC_FREQUENCY. */ + #undef CONST_ALC_FREQUENCY + +@@ -33,6 +57,9 @@ + /* The value of ALC_INVALID_ENUM. */ + #undef CONST_ALC_INVALID_ENUM + ++/* The value of ALC_INVALID_OPERATION. */ ++#undef CONST_ALC_INVALID_OPERATION ++ + /* The value of ALC_INVALID_VALUE. */ + #undef CONST_ALC_INVALID_VALUE + +@@ -42,6 +69,9 @@ + /* The value of ALC_MINOR_VERSION. */ + #undef CONST_ALC_MINOR_VERSION + ++/* The value of ALC_MONO_SOURCES. */ ++#undef CONST_ALC_MONO_SOURCES ++ + /* The value of ALC_NO_ERROR. */ + #undef CONST_ALC_NO_ERROR + +@@ -51,11 +81,197 @@ + /* The value of ALC_REFRESH. */ + #undef CONST_ALC_REFRESH + ++/* The value of ALC_STEREO_SOURCES. */ ++#undef CONST_ALC_STEREO_SOURCES ++ + /* The value of ALC_SYNC. */ + #undef CONST_ALC_SYNC + +-/* The value of AL_FORMAT_VORBIS_EXT. */ +-#undef CONST_AL_FORMAT_VORBIS_EXT ++/* The value of ALC_TRUE. */ ++#undef CONST_ALC_TRUE ++ ++/* The value of AL_BITS. */ ++#undef CONST_AL_BITS ++ ++/* The value of AL_BUFFER. */ ++#undef CONST_AL_BUFFER ++ ++/* The value of AL_BUFFERS_PROCESSED. */ ++#undef CONST_AL_BUFFERS_PROCESSED ++ ++/* The value of AL_BUFFERS_QUEUED. */ ++#undef CONST_AL_BUFFERS_QUEUED ++ ++/* The value of AL_BYTE_OFFSET. */ ++#undef CONST_AL_BYTE_OFFSET ++ ++/* The value of AL_CHANNELS. */ ++#undef CONST_AL_CHANNELS ++ ++/* The value of AL_CONE_INNER_ANGLE. */ ++#undef CONST_AL_CONE_INNER_ANGLE ++ ++/* The value of AL_CONE_OUTER_ANGLE. */ ++#undef CONST_AL_CONE_OUTER_ANGLE ++ ++/* The value of AL_CONE_OUTER_GAIN. */ ++#undef CONST_AL_CONE_OUTER_GAIN ++ ++/* The value of AL_DIRECTION. */ ++#undef CONST_AL_DIRECTION ++ ++/* The value of AL_DISTANCE_MODEL. */ ++#undef CONST_AL_DISTANCE_MODEL ++ ++/* The value of AL_DOPPLER_FACTOR. */ ++#undef CONST_AL_DOPPLER_FACTOR ++ ++/* The value of AL_EXPONENT_DISTANCE. */ ++#undef CONST_AL_EXPONENT_DISTANCE ++ ++/* The value of AL_EXPONENT_DISTANCE_CLAMPED. */ ++#undef CONST_AL_EXPONENT_DISTANCE_CLAMPED ++ ++/* The value of AL_EXTENSIONS. */ ++#undef CONST_AL_EXTENSIONS ++ ++/* The value of AL_FALSE. */ ++#undef CONST_AL_FALSE ++ ++/* The value of AL_FORMAT_MONO16. */ ++#undef CONST_AL_FORMAT_MONO16 ++ ++/* The value of AL_FORMAT_MONO8. */ ++#undef CONST_AL_FORMAT_MONO8 ++ ++/* The value of AL_FORMAT_STEREO16. */ ++#undef CONST_AL_FORMAT_STEREO16 ++ ++/* The value of AL_FORMAT_STEREO8. */ ++#undef CONST_AL_FORMAT_STEREO8 ++ ++/* The value of AL_FREQUENCY. */ ++#undef CONST_AL_FREQUENCY ++ ++/* The value of AL_GAIN. */ ++#undef CONST_AL_GAIN ++ ++/* The value of AL_INITIAL. */ ++#undef CONST_AL_INITIAL ++ ++/* The value of AL_INVALID_ENUM. */ ++#undef CONST_AL_INVALID_ENUM ++ ++/* The value of AL_INVALID_NAME. */ ++#undef CONST_AL_INVALID_NAME ++ ++/* The value of AL_INVALID_OPERATION. */ ++#undef CONST_AL_INVALID_OPERATION ++ ++/* The value of AL_INVALID_VALUE. */ ++#undef CONST_AL_INVALID_VALUE ++ ++/* The value of AL_INVERSE_DISTANCE. */ ++#undef CONST_AL_INVERSE_DISTANCE ++ ++/* The value of AL_INVERSE_DISTANCE_CLAMPED. */ ++#undef CONST_AL_INVERSE_DISTANCE_CLAMPED ++ ++/* The value of AL_LINEAR_DISTANCE. */ ++#undef CONST_AL_LINEAR_DISTANCE ++ ++/* The value of AL_LINEAR_DISTANCE_CLAMPED. */ ++#undef CONST_AL_LINEAR_DISTANCE_CLAMPED ++ ++/* The value of AL_LOOPING. */ ++#undef CONST_AL_LOOPING ++ ++/* The value of AL_MAX_DISTANCE. */ ++#undef CONST_AL_MAX_DISTANCE ++ ++/* The value of AL_MAX_GAIN. */ ++#undef CONST_AL_MAX_GAIN ++ ++/* The value of AL_MIN_GAIN. */ ++#undef CONST_AL_MIN_GAIN ++ ++/* The value of AL_NONE. */ ++#undef CONST_AL_NONE ++ ++/* The value of AL_NO_ERROR. */ ++#undef CONST_AL_NO_ERROR ++ ++/* The value of AL_ORIENTATION. */ ++#undef CONST_AL_ORIENTATION ++ ++/* The value of AL_OUT_OF_MEMORY. */ ++#undef CONST_AL_OUT_OF_MEMORY ++ ++/* The value of AL_PAUSED. */ ++#undef CONST_AL_PAUSED ++ ++/* The value of AL_PITCH. */ ++#undef CONST_AL_PITCH ++ ++/* The value of AL_PLAYING. */ ++#undef CONST_AL_PLAYING ++ ++/* The value of AL_POSITION. */ ++#undef CONST_AL_POSITION ++ ++/* The value of AL_REFERENCE_DISTANCE. */ ++#undef CONST_AL_REFERENCE_DISTANCE ++ ++/* The value of AL_RENDERER. */ ++#undef CONST_AL_RENDERER ++ ++/* The value of AL_ROLLOFF_FACTOR. */ ++#undef CONST_AL_ROLLOFF_FACTOR ++ ++/* The value of AL_SAMPLE_OFFSET. */ ++#undef CONST_AL_SAMPLE_OFFSET ++ ++/* The value of AL_SEC_OFFSET. */ ++#undef CONST_AL_SEC_OFFSET ++ ++/* The value of AL_SIZE. */ ++#undef CONST_AL_SIZE ++ ++/* The value of AL_SOURCE_RELATIVE. */ ++#undef CONST_AL_SOURCE_RELATIVE ++ ++/* The value of AL_SOURCE_STATE. */ ++#undef CONST_AL_SOURCE_STATE ++ ++/* The value of AL_SOURCE_TYPE. */ ++#undef CONST_AL_SOURCE_TYPE ++ ++/* The value of AL_SPEED_OF_SOUND. */ ++#undef CONST_AL_SPEED_OF_SOUND ++ ++/* The value of AL_STATIC. */ ++#undef CONST_AL_STATIC ++ ++/* The value of AL_STOPPED. */ ++#undef CONST_AL_STOPPED ++ ++/* The value of AL_STREAMING. */ ++#undef CONST_AL_STREAMING ++ ++/* The value of AL_TRUE. */ ++#undef CONST_AL_TRUE ++ ++/* The value of AL_UNDETERMINED. */ ++#undef CONST_AL_UNDETERMINED ++ ++/* The value of AL_VELOCITY. */ ++#undef CONST_AL_VELOCITY ++ ++/* The value of AL_VENDOR. */ ++#undef CONST_AL_VENDOR ++ ++/* The value of AL_VERSION. */ ++#undef CONST_AL_VERSION + + /* Define to 1 if you have the header file. */ + #undef HAVE_AL_ALC_H +@@ -63,6 +279,9 @@ + /* Define to 1 if you have the header file. */ + #undef HAVE_AL_ALEXT_H + ++/* Define to 1 if you have the header file. */ ++#undef HAVE_AL_AL_H ++ + /* Define to 1 if you have the header file. */ + #undef HAVE_INTTYPES_H + +@@ -75,6 +294,9 @@ + /* Define to 1 if you have the header file. */ + #undef HAVE_OPENAL_ALEXT_H + ++/* Define to 1 if you have the header file. */ ++#undef HAVE_OPENAL_AL_H ++ + /* Define to 1 if you have the header file. */ + #undef HAVE_STDINT_H + +@@ -96,23 +318,50 @@ + /* Define to 1 if you have the header file. */ + #undef HAVE_UNISTD_H + +-/* Define to Haskell type for ALbitfield */ +-#undef HTYPE_ALBITFIELD +- + /* Define to Haskell type for ALboolean */ + #undef HTYPE_ALBOOLEAN + + /* Define to Haskell type for ALbyte */ + #undef HTYPE_ALBYTE + ++/* Define to Haskell type for ALCboolean */ ++#undef HTYPE_ALCBOOLEAN ++ ++/* Define to Haskell type for ALCbyte */ ++#undef HTYPE_ALCBYTE ++ ++/* Define to Haskell type for ALCchar */ ++#undef HTYPE_ALCCHAR ++ ++/* Define to Haskell type for ALCdouble */ ++#undef HTYPE_ALCDOUBLE ++ + /* Define to Haskell type for ALCenum */ + #undef HTYPE_ALCENUM + +-/* Define to Haskell type for ALclampd */ +-#undef HTYPE_ALCLAMPD ++/* Define to Haskell type for ALCfloat */ ++#undef HTYPE_ALCFLOAT ++ ++/* Define to Haskell type for ALchar */ ++#undef HTYPE_ALCHAR ++ ++/* Define to Haskell type for ALCint */ ++#undef HTYPE_ALCINT ++ ++/* Define to Haskell type for ALCshort */ ++#undef HTYPE_ALCSHORT ++ ++/* Define to Haskell type for ALCsizei */ ++#undef HTYPE_ALCSIZEI ++ ++/* Define to Haskell type for ALCubyte */ ++#undef HTYPE_ALCUBYTE ++ ++/* Define to Haskell type for ALCuint */ ++#undef HTYPE_ALCUINT + +-/* Define to Haskell type for ALclampf */ +-#undef HTYPE_ALCLAMPF ++/* Define to Haskell type for ALCushort */ ++#undef HTYPE_ALCUSHORT + + /* Define to Haskell type for ALdouble */ + #undef HTYPE_ALDOUBLE +diff -uNr --exclude=autom4te.cache --exclude=.cvsignore hugs98-Mar2005-patched/fptools/libraries/OpenAL/package.conf.in ghc-6.4.2/libraries/OpenAL/package.conf.in +--- hugs98-Mar2005-patched/fptools/libraries/OpenAL/package.conf.in 2005-02-19 00:06:43.000000000 +0900 ++++ ghc-6.4.2/libraries/OpenAL/package.conf.in 2006-03-22 00:58:03.000000000 +0900 +@@ -9,27 +9,36 @@ + exposed-modules: + Sound.OpenAL, + Sound.OpenAL.AL, ++ Sound.OpenAL.AL.ALboolean, ++ Sound.OpenAL.AL.Attenuation, + Sound.OpenAL.AL.BasicTypes, + Sound.OpenAL.AL.Buffer, ++ Sound.OpenAL.AL.BufferInternal, ++ Sound.OpenAL.AL.Doppler, ++ Sound.OpenAL.AL.Errors, ++ Sound.OpenAL.AL.Extensions, ++ Sound.OpenAL.AL.Format, + Sound.OpenAL.AL.Listener, + Sound.OpenAL.AL.Source, ++ Sound.OpenAL.AL.StringQueries, + Sound.OpenAL.ALC, ++ Sound.OpenAL.ALC.BasicTypes, ++ Sound.OpenAL.ALC.Capture, + Sound.OpenAL.ALC.Context, + Sound.OpenAL.ALC.Device, + Sound.OpenAL.ALC.Errors, +- Sound.OpenAL.ALC.Extensions, +- Sound.OpenAL.ALUT, +- Sound.OpenAL.ALUT.Initialization, +- Sound.OpenAL.ALUT.WAV ++ Sound.OpenAL.ALC.Extensions + + hidden-modules: +- Sound.OpenAL.AL.ALboolean, +- Sound.OpenAL.AL.Format, + Sound.OpenAL.AL.PeekPoke, + Sound.OpenAL.AL.QueryUtils, +- Sound.OpenAL.ALC.BasicTypes, +- Sound.OpenAL.ALC.Queries, +- Sound.OpenAL.ALUT.Exception ++ Sound.OpenAL.AL.SourceState, ++ Sound.OpenAL.AL.String, ++ Sound.OpenAL.ALC.ALCboolean, ++ Sound.OpenAL.ALC.QueryUtils, ++ Sound.OpenAL.ALC.String, ++ Sound.OpenAL.Config, ++ Sound.OpenAL.Constants + + import-dirs: IMPORT_DIR +