OS4 DepotLogo by Kicko 
(anonymous IP:,1557) 

   Bug tracker
   Locale browser


   o Audio (331)
   o Datatype (50)
   o Demo (188)
   o Development (556)
   o Document (21)
   o Driver (90)
   o Emulation (143)
   o Game (904)
   o Graphics (477)
   o Library (104)
   o Network (213)
   o Office (60)
   o Utility (839)
   o Video (64)

Total files: 4040

Full index file
Recent index file



Support the site

 Readme for:  Development » Library » Audio » freealut.lha


Description: Free ALUT audio library (often needed by OpenAL)
Download: freealut.lha       (TIPS: Use the right click menu if your browser takes you back here all the time)
Size: 2Mb
Version: 1.1.0
Date: 08 Apr 2009
Author: http://www.openal.org, AmigaOS 4.x compile by Spot / Up Rough
Submitter: Spot / Up Rough
Email: spotup/gmail com
Homepage: http://www.openal.org
Category: development/library/audio
License: Other
Distribute: yes
Min OS Version: 4.0
FileID: 4735
Comments: 0
Snapshots: 0
Videos: 0
Downloads: 1002  (Current version)
1002  (Accumulated)
Votes: 0 (0/0)  (30 days/7 days)

Show comments Show snapshots Show videos Show content Show crashlogs Replace file 
The freealut library

freealut is a free implementation of OpenAL's ALUT standard. See the file
AUTHORS for the people involved.

Building and installing on *nix-alikes using autotools

To build and run ALUT, you need an OpenAL somewhere (and a sound card, of course
:-). If OpenAL is not installed in a standard place (let's say ${OPENAL_PREFIX})
you'll have to tell the build system about it:


If you install ALUT from the CVS repository, you'll have to call


first, this will generate some necessary files for building ALUT.

If these initial preparations are done, you can simply run:

   make install

The last step is optional and must be done as 'root', you can build and use the
test programs in 'test_suite' and the example programs in 'examples' without
installing ALUT. To build these, just go to the respective subdirectories and
run 'make'.

Alternatively, there is a spec file in the admin/RPM subdirectory, which can be
used to build an RPM.

Building with VisualStudio

The admin subdirectory contains VisualStudio6 and VisualStudioDotNET
subdirectories, which contain a Visual Studio 6 workspace and a Visual Studio
.NET solution, respectively. These expect the OpenAL SDK (header and import
library) at the standard path "C:\Program Files\OpenAL 1.1 with EFX SDK". If
this is not the case for your setup, you can change this either directly with a
text editor in the project files (the only way for *real* men ;-) or via the
project settings within Visual Studio. When everything is OK, just build
e.g. the hello_world project and you should get the ALUT library itself and a
demo with Steve Baker saying an immortal phrase.

Building with CMake

The CMake build files are maintained by prakash()punnoor.de, so
if you have troubles building Alut using CMake, please contact
me and not the Alut devs, as the official build system is still
the one using autotools. The CMake build files are currenty
meant as an additional possibility to build Alut.

The aim of using CMake is making portable development easier, as
CMake containg generators for various build systems. On eg. Unix
Makefiles will be built, and on Windows MS VC++ project files, if
you wish. You can get CMake at cmake.org.

Current status:
The build system is feature complete, so it (should) build every-
thing as the default one does.

This document explains briefly how to build with CMake on Linux via out-
of-tree build:

- Change to the alut dir.
- Create a dir, eg "default", and change into it.
- Now (eg.) run:

-DCMAKE_C_FLAGS:STRING="-march=athlon-xp -O2"
make install

  If you exported your CFLAGS, there is no need to specify them
  explicitly, as CMake will pick them up.

- OpenAL should get installed as you got used to it.

I really would like to get CMake building Alut on every
supported platform. So please contact me if it doesn't build
on yours. I'll try to fix this with your help.

Some Tips:

- You can use a console GUI named ccmake for configuring cmake.
  This also comes in handy, to find out about available options.
  You can also set options via command-line:

-DCMAKE_C_FLAGS:STRING="-march=athlon-xp -O2"

  sets the two variables defined on command line and then starts
  the GUI. Press 'c' the first time and every time you want to commit
  changes in the config. Finally press 'g' to run the generator.
  Btw, to set boolean vars from the command line, use -DVAR:BOOL=X,
  where X is eg. ON or OFF.

- If you want more output at compile time, use

make VERBOSE=1

- If you want to install to a different directory (using same prefix),

make install DESTDIR=/foo/bar

- CMake doesn't has a distclean target by default, so you better
  really do an out-of-tree build, then you can simply delete its
  content when you want a distclean... Furthermore it is easier to
  have different builds using different parameters via out-of-tree

- If you are interested in variables to set, take a look into
  CMakeCache.txt after having run the configuring stage.

- If you update your source tree via cvs and want to rebuild an pre-
  viously built lib without cleaning, you better at least clear the 
  CMake cache (remove CMakeCache.txt) otherwise a modified CMake project
  file could result to unwanted behaviour.


Please don't email me the authors directly, sign up to the OpenAL user's mailing
list. Instructions can be found here:



These libraries are offered as OpenSource freeware under the provisions of the
GNU Library Public License (LGPL). Those terms and conditions are detailed in
the file 'COPYING' in this directory.

Portability and Dependencies

This library is designed to be easily portable (and more importantly so that
programs using it can be UTTERLY portable).

Compiling/Linking with ALUT

In your source code, simply add:

   #include <AL/alut.h>

On *nix-alikes, use

   openal-config --cflags
   openal-config --libs

to find out the compiler and linker flags needed for OpenAL, the flags needed
for ALUT itself depend on the --prefix option given to configure.

In a VisualStudio project, add the path to the ALUT header, import library and
DLL to your project settings as usual.


Within this distribution, you will find the following directories:

admin      -- Administrative files needed for building ALUT
doc        -- The ALUT documentation
examples   -- For application authors, here is a small collection of example
              programs that you can use to get you started
include    -- The ALUT header
src        -- The source code for the ALUT library itself
test_suite -- A small suite of test programs to check that ALUT is installed and
              working correctly

Copyright © 2004-2020 by Björn Hagström All Rights Reserved