Merge mangle into openmw

.gitmodules

@@ -1,6 +1,3 @@
-[submodule "libs/mangle"]
-	path = libs/mangle
-	url = git://github.com/zinnschlag/mangle.git
 [submodule "libs/openengine"]
 	path = libs/openengine
 	url = git://github.com/zinnschlag/OpenEngine

libs/mangle

@@ -1 +0,0 @@
-Subproject commit 14b2851e72f610ae81dd296598867e6fb0babd2a

libs/mangle/.gitignore

@@ -0,0 +1,3 @@
+upload_docs.sh
+docs
+*~

libs/mangle/LICENSE.txt

@@ -0,0 +1,26 @@
+Minimal Abstraction Game Layer (Mangle) is licensed under the
+'zlib/libpng' license:
+
+----
+
+Copyright (c) 2009 Nicolay Korslund
+
+This software is provided 'as-is', without any express or implied
+warranty. In no event will the authors be held liable for any damages
+arising from the use of this software.
+
+Permission is granted to anyone to use this software for any purpose,
+including commercial applications, and to alter it and redistribute it
+freely, subject to the following restrictions:
+
+    1. The origin of this software must not be misrepresented; you must not
+    claim that you wrote the original software. If you use this software
+    in a product, an acknowledgment in the product documentation would be
+    appreciated but is not required.
+
+    2. Altered source versions must be plainly marked as such, and must not be
+    misrepresented as being the original software.
+
+    3. This notice may not be removed or altered from any source
+    distribution.
+

libs/mangle/README.txt

@@ -0,0 +1,129 @@
+Welcome to Mangle v0.1
+----------------------
+
+Written by:      Nicolay Korslund (korslund@gmail.com)
+License:         zlib/png (see LICENSE.txt)
+WWW:             http://asm-soft.com/mangle/
+Documentation:   http://asm-soft.com/mangle/docs
+
+
+
+Mangle is the project name for a small set of generic interfaces for
+various game middleware libraries, such as sound, input, graphics, and
+so on. You can imagine that it stands for "Minimal Abstraction Game
+Layer", if you like. It will consist of several more or less
+independent modules, one for each of these areas. These may be used
+together to build an entire game engine, or they can be used
+individually as separate libraries.
+
+However, Mangle does NOT actually implement a game engine, or any new
+fundamental functionality. More on that below.
+
+Currently there's modules for sound and streams / archives (virtual
+file systems.) More will come in the future (including input, 2D/3D
+graphics, GUI, physics, and more.)
+
+
+Main idea
+---------
+
+The idea behind Mangle is to provide a uniform, consistent interface
+to other game libraries. The library does not provide ANY
+functionality on its own. Instead it connects to a backend
+implementation of your choice (or of your making.)
+
+The Sound module, for example, currently has backends for OpenAL
+(output only), FFmpeg (input only) and for Audiere. Hopefully we'll
+add IrrKlang, FMod, DirectSound, Miles and more in the future. It can
+combine libraries to get more complete functionality (like using
+OpenAL for output and FFmpeg to decode sound files), and it's also
+easy to write your own backend if you're using a different (or
+home-brewed) sound system.
+
+Regardless of what backend you use, the front-end interfaces (found
+eg. in sound/output.h) is identical, and as a library user you
+shouldn't notice much difference at all if you swap one backend for
+another at a later point. It should Just Work.
+
+The interfaces themselves are also quite simple. Setting up a sound
+stream from FFmpeg or other decoder into OpenAL can be quite hairy -
+but with Mangle the hairy parts have already been written for you. You
+just plug the parts together.
+
+The goal in the long run is to support a wide variety of game-related
+libraries, and as many backend libraries (free and commercial) as
+possible, so that you the user will have to write as little code as
+possible.
+
+
+
+What is it good for
+-------------------
+
+The main point of Mangle, as we said above, is that it connects to any
+library of your choice "behind the scenes" but provides the same,
+super-simple interface front-end for all of them. There can benefit
+you in many ways:
+
+- If you want to use a new library that Mangle support. You don't have
+  to scour the net for tutorials and usage examples, since much of the
+  common usage code is already included in the implementation classes.
+
+- If you don't want to pollute your code with library-specific code.
+  The Mangle interfaces can help you keep your code clean, and its
+  user interface is often simpler than the exteral library one.
+
+- If you want to quickly connect different libraries together, it
+  really helps if they speak a common language. The Mangle interfaces
+  are exactly that - a common language between libraries. Do you need
+  Audiere to load sounds from a weird archive format only implemented
+  for PhysFS, all channeled through the OGRE resource system? No
+  problem!
+
+- If you are creating a library that depends on a specific feature
+  (such as sound), but you don't want to lock your users into any
+  specific sound library. Mangle works as an abstraction that lets
+  your users select their own implementation.
+
+- If you want to support multiple backends for your game/app, or want
+  to make it possible to easily switch backends later. You can select
+  backends at compile time or even at runtime. For example you might
+  want to switch to to a commercial sound library at a later stage in
+  development, or you may want to use a different input library on
+  console platforms than on PC.
+
+The Mangle implementations are extremely light-weight - often just one
+or two cpp/h pairs per module. You can plug them directly into your
+program, there's no separate library building step required.
+
+Since the library aims to be very modularly put together, you can
+also, in many cases, just copy-and-paste the parts you need and ignore
+the rest. Or modify stuff without fearing that the whole 'system' will
+come crashing down, because there is no big 'system' to speak of.
+
+
+Past and future 
+---------------
+
+Mangle started out as (and still is) a spin-off from OpenMW, another
+project I am personally working on ( http://openmw.com/ ). OpenMW is
+an attempt to recreate the engine behind the commercial game
+Morrowind, using only open source software.
+
+The projects are still tightly interlinked, and they will continue to
+be until OpenMW is finished. Most near-future work on Mangle will be
+focused chiefly on OpenMW at the moment. However I will gladly include
+external contributions and suggestions that are not OpenMW-related if
+someone sends them to me.
+
+
+Conclusion
+----------
+
+As you might have guessed, Mangle is more a concept in development
+than a finished library right now.
+
+All feedback, ideas, concepts, questions and code are very
+welcome. Send them to: korslund@gmail.com
+
+I will put up a forum later as well if there's enough interest.

libs/mangle/input/clients/ogre_input_capture.hpp

@@ -0,0 +1,29 @@
+#ifndef MANGLE_INPUT_OGREINPUTFRAME_H
+#define MANGLE_INPUT_OGREINPUTFRAME_H
+
+/*
+  This Ogre FrameListener calls capture() on an input driver every frame.
+ */
+
+#include <OgreFrameListener.h>
+#include "../driver.hpp"
+
+namespace Mangle {
+namespace Input {
+
+  struct OgreInputCapture : Ogre::FrameListener
+  {
+    Mangle::Input::Driver &driver;
+
+    OgreInputCapture(Mangle::Input::Driver &drv)
+      : driver(drv) {}
+
+    bool frameStarted(const Ogre::FrameEvent &evt)
+    {
+      driver.capture();
+      return true;
+    }
+  };
+}}
+
+#endif

libs/mangle/input/driver.hpp

@@ -0,0 +1,69 @@
+#ifndef MANGLE_INPUT_DRIVER_H
+#define MANGLE_INPUT_DRIVER_H
+
+#include "event.hpp"
+
+namespace Mangle
+{
+  namespace Input
+  {
+    /** Input::Driver is the main interface to any input system that
+        handles keyboard and/or mouse input, along with any other
+        input source like joysticks.
+
+        It is really a generalized event system, and could also be
+        used for non-input related events. The definition of the event
+        codes and structures are entirely dependent on the
+        implementation.
+
+        A system-independent key code list will be found in keys.hpp,
+        and input drivers should privide optional translations to/from
+        this list for full compatibility.
+     */
+    struct Driver
+    {
+      Driver() {}
+      virtual ~Driver() {}
+
+      /** Captures input and produces the relevant events from it. An
+          event callback must be set with setEvent(), or all events
+          will be ignored.
+       */
+      virtual void capture() = 0;
+
+      /** Check the state of a given key or button. The key/button
+          definitions depends on the driver.
+       */
+      virtual bool isDown(int index) = 0;
+
+      /** Show or hide system mouse cursor
+       */
+      virtual void showMouse(bool show) = 0;
+
+      /** Set the event handler for input events. The evt->event()
+          function is called for each event. The meaning of the index
+          and *p parameters will be specific to each driver and to
+          each input system.
+       */
+      void setEvent(EventPtr evt)
+      { event = evt; }
+
+      /** Instigate an event. Is used internally for all events, but
+          can also be called from the outside to "fake" events from
+          this driver.
+      */
+      void makeEvent(Event::Type type, int index, const void *p=NULL)
+      {
+        if(event)
+          event->event(type,index,p);
+      }
+
+    private:
+      /// Holds the event callback set byt setEvent()
+      EventPtr event;
+    };
+
+    typedef boost::shared_ptr<Driver> DriverPtr;
+  }
+}
+#endif

libs/mangle/input/event.hpp

@@ -0,0 +1,46 @@
+#ifndef MANGLE_INPUT_EVENT_H
+#define MANGLE_INPUT_EVENT_H
+
+#include "../tools/shared_ptr.hpp"
+
+namespace Mangle
+{
+  namespace Input
+  {
+    /** Generic callback for input events. The meaning of the
+        parameters depend on the system producing the events.
+    */
+    struct Event
+    {
+      /// Event types
+      enum Type
+        {
+          EV_Unknown    = 1,    // Unknown event type
+          EV_KeyDown    = 2,    // Keyboard button was pressed
+          EV_KeyUp      = 4,    // Keyboard button was released
+          EV_Keyboard   = 6,    // All keyboard events
+
+          EV_MouseMove  = 8,    // Mouse movement
+          EV_MouseDown  = 16,   // Mouse button pressed
+          EV_MouseUp    = 32,   // Mouse button released
+          EV_Mouse      = 56,   // All mouse events
+
+          EV_ALL        = 63    // All events
+        };
+
+      /**
+         Called upon all events. The first parameter give the event
+         type, the second gives additional data (usually the local
+         keysym or button index as defined by the driver), and the
+         pointer points to the full custom event structure provided by
+         the driver (the type may vary depending on the EventType,
+         this is defined in the Driver documentation.)
+       */
+      virtual void event(Type type, int index, const void *p) = 0;
+      virtual ~Event() {}
+    };
+
+    typedef boost::shared_ptr<Event> EventPtr;
+  }
+}
+#endif

libs/mangle/input/filters/eventlist.hpp

@@ -0,0 +1,47 @@
+#ifndef MANGLE_INPUT_EVENTLIST_H
+#define MANGLE_INPUT_EVENTLIST_H
+
+#include "../event.hpp"
+#include <vector>
+
+namespace Mangle
+{
+  namespace Input
+  {
+    /** And Event handler that distributes each event to a list of
+        other handlers. Supports filtering events by their Type
+        parameter.
+     */
+    struct EventList : Event
+    {
+      struct Filter
+      {
+        EventPtr evt;
+        int flags;
+      };
+      std::vector<Filter> list;
+
+      void add(EventPtr e, int flags = EV_ALL)
+      {
+        Filter f;
+        f.evt = e;
+        f.flags = flags;
+        list.push_back(f);
+      }
+
+      virtual void event(Type type, int index, const void *p)
+      {
+        std::vector<Filter>::iterator it;
+
+        for(it=list.begin(); it!=list.end(); it++)
+          {
+            if(type & it->flags)
+              it->evt->event(type,index,p);
+          }
+      }
+    };
+
+    typedef boost::shared_ptr<EventList> EventListPtr;
+  }
+}
+#endif

libs/mangle/input/servers/ois_driver.cpp

@@ -0,0 +1,148 @@
+#include "ois_driver.hpp"
+
+#include <assert.h>
+#include <sstream>
+#include <OgreRenderWindow.h>
+#include <OIS/OIS.h>
+
+#ifdef __APPLE_CC__
+#include <Carbon/Carbon.h>
+#endif
+
+using namespace Mangle::Input;
+using namespace OIS;
+
+struct Mangle::Input::OISListener : OIS::KeyListener, OIS::MouseListener
+{
+  OISDriver &drv;
+
+  OISListener(OISDriver &driver)
+    : drv(driver) {}
+
+  bool keyPressed( const OIS::KeyEvent &arg )
+  {
+    drv.makeEvent(Event::EV_KeyDown, arg.key, &arg);
+    return true;
+  }
+
+  bool keyReleased( const OIS::KeyEvent &arg )
+  {
+    drv.makeEvent(Event::EV_KeyUp, arg.key, &arg);
+    return true;
+  }
+
+  bool mousePressed( const OIS::MouseEvent &arg, OIS::MouseButtonID id )
+  {
+    // Mouse button events are handled as key events
+    // TODO: Translate mouse buttons into pseudo-keysyms
+    drv.makeEvent(Event::EV_MouseDown, id, &arg);
+    return true;
+  }
+
+  bool mouseReleased( const OIS::MouseEvent &arg, OIS::MouseButtonID id )
+  {
+    // TODO: ditto
+    drv.makeEvent(Event::EV_MouseUp, id, &arg);
+    return true;
+  }
+
+  bool mouseMoved( const OIS::MouseEvent &arg )
+  {
+    drv.makeEvent(Event::EV_MouseMove, -1, &arg);
+    return true;
+  }
+};
+
+OISDriver::OISDriver(Ogre::RenderWindow *window, bool exclusive)
+{
+  assert(window);
+
+  size_t windowHnd;
+
+  window->getCustomAttribute("WINDOW", &windowHnd);
+
+  std::ostringstream windowHndStr;
+  ParamList pl;
+
+  windowHndStr << windowHnd;
+  pl.insert(std::make_pair(std::string("WINDOW"), windowHndStr.str()));
+
+  // Set non-exclusive mouse and keyboard input if the user requested
+  // it.
+  if(!exclusive)
+    {
+#if defined OIS_WIN32_PLATFORM
+      pl.insert(std::make_pair(std::string("w32_mouse"),
+                               std::string("DISCL_FOREGROUND" )));
+      pl.insert(std::make_pair(std::string("w32_mouse"),
+                               std::string("DISCL_NONEXCLUSIVE")));
+      pl.insert(std::make_pair(std::string("w32_keyboard"),
+                               std::string("DISCL_FOREGROUND")));
+      pl.insert(std::make_pair(std::string("w32_keyboard"),
+                               std::string("DISCL_NONEXCLUSIVE")));
+#elif defined OIS_LINUX_PLATFORM
+      pl.insert(std::make_pair(std::string("x11_mouse_grab"),
+                               std::string("false")));
+      pl.insert(std::make_pair(std::string("x11_mouse_hide"),
+                               std::string("false")));
+      pl.insert(std::make_pair(std::string("x11_keyboard_grab"),
+                               std::string("false")));
+      pl.insert(std::make_pair(std::string("XAutoRepeatOn"),
+                               std::string("true")));
+#endif
+    }
+
+#ifdef __APPLE_CC__
+  // Give the application window focus to receive input events
+  ProcessSerialNumber psn = { 0, kCurrentProcess };
+  TransformProcessType(&psn, kProcessTransformToForegroundApplication);
+  SetFrontProcess(&psn);
+#endif
+
+  inputMgr = InputManager::createInputSystem( pl );
+
+  // Create all devices
+  keyboard = static_cast<Keyboard*>(inputMgr->createInputObject
+                                    ( OISKeyboard, true ));
+  mouse = static_cast<Mouse*>(inputMgr->createInputObject
+                              ( OISMouse, true ));
+
+  // Set mouse region
+  const MouseState &ms = mouse->getMouseState();
+  ms.width  = window->getWidth();
+  ms.height = window->getHeight();
+
+  // Set up the input listener
+  listener = new OISListener(*this);
+  keyboard-> setEventCallback(listener);
+  mouse-> setEventCallback(listener);
+}
+
+OISDriver::~OISDriver()
+{
+  // Delete the listener object
+  if(listener)
+    delete listener;
+
+  if(inputMgr == NULL) return;
+
+  // Kill the input systems. This will reset input options such as key
+  // repeat rate.
+  inputMgr->destroyInputObject(keyboard);
+  inputMgr->destroyInputObject(mouse);
+  InputManager::destroyInputSystem(inputMgr);
+  inputMgr = NULL;
+}
+
+void OISDriver::capture()
+{
+  // Capture keyboard and mouse events
+  keyboard->capture();
+  mouse->capture();
+}
+
+bool OISDriver::isDown(int index)
+{
+  // TODO: Extend to mouse buttons as well
+  return keyboard->isKeyDown((OIS::KeyCode)index);
+}

libs/mangle/input/servers/ois_driver.hpp

@@ -0,0 +1,48 @@
+#ifndef MANGLE_INPUT_OIS_DRIVER_H
+#define MANGLE_INPUT_OIS_DRIVER_H
+
+#include "../driver.hpp"
+
+namespace OIS
+{
+  class InputManager;
+  class Mouse;
+  class Keyboard;
+}
+
+namespace Ogre
+{
+  class RenderWindow;
+}
+
+namespace Mangle
+{
+  namespace Input
+  {
+    struct OISListener;
+
+    /** Input driver for OIS, the input manager typically used with
+        Ogre.
+     */
+    struct OISDriver : Driver
+    {
+      /// If exclusive=true, then we capture mouse and keyboard from
+      /// the OS.
+      OISDriver(Ogre::RenderWindow *window, bool exclusive=true);
+      ~OISDriver();
+
+      void capture();
+      bool isDown(int index);
+      /// Not currently supported.
+      void showMouse(bool) {}
+
+    private:
+      OIS::InputManager *inputMgr;
+      OIS::Mouse *mouse;
+      OIS::Keyboard *keyboard;
+
+      OISListener *listener;
+    };
+  }
+}
+#endif

libs/mangle/input/servers/sdl_driver.cpp

@@ -0,0 +1,54 @@
+#include "sdl_driver.hpp"
+
+#include <SDL.h>
+
+using namespace Mangle::Input;
+
+void SDLDriver::capture()
+{
+  // Poll for events
+  SDL_Event evt;
+  while(SDL_PollEvent(&evt))
+    {
+      Event::Type type = Event::EV_Unknown;
+      int index = -1;
+
+      switch(evt.type)
+        {
+          // For key events, send the keysym as the index.
+        case SDL_KEYDOWN:
+          type = Event::EV_KeyDown;
+          index = evt.key.keysym.sym;
+          break;
+        case SDL_KEYUP:
+          type = Event::EV_KeyUp;
+          index = evt.key.keysym.sym;
+          break;
+        case SDL_MOUSEMOTION:
+          type = Event::EV_MouseMove;
+          break;
+          // Add more event types later
+        }
+
+      // Pass the event along, using -1 as index for unidentified
+      // event types.
+      makeEvent(type, index, &evt);
+    }
+}
+
+bool SDLDriver::isDown(int index)
+{
+  int num;
+  Uint8 *keys = SDL_GetKeyState(&num);
+  assert(index >= 0 && index < num);
+
+  // The returned array from GetKeyState is indexed by the
+  // SDLK_KEYNAME enums and is just a list of bools. If the indexed
+  // value is true, the button is down.
+  return keys[index];
+}
+
+void SDLDriver::showMouse(bool show)
+{
+  SDL_ShowCursor(show?SDL_ENABLE:SDL_DISABLE);
+}

libs/mangle/input/servers/sdl_driver.hpp

@@ -0,0 +1,27 @@
+#ifndef MANGLE_INPUT_SDL_DRIVER_H
+#define MANGLE_INPUT_SDL_DRIVER_H
+
+#include "../driver.hpp"
+
+namespace Mangle
+{
+  namespace Input
+  {
+    /** Input driver for SDL. As the input system of SDL is seldomly
+        used alone (most often along with the video system), it is
+        assumed that you do your own initialization and cleanup of SDL
+        before and after using this driver.
+
+        The Event.event() calls will be given the proper EV_ type, the
+        key index (for key up/down events), and a pointer to the full
+        SDL_Event structure.
+     */
+    struct SDLDriver : Driver
+    {
+      void capture();
+      bool isDown(int index);
+      void showMouse(bool);
+    };
+  }
+}
+#endif

libs/mangle/input/tests/.gitignore

@@ -0,0 +1,2 @@
+*_test
+ogre.cfg

libs/mangle/input/tests/Makefile

@@ -0,0 +1,15 @@
+GCC=g++ -Wall
+
+all: sdl_driver_test ois_driver_test evtlist_test
+
+sdl_driver_test: sdl_driver_test.cpp
+	$(GCC) $< ../servers/sdl_driver.cpp -o $@ -I/usr/include/SDL/ -lSDL
+
+ois_driver_test: ois_driver_test.cpp
+	$(GCC) $< ../servers/ois_driver.cpp -o $@ -I/usr/local/include/OGRE/ -lOgreMain -lOIS -lboost_filesystem
+
+evtlist_test: evtlist_test.cpp ../filters/eventlist.hpp ../event.hpp
+	$(GCC) $< -o $@
+
+clean:
+	rm *_test

libs/mangle/input/tests/common.cpp

@@ -0,0 +1,35 @@
+#include <iostream>
+#include "../driver.hpp"
+#include <unistd.h>
+using namespace std;
+using namespace Mangle::Input;
+
+Driver *input;
+
+struct MyCB : Event
+{
+  void event(Event::Type type, int i, const void *p)
+  {
+    cout << "got event: type=" << type << " index=" << i << endl;
+  }
+};
+
+void mainLoop(int argc, int quitKey)
+{
+  cout << "Hold the Q key to quit:\n";
+  input->setEvent(EventPtr(new MyCB));
+  while(!input->isDown(quitKey))
+    {
+      input->capture();
+      usleep(20000);
+
+      if(argc == 1)
+        {
+          cout << "You are running in script mode, aborting. Run this test with a parameter (any at all) to test the input loop properly\n";
+          break;
+        }
+    }
+
+  delete input;
+  cout << "\nBye bye!\n";
+}

libs/mangle/input/tests/evtlist_test.cpp

@@ -0,0 +1,45 @@
+#include <iostream>
+#include "../filters/eventlist.hpp"
+
+using namespace std;
+using namespace Mangle::Input;
+
+struct MyEvent : Event
+{
+  int ii;
+  MyEvent(int i) : ii(i) {}
+
+  void event(Event::Type type, int i, const void *p)
+  {
+    cout << "  #" << ii << " got event: type=" << type << " index=" << i << endl;
+  }
+};
+
+EventList lst;
+
+int iii=1;
+void make(int flags)
+{
+  lst.add(EventPtr(new MyEvent(iii++)), flags);
+}
+
+void send(Event::Type type)
+{
+  cout << "Sending type " << type << endl;
+  lst.event(type,0,NULL);
+}
+
+int main()
+{
+  make(Event::EV_ALL);
+  make(Event::EV_KeyDown);
+  make(Event::EV_KeyUp | Event::EV_MouseDown);
+
+  send(Event::EV_Unknown);
+  send(Event::EV_KeyDown);
+  send(Event::EV_KeyUp);
+  send(Event::EV_MouseDown);
+
+  cout << "Enough of that\n";
+  return 0;
+}

libs/mangle/input/tests/ois_driver_test.cpp

@@ -0,0 +1,51 @@
+#include "common.cpp"
+
+#include "../servers/ois_driver.hpp"
+#include <Ogre.h>
+#include <OIS/OIS.h>
+#include <boost/filesystem.hpp>
+
+bool isFile(const char *name)
+{
+  boost::filesystem::path cfg_file_path(name);
+  return boost::filesystem::exists(cfg_file_path);
+}
+
+using namespace Ogre;
+using namespace OIS;
+
+Root *root;
+RenderWindow *window;
+
+void setupOgre()
+{
+  // Disable logging
+  new LogManager;
+  Log *log = LogManager::getSingleton().createLog("");
+  log->setDebugOutputEnabled(false);
+
+  bool useConfig = isFile("ogre.cfg");
+
+  // Set up Root
+  root = new Root("plugins.cfg", "ogre.cfg", "");
+
+  // Configure
+  if(!useConfig)
+    root->showConfigDialog();
+  else
+    root->restoreConfig();
+
+  // Initialize OGRE window
+  window = root->initialise(true, "test", "");
+}
+
+int main(int argc, char** argv)
+{
+  setupOgre();
+  input = new OISDriver(window);
+
+  mainLoop(argc, KC_Q);
+
+  delete root;
+  return 0;
+}

libs/mangle/input/tests/output/evtlist_test.out

@@ -0,0 +1,12 @@
+Sending type 1
+  #1 got event: type=1 index=0
+Sending type 2
+  #1 got event: type=2 index=0
+  #2 got event: type=2 index=0
+Sending type 4
+  #1 got event: type=4 index=0
+  #3 got event: type=4 index=0
+Sending type 16
+  #1 got event: type=16 index=0
+  #3 got event: type=16 index=0
+Enough of that

libs/mangle/input/tests/output/ois_driver_test.out

@@ -0,0 +1,5 @@
+Hold the Q key to quit:
+got event: type=8 index=-1
+You are running in script mode, aborting. Run this test with a parameter (any at all) to test the input loop properly
+
+Bye bye!

libs/mangle/input/tests/output/sdl_driver_test.out

@@ -0,0 +1,5 @@
+Hold the Q key to quit:
+got event: type=1 index=-1
+You are running in script mode, aborting. Run this test with a parameter (any at all) to test the input loop properly
+
+Bye bye!

libs/mangle/input/tests/plugins.cfg

@@ -0,0 +1,12 @@
+# Defines plugins to load
+
+# Define plugin folder
+PluginFolder=/usr/local/lib/OGRE/
+
+# Define plugins
+Plugin=RenderSystem_GL
+Plugin=Plugin_ParticleFX
+Plugin=Plugin_OctreeSceneManager
+# Plugin=Plugin_CgProgramManager
+
+

libs/mangle/input/tests/sdl_driver_test.cpp

@@ -0,0 +1,16 @@
+#include "common.cpp"
+
+#include "../servers/sdl_driver.hpp"
+#include <SDL.h>
+
+int main(int argc, char** argv)
+{
+  SDL_Init(SDL_INIT_VIDEO);
+  SDL_SetVideoMode(640, 480, 0, SDL_SWSURFACE);
+  input = new SDLDriver();
+
+  mainLoop(argc, SDLK_q);
+
+  SDL_Quit();
+  return 0;
+}

libs/mangle/input/tests/test.sh

@@ -0,0 +1,18 @@
+#!/bin/bash
+
+make || exit
+
+mkdir -p output
+
+PROGS=*_test
+
+for a in $PROGS; do
+    if [ -f "output/$a.out" ]; then
+        echo "Running $a:"
+        ./$a | diff output/$a.out -
+    else
+        echo "Creating $a.out"
+        ./$a > "output/$a.out"
+        git add "output/$a.out"
+    fi
+done

libs/mangle/rend2d/driver.hpp

@@ -0,0 +1,63 @@
+#ifndef MANGLE_REND2D_DRIVER_H
+#define MANGLE_REND2D_DRIVER_H
+
+#include <string>
+#include "sprite.hpp"
+
+namespace Mangle
+{
+  namespace Rend2D
+  {
+    /**
+       The driver is the connection to the backend system that powers
+       2D sprite rendering. For example the backend could be SDL or
+       any other 2D-capable graphics library.
+    */
+    struct Driver
+    {
+      /// Get the screen sprite
+      virtual Sprite *getScreen() = 0;
+
+      /// Sets the video mode.
+      virtual void setVideoMode(int width, int height, int bpp=32, bool fullscreen=false) = 0;
+
+      /** Update the screen. Until this function is called, none of
+          the changes written to the screen sprite will be visible.
+      */
+      virtual void update() = 0;
+
+      /// Set the window title, as well as the title of the window
+      /// when "iconified"
+      virtual void setWindowTitle(const std::string &title,
+                                  const std::string &icon) = 0;
+
+      /// Set the window title
+      void setWindowTitle(const std::string &title) { setWindowTitle(title,title); }
+
+      /// Load sprite from an image file. Thows an exception on
+      /// failure.
+      virtual Sprite* loadImage(const std::string &file) = 0;
+
+      /// Load a sprite from an image file stored in memory. Throws
+      /// exception on failure.
+      virtual Sprite* loadImage(const void* data, size_t size) = 0;
+
+      /** @brief Set gamma value for all colors.
+
+          Note: Setting this in windowed mode will affect the ENTIRE
+          SCREEN!
+      */
+      virtual void setGamma(float gamma) = 0;
+
+      /// Set gamma individually for red, green, blue
+      virtual void setGamma(float red, float green, float blue) = 0;
+
+      /// Get screen width
+      virtual int width() = 0;
+
+      /// Get screen height
+      virtual int height() = 0;
+    };
+  }
+}
+#endif

libs/mangle/rend2d/servers/sdl_driver.cpp

@@ -0,0 +1,259 @@
+#include "sdl_driver.hpp"
+
+#include <SDL.h>
+#include <SDL_image.h>
+#include <stdexcept>
+#include <assert.h>
+
+using namespace Mangle::Rend2D;
+
+const SpriteData *SDL_Sprite::lock()
+{
+  // Make sure we aren't already locked
+  assert(!data.pixels);
+
+  // Lock the surface and set up the data structure
+  SDL_LockSurface(surface);
+
+  data.pixels = surface->pixels;
+  data.w = surface->w;
+  data.h = surface->h;
+  data.pitch = surface->pitch;
+  data.bypp = surface->format->BytesPerPixel;
+
+  return &data;
+}
+
+void SDL_Sprite::unlock()
+{
+  if(data.pixels)
+    {
+      SDL_UnlockSurface(surface);
+      data.pixels = NULL;
+    }
+}
+
+// This is a really crappy and slow implementation, only intended for
+// testing purposes. Use lock/unlock for faster pixel drawing.
+void SDL_Sprite::pixel(int x, int y, int color)
+{
+  SDL_LockSurface(surface);
+
+  int bpp = surface->format->BytesPerPixel;
+  char *p = (char*)surface->pixels + y*surface->pitch + x*bpp;
+
+  switch(bpp)
+    {
+    case 1: *p = color; break;
+    case 3:
+        if(SDL_BYTEORDER == SDL_BIG_ENDIAN)
+          {
+            p[0] = (color >> 16) & 0xff;
+            p[1] = (color >> 8) & 0xff;
+            p[2] = color & 0xff;
+          }
+        else
+          {
+            p[0] = color & 0xff;
+            p[1] = (color >> 8) & 0xff;
+            p[2] = (color >> 16) & 0xff;
+          }
+        break;
+    case 4:
+        *(int*)p = color;
+        break;
+    }
+  SDL_UnlockSurface(surface);
+}
+
+void SDL_Sprite::draw(Sprite *s,                // Must be SDL_Sprite
+                      int x, int y,             // Destination position
+                      int sx, int sy,           // Source position
+                      int w, int h              // Amount to draw. -1 means remainder.
+                      )
+{
+  // Get source surface
+  SDL_Sprite *other = dynamic_cast<SDL_Sprite*>(s);
+  assert(other != NULL);
+  SDL_Surface *img = other->getSurface();
+
+  // Check coordinate validity
+  assert(sx <= img->w     && sy <= img->h);
+  assert(x  <= surface->w && y  <= surface->h);
+  assert(sx >= 0 && sy >= 0);
+
+  // Compute width and height if necessary
+  if(w == -1) w = img->w - sx;
+  if(h == -1) h = img->h - sy;
+
+  // Check them if they're valid
+  assert(w >= 0 && w <= img->w);
+  assert(h >= 0 && h <= img->h);
+
+  SDL_Rect dest;
+  dest.x = x;
+  dest.y = y;
+  dest.w = w;
+  dest.h = h;
+
+  SDL_Rect src;
+  src.x = sx;
+  src.y = sy;
+  src.w = w;
+  src.h = h;
+
+  // Do the Blitman
+  SDL_BlitSurface(img, &src, surface, &dest);
+}
+
+SDL_Sprite::SDL_Sprite(SDL_Surface *s, bool autoDelete)
+  : surface(s), autoDel(autoDelete)
+{
+  assert(surface != NULL);
+  data.pixels = NULL;
+}
+
+SDL_Sprite::~SDL_Sprite()
+{
+  if(autoDel)
+    SDL_FreeSurface(surface);
+}
+
+void SDL_Sprite::fill(int value)
+{
+  SDL_FillRect(surface, NULL, value);
+}
+
+int SDL_Sprite::width()  { return surface->w; }
+int SDL_Sprite::height() { return surface->h; }
+
+SDLDriver::SDLDriver() : display(NULL), realDisp(NULL), softDouble(false)
+{
+  if (SDL_InitSubSystem( SDL_INIT_VIDEO ) == -1)
+    throw std::runtime_error("Error initializing SDL video");
+}
+SDLDriver::~SDLDriver()
+{
+  if(display) delete display;
+  SDL_Quit();
+}
+
+void SDLDriver::setVideoMode(int width, int height, int bpp, bool fullscreen)
+{
+  unsigned int flags;
+
+  if(display) delete display;
+
+  if (fullscreen)
+    // Assume fullscreen mode allows a double-bufferd hardware
+    // mode. We need more test code for this to be safe though.
+    flags = SDL_FULLSCREEN | SDL_HWSURFACE | SDL_DOUBLEBUF;
+  else
+    flags = SDL_SWSURFACE;
+
+  // Create the surface and check it
+  realDisp = SDL_SetVideoMode(width, height, bpp, flags);
+  if(realDisp == NULL)
+    throw std::runtime_error("Failed setting SDL video mode");
+
+  // Code for software double buffering. I haven't found this to be
+  // any speed advantage at all in windowed mode (it's slower, as one
+  // would expect.) Not properly tested in fullscreen mode with
+  // hardware buffers, but it will probably only be an improvement if
+  // we do excessive writing (ie. write each pixel on average more
+  // than once) or try to read from the display buffer.
+  if(softDouble)
+    {
+      // Make a new surface with the same attributes as the real
+      // display surface.
+      SDL_Surface *back = SDL_DisplayFormat(realDisp);
+      assert(back != NULL);
+
+      // Create a sprite representing the double buffer
+      display = new SDL_Sprite(back);
+    }
+  else
+    {
+      // Create a sprite directly representing the display surface.
+      // The 'false' parameter means do not autodelete the screen
+      // surface upon exit (since SDL manages it)
+      display = new SDL_Sprite(realDisp, false);
+    }
+}
+
+/// Update the screen
+void SDLDriver::update()
+{
+  // Blit the soft double buffer onto the real display buffer
+  if(softDouble)
+    SDL_BlitSurface(display->getSurface(), NULL, realDisp, NULL );
+
+  if(realDisp)
+    SDL_Flip(realDisp);
+}
+
+/// Set the window title, as well as the title of the window when
+/// "iconified"
+void SDLDriver::setWindowTitle(const std::string &title,
+                               const std::string &icon)
+{
+  SDL_WM_SetCaption( title.c_str(), icon.c_str() );
+}
+
+// Convert the given surface to display format.
+static SDL_Surface* convertImage(SDL_Surface* surf)
+{
+  if(surf != NULL)
+    {
+      // Convert the image to the display buffer format, for faster
+      // blitting
+      SDL_Surface *surf2 = SDL_DisplayFormat(surf);
+      SDL_FreeSurface(surf);
+      surf = surf2;
+    }
+  return surf;
+}
+
+/// Load sprite from an image file, using SDL_image.
+Sprite* SDLDriver::loadImage(const std::string &file)
+{
+  SDL_Surface *surf = IMG_Load(file.c_str());
+  surf = convertImage(surf);
+  if(surf == NULL)
+    throw std::runtime_error("SDL failed to load image file '" + file + "'");
+  return spriteFromSDL(surf);
+}
+
+/// Load sprite from an SDL_RWops structure. autoFree determines
+/// whether the RWops struct should be closed/freed after use.
+Sprite* SDLDriver::loadImage(SDL_RWops *src, bool autoFree)
+{
+  SDL_Surface *surf = IMG_Load_RW(src, autoFree);
+  surf = convertImage(surf);
+  if(surf == NULL)
+    throw std::runtime_error("SDL failed to load image");
+  return spriteFromSDL(surf);
+}
+
+/// Load a sprite from an image file stored in memory. Uses
+/// SDL_image.
+Sprite* SDLDriver::loadImage(const void* data, size_t size)
+{
+  SDL_RWops *rw = SDL_RWFromConstMem(data, size);
+  return loadImage(rw, true);
+}
+
+void SDLDriver::setGamma(float red, float green, float blue)
+{
+  SDL_SetGamma(red,green,blue);
+}
+
+/// Convert an existing SDL surface into a sprite
+Sprite* SDLDriver::spriteFromSDL(SDL_Surface *surf, bool autoFree)
+{
+  assert(surf);
+  return new SDL_Sprite(surf, autoFree);
+}
+
+void SDLDriver::sleep(int ms) { SDL_Delay(ms); }
+unsigned int SDLDriver::ticks() { return SDL_GetTicks(); }

libs/mangle/rend2d/servers/sdl_driver.hpp

@@ -0,0 +1,125 @@
+#ifndef MANGLE_DRAW2D_SDL_H
+#define MANGLE_DRAW2D_SDL_H
+
+#include "../driver.hpp"
+
+// Predeclarations keep the streets safe at night
+struct SDL_Surface;
+struct SDL_RWops;
+
+namespace Mangle
+{
+  namespace Rend2D
+  {
+    /// SDL-implementation of Sprite
+    struct SDL_Sprite : Sprite
+    {
+      /** Draw a sprite in the given position. Can only draw other SDL
+          sprites.
+      */
+      void draw(Sprite *s,                // Must be SDL_Sprite
+                int x, int y,             // Destination position
+                int sx=0, int sy=0,       // Source position
+                int w=-1, int h=-1        // Amount to draw. -1 means remainder.
+                );
+
+      SDL_Sprite(SDL_Surface *s, bool autoDelete=true);
+      ~SDL_Sprite();
+
+      // Information retrieval
+      int width();
+      int height();
+      SDL_Surface *getSurface() { return surface; }
+
+      // Fill with a given pixel value
+      void fill(int value);
+
+      // Set one pixel
+      void pixel(int x, int y, int value);
+
+      const SpriteData *lock();
+      void unlock();
+
+    private:
+      // The SDL surface
+      SDL_Surface* surface;
+
+      // Used for locking
+      SpriteData data;
+
+      // If true, delete this surface when the canvas is destructed
+      bool autoDel;
+    };
+
+    class SDLDriver : public Driver
+    {
+      // The main display surface
+      SDL_Sprite *display;
+
+      // The actual display surface. May or may not be the same
+      // surface pointed to by 'display' above, depending on the
+      // softDouble flag.
+      SDL_Surface *realDisp;
+
+      // If true, we do software double buffering.
+      bool softDouble;
+
+    public:
+      SDLDriver();
+      ~SDLDriver();
+
+      /// Sets the video mode. Will create the window if it is not
+      /// already set up. Note that for SDL, bpp=0 means use current
+      /// bpp.
+      void setVideoMode(int width, int height, int bpp=0, bool fullscreen=false);
+
+      /// Update the screen
+      void update();
+
+      /// Set the window title, as well as the title of the window
+      /// when "iconified"
+      void setWindowTitle(const std::string &title,
+                          const std::string &icon);
+
+      // Include overloads from our Glorious parent
+      using Driver::setWindowTitle;
+
+      /// Load sprite from an image file, using SDL_image.
+      Sprite* loadImage(const std::string &file);
+
+      /// Load sprite from an SDL_RWops structure. autoFree determines
+      /// whether the RWops struct should be closed/freed after use.
+      Sprite* loadImage(SDL_RWops *src, bool autoFree=false);
+
+      /// Load a sprite from an image file stored in memory. Uses
+      /// SDL_image.
+      Sprite* loadImage(const void* data, size_t size);
+
+      /// Set gamma value
+      void setGamma(float gamma) { setGamma(gamma,gamma,gamma); }
+
+      /// Set gamma individually for red, green, blue
+      void setGamma(float red, float green, float blue);
+
+      /// Convert an existing SDL surface into a sprite
+      Sprite* spriteFromSDL(SDL_Surface *surf, bool autoFree = true);
+
+      // Get width and height
+      int width()  { return display ? display->width()  : 0; }
+      int height() { return display ? display->height() : 0; }
+
+      /// Get the screen sprite
+      Sprite *getScreen() { return display; }
+
+      /// Not really a graphic-related function, but very
+      /// handly. Sleeps the given number of milliseconds using
+      /// SDL_Delay().
+      void sleep(int ms);
+
+      /// Get the number of ticks since SDL initialization, using
+      /// SDL_GetTicks().
+      unsigned int ticks();
+    };
+  }
+}
+#endif

libs/mangle/rend2d/servers/sdl_gl_driver.cpp

@@ -0,0 +1,311 @@
+#include "sdl_gl_driver.hpp"
+
+#include <SDL.h>
+#include <SDL_image.h>
+#include <SDL_opengl.h>
+#include <stdexcept>
+#include <assert.h>
+
+using namespace Mangle::Rend2D;
+
+void SDLGL_Sprite::draw(Sprite *s,              // Must be SDLGL_Sprite
+                      int x, int y,             // Destination position
+                      int sx, int sy,           // Source position
+                      int w, int h              // Amount to draw. -1 means remainder.
+                      )
+{
+  // Get source surface
+  SDLGL_Sprite *other = dynamic_cast<SDLGL_Sprite*>(s);
+  assert(other != NULL);
+  SDL_Surface *img = other->getSurface();
+
+  // Check coordinate validity
+  assert(sx <= img->w     && sy <= img->h);
+  assert(x  <= surface->w && y  <= surface->h);
+  assert(sx >= 0 && sy >= 0);
+
+  // Compute width and height if necessary
+  if(w == -1) w = img->w - sx;
+  if(h == -1) h = img->h - sy;
+
+  // Check them if they're valid
+  assert(w >= 0 && w <= img->w);
+  assert(h >= 0 && h <= img->h);
+
+  SDL_Rect dest;
+  dest.x = x;
+  dest.y = y;
+  dest.w = w;
+  dest.h = h;
+
+  SDL_Rect src;
+  src.x = sx;
+  src.y = sy;
+  src.w = w;
+  src.h = h;
+
+  // Do the Blitman
+  SDL_BlitSurface(img, &src, surface, &dest);
+}
+
+SDLGL_Sprite::SDLGL_Sprite(SDL_Surface *s, bool autoDelete)
+  : surface(s), autoDel(autoDelete)
+{
+  assert(surface != NULL);
+}
+
+SDLGL_Sprite::~SDLGL_Sprite()
+{
+  if(autoDel)
+    SDL_FreeSurface(surface);
+}
+
+void SDLGL_Sprite::fill(int value)
+{
+  SDL_FillRect(surface, NULL, value);
+}
+
+int SDLGL_Sprite::width()  { return surface->w; }
+int SDLGL_Sprite::height() { return surface->h; }
+
+SDLGLDriver::SDLGLDriver() : display(NULL), realDisp(NULL)
+{
+  if (SDL_InitSubSystem( SDL_INIT_VIDEO ) == -1)
+    throw std::runtime_error("Error initializing SDL video");
+}
+SDLGLDriver::~SDLGLDriver()
+{
+  if(display) delete display;
+  SDL_Quit();
+}
+
+// Surface used for the screen. Since OpenGL surfaces must have sizes
+// that are powers of 2, we have to "fake" the returned display size
+// to match the screen, not the surface itself. If we don't use this,
+// the client program will get confused about the actual size of our
+// screen, thinking it is bigger than it is.
+struct FakeSizeSprite : SDLGL_Sprite
+{
+  int fakeW, fakeH;
+
+  FakeSizeSprite(SDL_Surface *s, int fw, int fh)
+    : SDLGL_Sprite(s), fakeW(fw), fakeH(fh)
+  {}
+
+  int width() { return fakeW; }
+  int height() { return fakeH; }
+};
+
+static int makePow2(int num)
+{
+  assert(num);
+  if((num & (num-1)) != 0)
+    {
+      int cnt = 0;
+      while(num)
+        {
+          num >>= 1;
+          cnt++;
+        }
+      num = 1 << cnt;
+    }
+  return num;
+}
+
+void SDLGLDriver::setVideoMode(int width, int height, int bpp, bool fullscreen)
+{
+  unsigned int flags;
+
+  if(display) delete display;
+
+  flags = SDL_OPENGL;
+
+  if (fullscreen)
+    flags |= SDL_FULLSCREEN;
+
+  SDL_GL_SetAttribute( SDL_GL_DOUBLEBUFFER, 1 );
+  SDL_GL_SetAttribute( SDL_GL_SWAP_CONTROL, 1 );
+
+  // Create the surface and check it
+  screen = SDL_SetVideoMode(width, height, bpp, flags);
+  if(screen == NULL)
+    throw std::runtime_error("Failed setting SDL video mode");
+
+  // Expand width and height to be powers of 2
+  int width2 = makePow2(width);
+  int height2 = makePow2(height);
+
+  // Create a new SDL surface of this size
+  const SDL_PixelFormat& fmt = *(screen->format);
+  realDisp = SDL_CreateRGBSurface(SDL_SWSURFACE,width2,height2,
+                                  fmt.BitsPerPixel,
+                                  fmt.Rmask,fmt.Gmask,fmt.Bmask,fmt.Amask);
+
+  // Create a sprite directly representing the display surface. This
+  // allows the user to blit to it directly.
+  display = new FakeSizeSprite(realDisp, width, height);
+
+  // Set up the OpenGL format
+  nOfColors = fmt.BytesPerPixel;
+
+  if(nOfColors == 4)
+    {
+      if (fmt.Rmask == 0x000000ff)
+        texture_format = GL_RGBA;
+      else
+        texture_format = GL_BGRA;
+    }
+  else if(nOfColors == 3)
+    {
+      if (fmt.Rmask == 0x000000ff)
+        texture_format = GL_RGB;
+      else
+        texture_format = GL_BGR;
+    }
+  else
+    assert(0 && "unsupported screen format");
+
+  glEnable(GL_TEXTURE_2D);
+
+  // Have OpenGL generate a texture object handle for us
+  glGenTextures( 1, &texture );
+
+  // Bind the texture object
+  glBindTexture( GL_TEXTURE_2D, texture );
+
+  // Set the texture's stretching properties
+  glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR );
+  glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR );
+}
+
+void SDLGLDriver::updateNoSwap()
+{
+  if(!realDisp) return;
+
+  // Fist, set up the screen texture:
+
+  // Bind the texture object
+  glBindTexture( GL_TEXTURE_2D, texture );
+
+  // Edit the texture object's image data
+  glTexImage2D( GL_TEXTURE_2D, 0, nOfColors, realDisp->w, realDisp->h, 0,
+                texture_format, GL_UNSIGNED_BYTE, realDisp->pixels );
+
+  glClear(GL_COLOR_BUFFER_BIT| GL_DEPTH_BUFFER_BIT);
+  glLoadIdentity();
+
+  // OpenGL barf. Set up the projection to match our screen
+  int vPort[4];
+  glGetIntegerv(GL_VIEWPORT, vPort);
+  glMatrixMode(GL_PROJECTION);
+  glPushMatrix();
+  glLoadIdentity();
+  glOrtho(0, vPort[2], 0, vPort[3], -1, 1);
+  glMatrixMode(GL_MODELVIEW);
+  glPushMatrix();
+  glLoadIdentity();
+
+  glBegin( GL_QUADS );
+
+  // Needed to move the screen into the right place
+  int diff = screen->h - realDisp->h;
+
+  // Bottom-left vertex (corner)
+  glTexCoord2i( 0, 1 );
+  glVertex3f(0,diff,0);
+
+  // Bottom-right vertex (corner)
+  glTexCoord2i( 1, 1 );
+  glVertex3f( realDisp->w, diff, 0.f );
+
+  // Top-right vertex (corner)
+  glTexCoord2i( 1, 0 );
+  glVertex3f( realDisp->w, screen->h, 0.f );
+
+  // Top-left vertex (corner)
+  glTexCoord2i( 0, 0 );
+  glVertex3f( 0, screen->h, 0.f );
+  glEnd();
+
+  glMatrixMode(GL_PROJECTION);
+  glPopMatrix();
+  glMatrixMode(GL_MODELVIEW);
+  glPopMatrix();
+}
+
+void SDLGLDriver::swap()
+{
+  SDL_GL_SwapBuffers();
+}
+
+void SDLGLDriver::update()
+{
+  updateNoSwap();
+  swap();
+}
+
+/// Set the window title, as well as the title of the window when
+/// "iconified"
+void SDLGLDriver::setWindowTitle(const std::string &title,
+                               const std::string &icon)
+{
+  SDL_WM_SetCaption( title.c_str(), icon.c_str() );
+}
+
+// Convert the given surface to display format.
+static SDL_Surface* convertImage(SDL_Surface* surf)
+{
+  if(surf != NULL)
+    {
+      // Convert the image to the display buffer format, for faster
+      // blitting
+      SDL_Surface *surf2 = SDL_DisplayFormat(surf);
+      SDL_FreeSurface(surf);
+      surf = surf2;
+    }
+  return surf;
+}
+
+/// Load sprite from an image file, using SDL_image.
+Sprite* SDLGLDriver::loadImage(const std::string &file)
+{
+  SDL_Surface *surf = IMG_Load(file.c_str());
+  surf = convertImage(surf);
+  if(surf == NULL)
+    throw std::runtime_error("SDL failed to load image file '" + file + "'");
+  return spriteFromSDL(surf);
+}
+
+/// Load sprite from an SDL_RWops structure. autoFree determines
+/// whether the RWops struct should be closed/freed after use.
+Sprite* SDLGLDriver::loadImage(SDL_RWops *src, bool autoFree)
+{
+  SDL_Surface *surf = IMG_Load_RW(src, autoFree);
+  surf = convertImage(surf);
+  if(surf == NULL)
+    throw std::runtime_error("SDL failed to load image");
+  return spriteFromSDL(surf);
+}
+
+/// Load a sprite from an image file stored in memory. Uses
+/// SDL_image.
+Sprite* SDLGLDriver::loadImage(const void* data, size_t size)
+{
+  SDL_RWops *rw = SDL_RWFromConstMem(data, size);
+  return loadImage(rw, true);
+}
+
+void SDLGLDriver::setGamma(float red, float green, float blue)
+{
+  SDL_SetGamma(red,green,blue);
+}
+
+/// Convert an existing SDL surface into a sprite
+Sprite* SDLGLDriver::spriteFromSDL(SDL_Surface *surf, bool autoFree)
+{
+  assert(surf);
+  return new SDLGL_Sprite(surf, autoFree);
+}
+
+void SDLGLDriver::sleep(int ms) { SDL_Delay(ms); }
+unsigned int SDLGLDriver::ticks() { return SDL_GetTicks(); }

libs/mangle/rend2d/servers/sdl_gl_driver.hpp

@@ -0,0 +1,132 @@
+#ifndef MANGLE_DRAW2D_SDLGL_H
+#define MANGLE_DRAW2D_SDLGL_H
+
+/** This driver is similar to SDLDriver, except that it uses SDL on
+    top of OpenGL.
+
+    I've decided to make it a separate file instead of just adding
+    optional OpenGL support to the original, so that pure SDL users
+    don't have to add OpenGL as a dependency.
+ */
+
+#include "../driver.hpp"
+
+// Predeclarations keep the streets safe at night
+struct SDL_Surface;
+struct SDL_RWops;
+
+namespace Mangle
+{
+  namespace Rend2D
+  {
+    /// SDL-implementation of Sprite
+    struct SDLGL_Sprite : Sprite
+    {
+      /** Draw a sprite in the given position. Can only draw other SDL
+          sprites.
+      */
+      void draw(Sprite *s,                // Must be SDLGL_Sprite
+                int x, int y,             // Destination position
+                int sx=0, int sy=0,       // Source position
+                int w=-1, int h=-1        // Amount to draw. -1 means remainder.
+                );
+
+      SDLGL_Sprite(SDL_Surface *s, bool autoDelete=true);
+      ~SDLGL_Sprite();
+
+      // Information retrieval
+      virtual int width();
+      virtual int height();
+      SDL_Surface *getSurface() { return surface; }
+
+      // Fill with a given pixel value
+      void fill(int value);
+
+    private:
+      // The SDL surface
+      SDL_Surface* surface;
+
+      // If true, delete this surface when the canvas is destructed
+      bool autoDel;
+    };
+
+    class SDLGLDriver : public Driver
+    {
+      // The main display surface
+      SDLGL_Sprite *display;
+
+      // The screen surface. This is completely unused.
+      SDL_Surface *screen;
+
+      // The display surface and main GL texture. These are used when
+      // drawing the entire screen as one surface, as a drop-in
+      // replacement for SDLDriver.
+      SDL_Surface *realDisp;
+      unsigned int texture;
+      int nOfColors, texture_format;
+
+    public:
+      SDLGLDriver();
+      ~SDLGLDriver();
+
+      /// Sets the video mode. Will create the window if it is not
+      /// already set up. Note that for SDL, bpp=0 means use current
+      /// bpp.
+      void setVideoMode(int width, int height, int bpp=0, bool fullscreen=false);
+
+      /// Update the screen
+      void update();
+
+      /// Calls SDL_GL_SwapBuffers
+      void swap();
+
+      /// Draw surface to screen but do not call SDL_GL_SwapBuffers()
+      void updateNoSwap();
+
+      /// Set the window title, as well as the title of the window
+      /// when "iconified"
+      void setWindowTitle(const std::string &title,
+                          const std::string &icon);
+
+      // Include overloads from our Glorious parent
+      using Driver::setWindowTitle;
+
+      /// Load sprite from an image file, using SDL_image.
+      Sprite* loadImage(const std::string &file);
+
+      /// Load sprite from an SDL_RWops structure. autoFree determines
+      /// whether the RWops struct should be closed/freed after use.
+      Sprite* loadImage(SDL_RWops *src, bool autoFree=false);
+
+      /// Load a sprite from an image file stored in memory. Uses
+      /// SDL_image.
+      Sprite* loadImage(const void* data, size_t size);
+
+      /// Set gamma value
+      void setGamma(float gamma) { setGamma(gamma,gamma,gamma); }
+
+      /// Set gamma individually for red, green, blue
+      void setGamma(float red, float green, float blue);
+
+      /// Convert an existing SDL surface into a sprite
+      Sprite* spriteFromSDL(SDL_Surface *surf, bool autoFree = true);
+
+      // Get width and height
+      int width()  { return display ? display->width()  : 0; }
+      int height() { return display ? display->height() : 0; }
+
+      /// Get the screen sprite
+      Sprite *getScreen() { return display; }
+
+      /// Not really a graphic-related function, but very
+      /// handly. Sleeps the given number of milliseconds using
+      /// SDL_Delay().
+      void sleep(int ms);
+
+      /// Get the number of ticks since SDL initialization, using
+      /// SDL_GetTicks().
+      unsigned int ticks();
+    };
+  }
+}
+#endif

libs/mangle/rend2d/sprite.hpp

@@ -0,0 +1,57 @@
+#ifndef MANGLE_REND2D_SPRITE_H
+#define MANGLE_REND2D_SPRITE_H
+
+namespace Mangle
+{
+  namespace Rend2D
+  {
+    /**
+       A pointer to sprite data for direct drawing. Only to be used
+       while the corresponding sprite is locked.
+     */
+    struct SpriteData
+    {
+      void *pixels;     // Pixel data
+      int w, h;         // Width and height
+      int pitch, bypp;  // Pitch (bytes) and bytes per pixel
+    };
+
+    /**
+       A Sprite is either a bitmap to be drawn or an output of area
+       for blitting other bitmaps, or both. They are created by the
+       Driver.
+    */
+    struct Sprite
+    {
+      /// Draw a sprite in the given position
+      virtual void draw(Sprite *s,                // The sprite to draw
+                        int x, int y,             // Destination position
+                        int sx=0, int sy=0,       // Source position
+                        int w=-1, int h=-1        // Amount to draw. -1 means remainder.
+                        ) = 0;
+
+      virtual ~Sprite() {}
+
+      // Information retrieval
+      virtual int width() = 0;
+      virtual int height() = 0;
+
+      /// Fill the sprite with the given pixel value. The pixel format
+      /// depends on the format of the sprite.
+      virtual void fill(int value) = 0;
+
+      /// Set one pixel value. The pixel format depends on the sprite
+      /// format. This is not expected to be fast, and in some
+      /// implementations may not work at all.
+      virtual void pixel(int x, int y, int value) {}
+
+      /// Lock sprite for direct drawing, and return a struct
+      /// containing the necessary pointer.  When finished, unlock the
+      /// sprite with unlock(). May return NULL, if so then direct
+      /// drawing is not possible.
+      virtual const SpriteData *lock() { return NULL; }
+      virtual void unlock() {}
+    };
+  }
+}
+#endif

libs/mangle/rend2d/tests/.gitignore

@@ -0,0 +1 @@
+*_test

libs/mangle/rend2d/tests/Makefile

@@ -0,0 +1,15 @@
+GCC=g++ -Wall -Werror
+
+all: sdl_test sdl_move_test sdlgl_move_test
+
+sdl_test: sdl_test.cpp
+	$(GCC) $< ../servers/sdl_driver.cpp -o $@ -I/usr/include/SDL/ -lSDL -lSDL_image
+
+sdl_move_test: sdl_move_test.cpp ../servers/sdl_driver.cpp
+	$(GCC) $^ -o $@ -I/usr/include/SDL/ -lSDL -lSDL_image
+
+sdlgl_move_test: sdlgl_move_test.cpp ../servers/sdl_gl_driver.cpp
+	$(GCC) $^ -o $@ -I/usr/include/SDL/ -lSDL -lSDL_image -lGL
+
+clean:
+	rm *_test

libs/mangle/rend2d/tests/output/sdl_test.out

@@ -0,0 +1,11 @@
+Loading SDL driver.
+Creating window.
+Current mode: 640x480
+Setting fancy title, cause we like fancy titles.
+Loading tile1-blue.png from file.
+Loading tile1-yellow.png from memory.
+Going bananas.
+Taking a breather.
+WOW DID YOU SEE THAT!?
+Mucking about with the gamma settings
+Done.

libs/mangle/rend2d/tests/sdl_move_test.cpp

@@ -0,0 +1,30 @@
+#include <iostream>
+#include <fstream>
+
+using namespace std;
+
+#include "../servers/sdl_driver.hpp"
+
+using namespace Mangle::Rend2D;
+
+int main()
+{
+  SDLDriver sdl;
+
+  sdl.setVideoMode(640,480,0,false);
+  sdl.setWindowTitle("Testing 123");
+  Sprite *screen = sdl.getScreen();
+  const char* imgName = "tile1-blue.png";
+  Sprite *image = sdl.loadImage(imgName);
+
+  for(int frames=0; frames<170; frames++)
+    {
+      screen->fill(0);
+      for(int j=0; j<10; j++)
+        for(int i=0; i<25; i++)
+          screen->draw(image, 2*frames+30*j, 20*i);
+      sdl.update();
+      sdl.sleep(10);
+    }
+  return 0;
+}

libs/mangle/rend2d/tests/sdl_test.cpp

@@ -0,0 +1,65 @@
+#include <iostream>
+#include <fstream>
+
+using namespace std;
+
+#include "../servers/sdl_driver.hpp"
+
+using namespace Mangle::Rend2D;
+
+int main()
+{
+  cout << "Loading SDL driver.\n";
+  SDLDriver sdl;
+
+  cout << "Creating window.\n";
+  sdl.setVideoMode(640,480);
+  cout << "Current mode: " << sdl.width() << "x" << sdl.height() << endl;
+
+  cout << "Setting fancy title, cause we like fancy titles.\n";
+  sdl.setWindowTitle("Chief executive window");
+
+  // Display surface
+  Sprite *screen = sdl.getScreen();
+
+  const char* imgName = "tile1-blue.png";
+  cout << "Loading " << imgName << " from file.\n";
+  Sprite *image = sdl.loadImage(imgName);
+
+  const char* imgName2 = "tile1-yellow.png";
+  cout << "Loading " << imgName2 << " from memory.\n";
+  Sprite *image2;
+  {
+    // This is hard-coded for file sizes below 500 bytes, so obviously
+    // you shouldn't mess with the image files.
+    ifstream file(imgName2, ios::binary);
+    char buf[500];
+    file.read(buf, 500);
+    int size = file.gcount();
+    image2 = sdl.loadImage(buf, size);
+  }
+
+  cout << "Going bananas.\n";
+  for(int i=1; i<20; i++)
+    screen->draw(image, 30*i, 20*i);
+
+  cout << "Taking a breather.\n";
+  sdl.update();
+  for(int i=1; i<20; i++)
+    screen->draw(image2, 30*(20-i), 20*i);
+  sdl.sleep(800);
+  sdl.update();
+  cout << "WOW DID YOU SEE THAT!?\n";
+  sdl.sleep(800);
+
+  cout << "Mucking about with the gamma settings\n";
+  sdl.setGamma(2.0, 0.1, 0.8);
+  sdl.sleep(100);
+  sdl.setGamma(0.6, 2.1, 2.1);
+  sdl.sleep(100);
+  sdl.setGamma(1.6);
+  sdl.sleep(100);
+
+  cout << "Done.\n";
+  return 0;
+}

libs/mangle/rend2d/tests/sdlgl_move_test.cpp

@@ -0,0 +1,31 @@
+#include <iostream>
+#include <fstream>
+
+using namespace std;
+
+#include "../servers/sdl_gl_driver.hpp"
+
+using namespace Mangle::Rend2D;
+
+int main()
+{
+  SDLGLDriver sdl;
+
+  sdl.setVideoMode(640,480,0,false);
+  sdl.setWindowTitle("Testing 123");
+  Sprite *screen = sdl.getScreen();
+  const char* imgName = "tile1-blue.png";
+  Sprite *image = sdl.loadImage(imgName);
+
+  for(int frames=0; frames<170; frames++)
+    {
+      screen->fill(0);
+      for(int j=0; j<10; j++)
+        for(int i=0; i<25; i++)
+          screen->draw(image, 2*frames+30*j, 20*i);
+      sdl.update();
+      sdl.sleep(5);
+    }
+
+  return 0;
+}

libs/mangle/rend2d/tests/test.sh

@@ -0,0 +1,18 @@
+#!/bin/bash
+
+make || exit
+
+mkdir -p output
+
+PROGS=*_test
+
+for a in $PROGS; do
+    if [ -f "output/$a.out" ]; then
+        echo "Running $a:"
+        ./$a | diff output/$a.out -
+    else
+        echo "Creating $a.out"
+        ./$a > "output/$a.out"
+        git add "output/$a.out"
+    fi
+done

libs/mangle/sound/.gitignore

@@ -0,0 +1 @@
+

libs/mangle/sound/clients/ogre_listener_mover.hpp

@@ -0,0 +1,79 @@
+#ifndef MANGLE_SOUND_OGRELISTENERMOVER_H
+#define MANGLE_SOUND_OGRELISTENERMOVER_H
+
+#include <OgreCamera.h>
+#include <assert.h>
+#include "../output.hpp"
+
+namespace Mangle {
+namespace Sound {
+
+  /** This class lets a sound listener (ie. the SoundFactory) track a
+      given camera in Ogre3D. The position and orientation of the
+      listener will be updated to match the camera whenever the camera
+      is moved.
+   */
+  struct OgreListenerMover : Ogre::Camera::Listener
+  {
+    OgreListenerMover(Mangle::Sound::SoundFactoryPtr snd)
+      : soundFact(snd), camera(NULL)
+    {}
+
+    /// Follow a camera. WARNING: This will OVERRIDE any other
+    /// MovableObject::Listener you may have attached to the camera.
+    void followCamera(Ogre::Camera *cam)
+    {
+      camera = cam;
+      camera->addListener(this);
+    }
+
+    void unfollowCamera()
+    {
+        // If the camera is null, this object wasn't following a camera.
+        // It doesn't make sense to call unfollow
+        assert(camera != NULL);
+
+        camera->removeListener(this);
+        camera = NULL;
+    }
+
+  private:
+    Mangle::Sound::SoundFactoryPtr soundFact;
+    Ogre::Camera *camera;
+    Ogre::Vector3 pos, dir, up;
+
+    /// From Camera::Listener. This is called once per
+    /// frame. Unfortunately, Ogre doesn't allow us to be notified
+    /// only when the camera itself has moved, so we must poll every
+    /// frame.
+    void cameraPreRenderScene(Ogre::Camera *cam)
+    {
+      assert(cam == camera);
+
+      Ogre::Vector3 nPos, nDir, nUp;
+
+      nPos = camera->getPosition();
+      nDir = camera->getDirection();
+      nUp  = camera->getUp();
+
+      // Don't bother the sound system needlessly
+      if(nDir != dir || nPos != pos || nUp != up)
+        {
+          pos = nPos;
+          dir = nDir;
+          up  = nUp;
+
+          soundFact->setListenerPos(pos.x, pos.y, pos.z,
+                                    dir.x, dir.y, dir.z,
+                                    up.x, up.y, up.z);
+        }
+    }
+
+    void cameraDestroyed(Ogre::Camera *cam)
+    {
+      assert(cam == camera);
+      camera = NULL;
+    }
+  };
+}}
+#endif

libs/mangle/sound/clients/ogre_output_updater.hpp

@@ -0,0 +1,31 @@
+#ifndef MANGLE_SOUND_OGREUPDATER_H
+#define MANGLE_SOUND_OGREUPDATER_H
+
+/*
+  This Ogre FrameListener calls update on a SoundFactory
+ */
+
+#include <OgreFrameListener.h>
+#include "../output.hpp"
+#include <assert.h>
+
+namespace Mangle {
+namespace Sound {
+
+  struct OgreOutputUpdater : Ogre::FrameListener
+  {
+    Mangle::Sound::SoundFactoryPtr driver;
+
+    OgreOutputUpdater(Mangle::Sound::SoundFactoryPtr drv)
+      : driver(drv)
+    { assert(drv->needsUpdate); }
+
+    bool frameStarted(const Ogre::FrameEvent &evt)
+    {
+      driver->update();
+      return true;
+    }
+  };
+}}
+
+#endif

libs/mangle/sound/filters/input_filter.hpp

@@ -0,0 +1,68 @@
+#ifndef MANGLE_INPUT_FILTER_H
+#define MANGLE_INPUT_FILTER_H
+
+#include "../output.hpp"
+
+#include <assert.h>
+
+namespace Mangle {
+namespace Sound {
+
+/**
+   @brief This filter class adds file loading capabilities to a
+   Sound::SoundFactory class, by associating a SampleSourceLoader with
+   it.
+
+   The class takes an existing SoundFactory able to load streams, and
+   associates a SampleSourceLoader with it. The combined class is able
+   to load files directly.  */
+class InputFilter : public SoundFactory
+{
+ protected:
+  SoundFactoryPtr snd;
+  SampleSourceLoaderPtr inp;
+
+ public:
+  /// Empty constructor
+  InputFilter() {}
+
+  /// Assign an input manager and a sound manager to this object
+  InputFilter(SoundFactoryPtr _snd, SampleSourceLoaderPtr _inp)
+    { set(_snd, _inp); }
+
+  /// Assign an input manager and a sound manager to this object
+  void set(SoundFactoryPtr _snd, SampleSourceLoaderPtr _inp)
+  {
+    inp = _inp;
+    snd = _snd;
+
+    // Set capabilities
+    needsUpdate = snd->needsUpdate;
+    has3D = snd->has3D;
+    canLoadStream = inp->canLoadStream;
+
+    // Both these should be true, or the use of this class is pretty
+    // pointless
+    canLoadSource = snd->canLoadSource;
+    canLoadFile = inp->canLoadFile;
+    assert(canLoadSource && canLoadFile);
+  }
+
+  virtual SoundPtr load(const std::string &file)
+  { return loadRaw(inp->load(file)); }
+
+  virtual SoundPtr load(Stream::StreamPtr input)
+  { return loadRaw(inp->load(input)); }
+
+  virtual SoundPtr loadRaw(SampleSourcePtr input)
+  { return snd->loadRaw(input); }
+
+  virtual void update() { snd->update(); }
+  virtual void setListenerPos(float x, float y, float z,
+                              float fx, float fy, float fz,
+                              float ux, float uy, float uz)
+    { snd->setListenerPos(x,y,z,fx,fy,fz,ux,uy,uz); }
+};
+
+}}
+#endif

libs/mangle/sound/filters/openal_audiere.hpp

@@ -0,0 +1,24 @@
+#ifndef MANGLE_AUDIERE_OPENAL_H
+#define MANGLE_AUDIERE_OPENAL_H
+
+#include "input_filter.hpp"
+#include "../sources/audiere_source.hpp"
+#include "../outputs/openal_out.hpp"
+
+namespace Mangle {
+namespace Sound {
+
+/// A InputFilter that adds audiere decoding to OpenAL. Audiere has
+/// it's own output, but OpenAL sports 3D and other advanced features.
+class OpenAL_Audiere_Factory : public InputFilter
+{
+ public:
+  OpenAL_Audiere_Factory()
+    {
+      set(SoundFactoryPtr(new OpenAL_Factory),
+          SampleSourceLoaderPtr(new AudiereLoader));
+    }
+};
+
+}}
+#endif

libs/mangle/sound/filters/openal_ffmpeg.hpp

@@ -0,0 +1,23 @@
+#ifndef MANGLE_FFMPEG_OPENAL_H
+#define MANGLE_FFMPEG_OPENAL_H
+
+#include "input_filter.hpp"
+#include "../sources/ffmpeg_source.hpp"
+#include "../outputs/openal_out.hpp"
+
+namespace Mangle {
+namespace Sound {
+
+/// A InputFilter that adds ffmpeg decoding to OpenAL.
+class OpenAL_FFMpeg_Factory : public InputFilter
+{
+ public:
+  OpenAL_FFMpeg_Factory()
+    {
+      set(SoundFactoryPtr(new OpenAL_Factory),
+          SampleSourceLoaderPtr(new FFMpegLoader));
+    }
+};
+
+}}
+#endif

libs/mangle/sound/filters/openal_mpg123.hpp

@@ -0,0 +1,24 @@
+#ifndef MANGLE_MPG123_OPENAL_H
+#define MANGLE_MPG123_OPENAL_H
+
+#include "input_filter.hpp"
+#include "../sources/mpg123_source.hpp"
+#include "../outputs/openal_out.hpp"
+
+namespace Mangle {
+namespace Sound {
+
+/// A InputFilter that adds mpg123 decoding to OpenAL. Only supports
+/// MP3 files.
+class OpenAL_Mpg123_Factory : public InputFilter
+{
+ public:
+  OpenAL_Mpg123_Factory()
+    {
+      set(SoundFactoryPtr(new OpenAL_Factory),
+          SampleSourceLoaderPtr(new Mpg123Loader));
+    }
+};
+
+}}
+#endif

libs/mangle/sound/filters/openal_sndfile.hpp

@@ -0,0 +1,24 @@
+#ifndef MANGLE_SNDFILE_OPENAL_H
+#define MANGLE_SNDFILE_OPENAL_H
+
+#include "input_filter.hpp"
+#include "../sources/libsndfile.hpp"
+#include "../outputs/openal_out.hpp"
+
+namespace Mangle {
+namespace Sound {
+
+/// A InputFilter that adds libsnd decoding to OpenAL. libsndfile
+/// supports most formats except MP3.
+class OpenAL_SndFile_Factory : public InputFilter
+{
+ public:
+  OpenAL_SndFile_Factory()
+    {
+      set(SoundFactoryPtr(new OpenAL_Factory),
+          SampleSourceLoaderPtr(new SndFileLoader));
+    }
+};
+
+}}
+#endif

libs/mangle/sound/filters/openal_sndfile_mpg123.hpp

@@ -0,0 +1,33 @@
+#ifndef MANGLE_SNDFILE_MPG123_OPENAL_H
+#define MANGLE_SNDFILE_MPG123_OPENAL_H
+
+#include "input_filter.hpp"
+#include "source_splicer.hpp"
+#include "../sources/mpg123_source.hpp"
+#include "../sources/libsndfile.hpp"
+#include "../outputs/openal_out.hpp"
+
+namespace Mangle {
+namespace Sound {
+
+/// A InputFilter that uses OpenAL for output, and mpg123 (for MP3) +
+/// libsndfile (for everything else) to decode files. Can only load
+/// from the file system, and uses the file name to differentiate
+/// between mp3 and non-mp3 types.
+class OpenAL_SndFile_Mpg123_Factory : public InputFilter
+{
+ public:
+  OpenAL_SndFile_Mpg123_Factory()
+    {
+      SourceSplicer *splice = new SourceSplicer;
+
+      splice->add("mp3", SampleSourceLoaderPtr(new Mpg123Loader));
+      splice->setDefault(SampleSourceLoaderPtr(new SndFileLoader));
+
+      set(SoundFactoryPtr(new OpenAL_Factory),
+          SampleSourceLoaderPtr(splice));
+    }
+};
+
+}}
+#endif

libs/mangle/sound/filters/openal_various.hpp

@@ -0,0 +1,39 @@
+#ifndef MANGLE_VARIOUS_OPENAL_H
+#define MANGLE_VARIOUS_OPENAL_H
+
+#include "input_filter.hpp"
+#include "source_splicer.hpp"
+#include "../sources/mpg123_source.hpp"
+#include "../sources/wav_source.hpp"
+#include "../outputs/openal_out.hpp"
+
+namespace Mangle {
+namespace Sound {
+
+/** A InputFilter that uses OpenAL for output, and load input from
+    various individual sources, depending on file extension. Currently
+    supports:
+
+      MP3: mpg123
+      WAV: custom wav loader (PCM only)
+
+    This could be an alternative to using eg. 3rd party decoder
+    libraries like libsndfile.
+ */
+class OpenAL_Various_Factory : public InputFilter
+{
+ public:
+  OpenAL_Various_Factory()
+    {
+      SourceSplicer *splice = new SourceSplicer;
+
+      splice->add("mp3", SampleSourceLoaderPtr(new Mpg123Loader));
+      splice->add("wav", SampleSourceLoaderPtr(new WavLoader));
+
+      set(SoundFactoryPtr(new OpenAL_Factory),
+          SampleSourceLoaderPtr(splice));
+    }
+};
+
+}}
+#endif

libs/mangle/sound/filters/pure_filter.hpp

@@ -0,0 +1,72 @@
+#ifndef MANGLE_SOUND_OUTPUT_PUREFILTER_H
+#define MANGLE_SOUND_OUTPUT_PUREFILTER_H
+
+#include "../output.hpp"
+
+namespace Mangle
+{
+  namespace Sound
+  {
+    // For use in writing other filters
+    class SoundFilter : public Sound
+    {
+    protected:
+      SoundPtr client;
+
+    public:
+      SoundFilter(SoundPtr c) : client(c) {}
+      void play() { client->play(); }
+      void stop() { client->stop(); }
+      void pause() { client->pause(); }
+      bool isPlaying() const { return client->isPlaying(); }
+      void setVolume(float f) { client->setVolume(f); }
+      void setPan(float f) { client->setPan(f); }
+      void setPos(float x, float y, float z)
+      { client->setPos(x,y,z); }
+      void setPitch(float p) { client->setPitch(p); }
+      void setRepeat(bool b) { client->setRepeat(b); }
+      void setRange(float a, float b=0, float c=0)
+      { client->setRange(a,b,c); }
+      void setStreaming(bool b) { client->setStreaming(b); }
+
+      // The clone() function is not implemented here, as you will
+      // almost certainly want to override it yourself
+    };
+
+    class FactoryFilter : public SoundFactory
+    {
+    protected:
+      SoundFactoryPtr client;
+
+    public:
+      FactoryFilter(SoundFactoryPtr c) : client(c)
+      {
+        needsUpdate = client->needsUpdate;
+        has3D = client->has3D;
+        canLoadFile = client->canLoadFile;
+        canLoadStream = client->canLoadStream;
+        canLoadSource = client->canLoadSource;
+      }
+
+      SoundPtr loadRaw(SampleSourcePtr input)
+      { return client->loadRaw(input); }
+
+      SoundPtr load(Stream::StreamPtr input)
+      { return client->load(input); }
+
+      SoundPtr load(const std::string &file)
+      { return client->load(file); }
+
+      void update()
+      { client->update(); }
+
+      void setListenerPos(float x, float y, float z,
+                          float fx, float fy, float fz,
+                          float ux, float uy, float uz)
+      {
+        client->setListenerPos(x,y,z,fx,fy,fz,ux,uy,uz);
+      }
+    };
+  }
+}
+#endif

libs/mangle/sound/filters/source_splicer.hpp

@@ -0,0 +1,90 @@
+#ifndef MANGLE_SOUND_SOURCE_SPLICE_H
+#define MANGLE_SOUND_SOURCE_SPLICE_H
+
+#include "../source.hpp"
+#include <stdexcept>
+#include <string>
+#include <list>
+#include <assert.h>
+
+namespace Mangle
+{
+  namespace Sound
+  {
+    class SourceSplicer : public SampleSourceLoader
+    {
+      struct SourceType
+      {
+        std::string type;
+        SampleSourceLoaderPtr loader;
+      };
+
+      typedef std::list<SourceType> TypeList;
+      TypeList list;
+      SampleSourceLoaderPtr catchAll;
+
+      static bool isMatch(char a, char b)
+      {
+        if(a >= 'A' && a <= 'Z')
+          a += 'a' - 'A';
+        if(b >= 'A' && b <= 'Z')
+          b += 'a' - 'A';
+        return a == b;
+      }
+
+    public:
+      SourceSplicer()
+      {
+        canLoadStream = false;
+        canLoadFile = true;
+      }
+
+      void add(const std::string &type, SampleSourceLoaderPtr fact)
+      {
+        SourceType tp;
+        tp.type = type;
+        tp.loader = fact;
+        list.push_back(tp);
+      }
+
+      void setDefault(SampleSourceLoaderPtr def)
+      {
+        catchAll = def;
+      }
+
+      SampleSourcePtr load(const std::string &file)
+      {
+        // Search the list for this file type.
+        for(TypeList::iterator it = list.begin();
+            it != list.end(); it++)
+          {
+            const std::string &t = it->type;
+
+            int diff = file.size() - t.size();
+            if(diff < 0) continue;
+
+            bool match = true;
+            for(unsigned i=0; i<t.size(); i++)
+              if(!isMatch(t[i], file[i+diff]))
+                {
+                  match = false;
+                  break;
+                }
+
+            // Got something! We're done.
+            if(match)
+              return it->loader->load(file);
+          }
+        // If not found, use the catch-all
+        if(catchAll)
+          return catchAll->load(file);
+
+        throw std::runtime_error("No handler for sound file " + file);
+      }
+
+      SampleSourcePtr load(Stream::StreamPtr input) { assert(0); }
+    };
+  }
+}
+
+#endif

libs/mangle/sound/output.hpp

@@ -0,0 +1,180 @@
+#ifndef MANGLE_SOUND_OUTPUT_H
+#define MANGLE_SOUND_OUTPUT_H
+
+#include <string>
+#include <assert.h>
+
+#include "source.hpp"
+#include "../stream/stream.hpp"
+
+namespace Mangle {
+namespace Sound {
+
+/// Abstract interface for a single playable sound
+/** This class represents one sound outlet, which may be played,
+    stopped, paused and so on.
+
+    Sound instances are created from the SoundFactory class. Sounds
+    may be connected to a SampleSource or read directly from a file,
+    and they may support 3d sounds, looping and other features
+    depending on the capabilities of the backend system.
+
+    To create multiple instances of one sound, it is recommended to
+    'clone' an existing instance instead of reloading it from
+    file. Cloned sounds will often (depending on the back-end) use
+    less memory due to shared buffers.
+*/
+class Sound;
+typedef boost::shared_ptr<Sound> SoundPtr;
+typedef boost::weak_ptr  <Sound> WSoundPtr;
+
+class Sound
+{
+ public:
+  /// Play or resume the sound
+  virtual void play() = 0;
+
+  /// Stop the sound
+  virtual void stop() = 0;
+
+  /// Pause the sound, may be resumed later
+  virtual void pause() = 0;
+
+  /// Check if the sound is still playing
+  virtual bool isPlaying() const = 0;
+
+  /// Set the volume. The parameter must be between 0.0 and 1.0.
+  virtual void setVolume(float) = 0;
+
+  /// Set left/right pan. -1.0 is left, 0.0 is center and 1.0 is right.
+  virtual void setPan(float) = 0;
+
+  /// Set pitch (1.0 is normal speed)
+  virtual void setPitch(float) = 0;
+
+  /// Set range factors for 3D sounds. The meaning of the fields
+  /// depend on implementation.
+  virtual void setRange(float a, float b=0.0, float c=0.0) = 0;
+
+  /// Set the position. May not work with all backends.
+  virtual void setPos(float x, float y, float z) = 0;
+
+  /// Set loop mode
+  virtual void setRepeat(bool) = 0;
+
+  /// Set streaming mode.
+  /** This may be used by implementations to optimize for very large
+      files. If streaming mode is off (default), most implementations
+      will load the entire file into memory before starting playback.
+   */
+  virtual void setStreaming(bool) = 0;
+
+  /// Create a new instance of this sound.
+  /** Playback status is not cloned, only the sound data
+      itself. Back-ends can use this as a means of sharing data and
+      saving memory. */
+  virtual SoundPtr clone() = 0;
+
+  /// Virtual destructor
+  virtual ~Sound() {}
+};
+
+/// Factory interface for creating Sound objects
+/** The SoundFactory is the main entry point to a given sound output
+    system. It is used to create Sound objects, which may be connected
+    to a sound file or stream, and which may be individually played,
+    paused, and so on.
+
+    The class also contains a set of public bools which describe the
+    capabilities the particular system. These should be set by
+    implementations (base classes) in their respective constructors.
+ */
+class SoundFactory
+{
+ public:
+  /// Virtual destructor
+  virtual ~SoundFactory() {}
+
+  /** @brief If set to true, you should call update() regularly (every frame
+      or so) on this sound manager. If false, update() should not be
+      called.
+  */
+  bool needsUpdate;
+
+  /** @brief true if 3D functions are available. If false, all use of
+      3D sounds and calls to setPos / setListenerPos will result in
+      undefined behavior.
+  */
+  bool has3D;
+
+  /// true if we can load sounds directly from file (containing encoded data)
+  bool canLoadFile;
+
+  /// If true, we can lound sound files from a Stream (containing encoded data)
+  bool canLoadStream;
+
+  /// true if we can load sounds from a SampleSource (containing raw data)
+  bool canLoadSource;
+
+  /**
+     @brief Load a sound from a sample source. Only valid if
+     canLoadSource is true.
+
+     This function loads a sound from a given stream as defined by
+     SampleSource.
+
+     @param input the input source
+     @param stream true if the file should be streamed.
+            Implementations may use this for optimizing playback of
+            large files, but they are not required to.
+     @return a new Sound object
+  */
+  virtual SoundPtr loadRaw(SampleSourcePtr input) = 0;
+
+  /**
+     @brief Load a sound file from stream. Only valid if canLoadStream
+     is true.
+
+     @param input audio file stream
+     @param stream true if the file should be streamed
+     @see load(InputSource*,bool)
+  */
+  virtual SoundPtr load(Stream::StreamPtr input) = 0;
+
+  /**
+     @brief Load a sound directly from file. Only valid if canLoadFile
+     is true.
+
+     @param file filename
+     @param stream true if the file should be streamed
+     @see load(InputSource*,bool)
+  */
+  virtual SoundPtr load(const std::string &file) = 0;
+
+  /// Call this every frame if needsUpdate is true
+  /**
+     This should be called regularly (about every frame in a normal
+     game setting.) Implementions may use this for filling streaming
+     buffers and similar tasks. Implementations that do not need this
+     should set needsUpdate to false.
+  */
+  virtual void update() { assert(0); }
+
+  /// Set listener position (coordinates, front and up vectors)
+  /**
+     Only valid if has3D is true.
+
+     @param x,y,z listener position
+     @param fx,fy,fz listener's looking direction
+     @param ux,uy,uz listener's up direction
+   */
+  virtual void setListenerPos(float x, float y, float z,
+                              float fx, float fy, float fz,
+                              float ux, float uy, float uz) = 0;
+};
+
+typedef boost::shared_ptr<SoundFactory> SoundFactoryPtr;
+
+}} // Namespaces
+
+#endif

libs/mangle/sound/outputs/openal_out.cpp

@@ -0,0 +1,492 @@
+#include "openal_out.hpp"
+#include <assert.h>
+#include <stdexcept>
+
+#include "../../stream/filters/buffer_stream.hpp"
+
+#ifdef _WIN32
+#include <al.h>
+#include <alc.h>
+#elif defined(__APPLE__)
+#include <OpenAL/alc.h>
+#include <OpenAL/al.h>
+#else
+#include <AL/al.h>
+#include <AL/alc.h>
+#endif
+
+using namespace Mangle::Sound;
+
+// ---- Helper functions and classes ----
+
+// Static buffer used to shuffle sound data from the input into
+// OpenAL. The data is only stored temporarily and then immediately
+// shuffled off to the library. This is not thread safe, but it works
+// fine with multiple sounds in one thread. It could be made thread
+// safe simply by using thread local storage.
+const size_t BSIZE = 32*1024;
+static char tmp_buffer[BSIZE];
+
+// Number of buffers used (per sound) for streaming sounds. Each
+// buffer is of size BSIZE. Increasing this will make streaming sounds
+// more fault tolerant against temporary lapses in call to update(),
+// but will also increase memory usage.
+// This was changed from 4 to 150 for an estimated 30 seconds tolerance.
+// At some point we should replace it with a more multithreading-ish
+// solution.
+const int STREAM_BUF_NUM = 150;
+
+static void fail(const std::string &msg)
+{ throw std::runtime_error("OpenAL exception: " + msg); }
+
+/*
+  Check for AL error. Since we're always calling this with string
+  literals, and it only makes sense to optimize for the non-error
+  case, the parameter is const char* rather than std::string.
+
+  This way we don't force the compiler to create a string object each
+  time we're called (since the string is never used unless there's an
+  error), although a good compiler might have optimized that away in
+  any case.
+ */
+static void checkALError(const char *where)
+{
+  ALenum err = alGetError();
+  if(err != AL_NO_ERROR)
+    {
+      std::string msg = where;
+
+      const ALchar* errmsg = alGetString(err);
+      if(errmsg)
+        fail("\"" + std::string(alGetString(err)) + "\" while " + msg);
+      else
+        fail("non-specified error while " + msg + " (did you forget to initialize OpenAL?)");
+    }
+}
+
+static void getALFormat(SampleSourcePtr inp, int &fmt, int &rate)
+{
+  boost::int32_t rate_, ch, bits;
+  inp->getInfo(&rate_, &ch, &bits);
+  rate = rate_;
+
+  fmt = 0;
+
+  if(bits == 8)
+    {
+      if(ch == 1) fmt = AL_FORMAT_MONO8;
+      if(ch == 2) fmt = AL_FORMAT_STEREO8;
+      if(alIsExtensionPresent("AL_EXT_MCFORMATS"))
+        {
+          if(ch == 4) fmt = alGetEnumValue("AL_FORMAT_QUAD8");
+          if(ch == 6) fmt = alGetEnumValue("AL_FORMAT_51CHN8");
+        }
+    }
+  if(bits == 16)
+    {
+      if(ch == 1) fmt = AL_FORMAT_MONO16;
+      if(ch == 2) fmt = AL_FORMAT_STEREO16;
+      if(ch == 4) fmt = alGetEnumValue("AL_FORMAT_QUAD16");
+      if(alIsExtensionPresent("AL_EXT_MCFORMATS"))
+        {
+          if(ch == 4) fmt = alGetEnumValue("AL_FORMAT_QUAD16");
+          if(ch == 6) fmt = alGetEnumValue("AL_FORMAT_51CHN16");
+        }
+    }
+
+  if(fmt == 0)
+    fail("Unsupported input format");
+}
+
+/// OpenAL sound output
+class Mangle::Sound::OpenAL_Sound : public Sound
+{
+  ALuint inst;
+
+  // Buffers. Only the first is used for non-streaming sounds.
+  ALuint bufferID[STREAM_BUF_NUM];
+
+  // Number of buffers used
+  int bufNum;
+
+  // Parameters used for filling buffers
+  int fmt, rate;
+
+  // Poor mans reference counting. Might improve this later. When
+  // NULL, the buffer has not been set up yet.
+  int *refCnt;
+
+  bool streaming;
+
+  // Input stream
+  SampleSourcePtr input;
+
+  OpenAL_Factory *owner;
+  bool ownerAlive;
+
+  // Used for streamed sound list
+  OpenAL_Sound *next, *prev;
+
+  void setupBuffer();
+
+  // Fill data into the given buffer and queue it, if there is any
+  // data left to queue. Assumes the buffer is already unqueued, if
+  // necessary.
+  void queueBuffer(ALuint buf)
+  {
+    // If there is no more data, do nothing
+    if(!input) return;
+    if(input->eof())
+      {
+        input.reset();
+        return;
+      }
+
+    // Get some new data
+    size_t bytes = input->read(tmp_buffer, BSIZE);
+    if(bytes == 0)
+      {
+        input.reset();
+        return;
+      }
+
+    // Move data into the OpenAL buffer
+    alBufferData(buf, fmt, tmp_buffer, bytes, rate);
+    // Queue it
+    alSourceQueueBuffers(inst, 1, &buf);
+    checkALError("Queueing buffer data");
+  }
+
+ public:
+  /// Read samples from the given input buffer
+  OpenAL_Sound(SampleSourcePtr input, OpenAL_Factory *fact);
+
+  /// Play an existing buffer, with a given ref counter. Used
+  /// internally for cloning.
+  OpenAL_Sound(ALuint buf, int *ref, OpenAL_Factory *fact);
+
+  ~OpenAL_Sound();
+
+  // Must be called regularly on streamed sounds
+  void update()
+  {
+    if(!streaming) return;
+    if(!input) return;
+
+    // Get the number of processed buffers
+    ALint count;
+    alGetSourcei(inst, AL_BUFFERS_PROCESSED, &count);
+    checkALError("getting number of unprocessed buffers");
+
+    for(int i=0; i<count; i++)
+      {
+        ALuint buf;
+        // Unqueue one of the processed buffer
+        alSourceUnqueueBuffers(inst, 1, &buf);
+
+        // Then reload it with data (if any) and queue it up
+        queueBuffer(buf);
+      }
+  }
+
+  void play();
+  void stop();
+  void pause();
+  bool isPlaying() const;
+  void setVolume(float);
+  void setPos(float x, float y, float z);
+  void setPitch(float);
+  void setRepeat(bool);
+
+  void notifyOwnerDeath()
+  { ownerAlive = false; }
+
+  // We can enable streaming, but never disable it.
+  void setStreaming(bool s)
+  { if(s) streaming = true; }
+
+  SoundPtr clone();
+
+  // a = AL_REFERENCE_DISTANCE
+  // b = AL_MAX_DISTANCE
+  // c = ignored
+  void setRange(float a, float b=0.0, float c=0.0);
+
+  /// Not implemented
+  void setPan(float) {}
+};
+
+// ---- OpenAL_Factory ----
+
+SoundPtr OpenAL_Factory::loadRaw(SampleSourcePtr input)
+{
+  return SoundPtr(new OpenAL_Sound(input, this));
+}
+
+void OpenAL_Factory::setListenerPos(float x, float y, float z,
+                                    float fx, float fy, float fz,
+                                    float ux, float uy, float uz)
+{
+  ALfloat orient[6];
+  orient[0] = fx;
+  orient[1] = fy;
+  orient[2] = fz;
+  orient[3] = ux;
+  orient[4] = uy;
+  orient[5] = uz;
+  alListener3f(AL_POSITION, x, y, z);
+  alListenerfv(AL_ORIENTATION, orient);
+}
+
+OpenAL_Factory::OpenAL_Factory(bool doSetup)
+  : device(NULL), context(NULL), didSetup(doSetup)
+{
+  needsUpdate = true;
+  has3D = true;
+  canLoadFile = false;
+  canLoadStream = false;
+  canLoadSource = true;
+
+  ALCdevice *Device;
+  ALCcontext *Context;
+
+  if(doSetup)
+    {
+      // Set up sound system
+      Device = alcOpenDevice(NULL);
+      Context = alcCreateContext(Device, NULL);
+
+      if(!Device || !Context)
+        fail("Failed to initialize context or device");
+
+      alcMakeContextCurrent(Context);
+
+      device = Device;
+      context = Context;
+    }
+}
+
+void OpenAL_Factory::update()
+{
+  // Loop through all streaming sounds and update them
+  StreamList::iterator it = streaming.begin();
+  for(;it != streaming.end(); it++)
+    (*it)->update();
+}
+
+void OpenAL_Factory::notifyStreaming(OpenAL_Sound *snd)
+{
+  // Add the sound to the streaming list
+  streaming.push_back(snd);
+}
+
+void OpenAL_Factory::notifyDelete(OpenAL_Sound *snd)
+{
+  // Remove the sound from the stream list
+  streaming.remove(snd);
+}
+
+OpenAL_Factory::~OpenAL_Factory()
+{
+  // Notify remaining streamed sounds that we're dying
+  StreamList::iterator it = streaming.begin();
+  for(;it != streaming.end(); it++)
+    (*it)->notifyOwnerDeath();
+
+  // Deinitialize sound system
+  if(didSetup)
+    {
+      alcMakeContextCurrent(NULL);
+      if(context) alcDestroyContext((ALCcontext*)context);
+      if(device) alcCloseDevice((ALCdevice*)device);
+    }
+}
+
+// ---- OpenAL_Sound ----
+
+void OpenAL_Sound::play()
+{
+  setupBuffer();
+  alSourcePlay(inst);
+  checkALError("starting playback");
+}
+
+void OpenAL_Sound::stop()
+{
+  alSourceStop(inst);
+  checkALError("stopping");
+}
+
+void OpenAL_Sound::pause()
+{
+  alSourcePause(inst);
+  checkALError("pausing");
+}
+
+bool OpenAL_Sound::isPlaying() const
+{
+  ALint state;
+  alGetSourcei(inst, AL_SOURCE_STATE, &state);
+
+  return state == AL_PLAYING;
+}
+
+void OpenAL_Sound::setVolume(float volume)
+{
+  if(volume > 1.0) volume = 1.0;
+  if(volume < 0.0) volume = 0.0;
+  alSourcef(inst, AL_GAIN, volume);
+  checkALError("setting volume");
+}
+
+void OpenAL_Sound::setRange(float a, float b, float)
+{
+  alSourcef(inst, AL_REFERENCE_DISTANCE, a);
+  alSourcef(inst, AL_MAX_DISTANCE, b);
+  checkALError("setting sound ranges");
+}
+
+void OpenAL_Sound::setPos(float x, float y, float z)
+{
+  alSource3f(inst, AL_POSITION, x, y, z);
+  checkALError("setting position");
+}
+
+void OpenAL_Sound::setPitch(float pitch)
+{
+  alSourcef(inst, AL_PITCH, pitch);
+  checkALError("setting pitch");
+}
+
+void OpenAL_Sound::setRepeat(bool rep)
+{
+  alSourcei(inst, AL_LOOPING, rep?AL_TRUE:AL_FALSE);
+}
+
+SoundPtr OpenAL_Sound::clone()
+{
+  setupBuffer();
+  assert(!streaming && "cloning streamed sounds not supported");
+  return SoundPtr(new OpenAL_Sound(bufferID[0], refCnt, owner));
+}
+
+// Constructor used for cloned sounds
+OpenAL_Sound::OpenAL_Sound(ALuint buf, int *ref, OpenAL_Factory *fact)
+  : refCnt(ref), streaming(false), owner(fact), ownerAlive(false)
+{
+  // Increase the reference count
+  assert(ref != NULL);
+  (*refCnt)++;
+
+  // Set up buffer
+  bufferID[0] = buf;
+  bufNum = 1;
+
+  // Create a source
+  alGenSources(1, &inst);
+  checkALError("creating instance (clone)");
+  alSourcei(inst, AL_BUFFER, bufferID[0]);
+  checkALError("assigning buffer (clone)");
+}
+
+// Constructor used for original (non-cloned) sounds
+OpenAL_Sound::OpenAL_Sound(SampleSourcePtr _input, OpenAL_Factory *fact)
+  : refCnt(NULL), streaming(false), input(_input), owner(fact), ownerAlive(false)
+{
+  // Create a source
+  alGenSources(1, &inst);
+  checkALError("creating source");
+
+  // By default, the sound starts out in a buffer-less mode. We don't
+  // create a buffer until the sound is played. This gives the user
+  // the chance to call setStreaming(true) first.
+}
+
+void OpenAL_Sound::setupBuffer()
+{
+  if(refCnt != NULL) return;
+
+  assert(input);
+
+  // Get the format
+  getALFormat(input, fmt, rate);
+
+  // Create a cheap reference counter for the buffer
+  refCnt = new int;
+  *refCnt = 1;
+
+  if(streaming) bufNum = STREAM_BUF_NUM;
+  else bufNum = 1;
+
+  // Set up the OpenAL buffer(s)
+  alGenBuffers(bufNum, bufferID);
+  checkALError("generating buffer(s)");
+  assert(bufferID[0] != 0);
+
+  // STREAMING.
+  if(streaming)
+    {
+      // Just queue all the buffers with data and exit. queueBuffer()
+      // will work correctly also in the case where there is not
+      // enough data to fill all the buffers.
+      for(int i=0; i<bufNum; i++)
+        queueBuffer(bufferID[i]);
+
+      // Notify the manager what we're doing
+      owner->notifyStreaming(this);
+      ownerAlive = true;
+
+      return;
+    }
+
+  // NON-STREAMING. We have to load all the data and shove it into the
+  // buffer.
+
+  // Does the stream support pointer operations?
+  if(input->hasPtr)
+    {
+      // If so, we can read the data directly from the stream
+      alBufferData(bufferID[0], fmt, input->getPtr(), input->size(), rate);
+    }
+  else
+    {
+      // Read the entire stream into a temporary buffer first
+      Mangle::Stream::BufferStream buf(input, 128*1024);
+
+      // Then copy that into OpenAL
+      alBufferData(bufferID[0], fmt, buf.getPtr(), buf.size(), rate);
+    }
+  checkALError("loading sound data");
+
+  // We're done with the input stream, release the pointer
+  input.reset();
+
+  alSourcei(inst, AL_BUFFER, bufferID[0]);
+  checkALError("assigning buffer");
+}
+
+OpenAL_Sound::~OpenAL_Sound()
+{
+  // Stop
+  alSourceStop(inst);
+
+  // Return sound
+  alDeleteSources(1, &inst);
+
+  // Notify the factory that we quit. You will hear from our union
+  // rep. The bool check is to handle cases where the manager goes out
+  // of scope before the sounds do. In that case, don't try to contact
+  // the factory.
+  if(ownerAlive)
+    owner->notifyDelete(this);
+
+  // Decrease the reference counter
+  if((-- (*refCnt)) == 0)
+    {
+      // We're the last owner. Delete the buffer(s) and the counter
+      // itself.
+      alDeleteBuffers(bufNum, bufferID);
+      checkALError("deleting buffer");
+      delete refCnt;
+    }
+}

libs/mangle/sound/outputs/openal_out.hpp

@@ -0,0 +1,44 @@
+#ifndef MANGLE_SOUND_OPENAL_OUT_H
+#define MANGLE_SOUND_OPENAL_OUT_H
+
+#include "../output.hpp"
+#include <list>
+
+namespace Mangle {
+namespace Sound {
+
+class OpenAL_Sound;
+
+class OpenAL_Factory : public SoundFactory
+{
+  void *device;
+  void *context;
+  bool didSetup;
+
+  // List of streaming sounds that need to be updated every frame.
+  typedef std::list<OpenAL_Sound*> StreamList;
+  StreamList streaming;
+
+  friend class OpenAL_Sound;
+  void notifyStreaming(OpenAL_Sound*);
+  void notifyDelete(OpenAL_Sound*);
+
+ public:
+  /// Initialize object. Pass true (default) if you want the
+  /// constructor to set up the current ALCdevice and ALCcontext for
+  /// you.
+  OpenAL_Factory(bool doSetup = true);
+  ~OpenAL_Factory();
+
+  SoundPtr load(const std::string &file) { assert(0); return SoundPtr(); }
+  SoundPtr load(Stream::StreamPtr input) { assert(0); return SoundPtr(); }
+  SoundPtr loadRaw(SampleSourcePtr input);
+
+  void update();
+  void setListenerPos(float x, float y, float z,
+                      float fx, float fy, float fz,
+                      float ux, float uy, float uz);
+};
+
+}} // namespaces
+#endif

libs/mangle/sound/source.hpp

@@ -0,0 +1,62 @@
+#ifndef MANGLE_SOUND_SOURCE_H
+#define MANGLE_SOUND_SOURCE_H
+
+#include <string>
+#include <boost/cstdint.hpp>
+#include <assert.h>
+
+#include "../stream/stream.hpp"
+
+namespace Mangle {
+namespace Sound {
+
+typedef boost::int32_t int32_t;
+
+/// A stream containing raw sound data and information about the format
+class SampleSource : public Stream::Stream
+{
+ protected:
+  bool isEof;
+
+ public:
+  SampleSource() : isEof(false) {}
+
+  /// Get the sample rate, number of channels, and bits per
+  /// sample. NULL parameters are ignored.
+  virtual void getInfo(int32_t *rate, int32_t *channels, int32_t *bits) = 0;
+
+  bool eof() const { return isEof; }
+
+  // Disabled functions by default. You can still override them in
+  // subclasses.
+  void seek(size_t pos) { assert(0); }
+  size_t tell() const { assert(0); return 0; }
+  size_t size() const { assert(0); return 0; }
+};
+
+typedef boost::shared_ptr<SampleSource> SampleSourcePtr;
+
+/// A factory interface for loading SampleSources from file or stream
+class SampleSourceLoader
+{
+ public:
+  /// If true, the stream version of load() works
+  bool canLoadStream;
+
+  /// If true, the file version of load() works
+  bool canLoadFile;
+
+  /// Load a sound input source from file (if canLoadFile is true)
+  virtual SampleSourcePtr load(const std::string &file) = 0;
+
+  /// Load a sound input source from stream (if canLoadStream is true)
+  virtual SampleSourcePtr load(Stream::StreamPtr input) = 0;
+
+  /// Virtual destructor
+  virtual ~SampleSourceLoader() {}
+};
+
+typedef boost::shared_ptr<SampleSourceLoader> SampleSourceLoaderPtr;
+
+}} // namespaces
+#endif

libs/mangle/sound/sources/audiere_source.cpp

@@ -0,0 +1,77 @@
+#include "audiere_source.hpp"
+
+#include "../../stream/clients/audiere_file.hpp"
+
+#include <stdexcept>
+
+using namespace Mangle::Stream;
+
+static void fail(const std::string &msg)
+{ throw std::runtime_error("Audiere exception: " + msg); }
+
+using namespace audiere;
+using namespace Mangle::Sound;
+
+// --- SampleSource ---
+
+void AudiereSource::getInfo(Mangle::Sound::int32_t *rate,
+    Mangle::Sound::int32_t *channels, Mangle::Sound::int32_t *bits)
+{
+  SampleFormat fmt;
+  int channels_, rate_;
+  sample->getFormat(channels_, rate_, fmt);
+  *channels = channels_;
+  *rate = rate_;
+  if(bits)
+    {
+      if(fmt == SF_U8)
+        *bits = 8;
+      else if(fmt == SF_S16)
+        *bits = 16;
+      else assert(0);
+    }
+}
+
+// --- Constructors ---
+
+AudiereSource::AudiereSource(const std::string &file)
+{
+  sample = OpenSampleSource(file.c_str());
+
+  if(!sample)
+    fail("Couldn't load file " + file);
+
+  doSetup();
+}
+
+AudiereSource::AudiereSource(StreamPtr input)
+{
+  // Use our Stream::AudiereFile implementation to convert a Mangle
+  // 'Stream' to an Audiere 'File'
+  sample = OpenSampleSource(new AudiereFile(input));
+  if(!sample)
+    fail("Couldn't load stream");
+
+  doSetup();
+}
+
+AudiereSource::AudiereSource(audiere::SampleSourcePtr src)
+  : sample(src)
+{ assert(sample); doSetup(); }
+
+// Common function called from all constructors
+void AudiereSource::doSetup()
+{
+  assert(sample);
+
+  SampleFormat fmt;
+  int channels, rate;
+  sample->getFormat(channels, rate, fmt);
+
+  // Calculate the size of one frame, and pass it to SampleReader.
+  setup(GetSampleSize(fmt) * channels);
+
+  isSeekable = sample->isSeekable();
+  hasPosition = true;
+  hasSize = true;
+}

libs/mangle/sound/sources/audiere_source.hpp

@@ -0,0 +1,48 @@
+#ifndef MANGLE_SOUND_AUDIERE_SOURCE_H
+#define MANGLE_SOUND_AUDIERE_SOURCE_H
+
+#include "sample_reader.hpp"
+
+// audiere.h from 1.9.4 (latest) release uses
+// cstring routines like strchr() and strlen() without
+// including cstring itself.
+#include <cstring>
+#include <audiere.h>
+
+namespace Mangle {
+namespace Sound {
+
+/// A sample source that decodes files using Audiere
+class AudiereSource : public SampleReader
+{
+  audiere::SampleSourcePtr sample;
+
+  size_t readSamples(void *data, size_t length)
+  { return sample->read(length, data); }
+
+  void doSetup();
+
+ public:
+  /// Decode the given sound file
+  AudiereSource(const std::string &file);
+
+  /// Decode the given sound stream
+  AudiereSource(Mangle::Stream::StreamPtr src);
+
+  /// Read directly from an existing audiere::SampleSource
+  AudiereSource(audiere::SampleSourcePtr src);
+
+  void getInfo(int32_t *rate, int32_t *channels, int32_t *bits);
+
+  void seek(size_t pos) { sample->setPosition(pos/frameSize); }
+  size_t tell() const { return sample->getPosition()*frameSize; }
+  size_t size() const { return sample->getLength()*frameSize; }
+};
+
+#include "loadertemplate.hpp"
+
+/// A factory that loads AudiereSources from file and stream
+typedef SSL_Template<AudiereSource,true,true> AudiereLoader;
+
+}} // Namespace
+#endif

libs/mangle/sound/sources/ffmpeg_source.cpp

@@ -0,0 +1,189 @@
+#include "ffmpeg_source.hpp"
+
+#include <stdexcept>
+
+using namespace Mangle::Sound;
+
+// Static output buffer. Not thread safe, but supports multiple
+// streams operated from the same thread.
+static uint8_t outBuf[AVCODEC_MAX_AUDIO_FRAME_SIZE];
+
+static void fail(const std::string &msg)
+{ throw std::runtime_error("FFMpeg exception: " + msg); }
+
+// --- Loader ---
+
+static bool init = false;
+
+FFMpegLoader::FFMpegLoader(bool setup)
+{
+  if(setup && !init)
+    {
+      av_register_all();
+      av_log_set_level(AV_LOG_ERROR);
+      init = true;
+    }
+}
+
+// --- Source ---
+
+FFMpegSource::FFMpegSource(const std::string &file)
+{
+  std::string msg;
+  AVCodec *codec;
+
+  if(av_open_input_file(&FmtCtx, file.c_str(), NULL, 0, NULL) != 0)
+    fail("Error loading audio file " + file);
+
+  if(av_find_stream_info(FmtCtx) < 0)
+    {
+      msg = "Error in file stream " + file;
+      goto err;
+    }
+
+  // Pick the first audio stream, if any
+  for(StreamNum = 0; StreamNum < FmtCtx->nb_streams; StreamNum++)
+    {
+      // Pick the first audio stream
+      if(FmtCtx->streams[StreamNum]->codec->codec_type == CODEC_TYPE_AUDIO)
+        break;
+    }
+
+  if(StreamNum == FmtCtx->nb_streams)
+    fail("File '" + file + "' didn't contain any audio streams");
+
+  // Open the decoder
+  CodecCtx = FmtCtx->streams[StreamNum]->codec;
+  codec = avcodec_find_decoder(CodecCtx->codec_id);
+
+  if(!codec || avcodec_open(CodecCtx, codec) < 0)
+    {
+      msg = "Error loading '" + file + "': ";
+      if(codec)
+        msg += "coded error";
+      else
+        msg += "no codec found";
+      goto err;
+    }
+
+  // No errors, we're done
+  return;
+
+  // Handle errors
+ err:
+  av_close_input_file(FmtCtx);
+  fail(msg);
+}
+
+FFMpegSource::~FFMpegSource()
+{
+  avcodec_close(CodecCtx);
+  av_close_input_file(FmtCtx);
+}
+
+void FFMpegSource::getInfo(int32_t *rate, int32_t *channels, int32_t *bits)
+{
+  if(rate) *rate = CodecCtx->sample_rate;
+  if(channels) *channels = CodecCtx->channels;
+  if(bits) *bits = 16;
+}
+
+size_t FFMpegSource::read(void *data, size_t length)
+{
+  if(isEof) return 0;
+
+  size_t left = length;
+  uint8_t *outPtr = (uint8_t*)data;
+
+  // First, copy over any stored data we might be sitting on
+  {
+    size_t s = storage.size();
+    size_t copy = s;
+    if(s)
+      {
+        // Make sure there's room
+        if(copy > left)
+          copy = left;
+
+        // Copy
+        memcpy(outPtr, &storage[0], copy);
+        outPtr += copy;
+        left -= copy;
+
+        // Is there anything left in the storage?
+        assert(s>= copy);
+        s -= copy;
+        if(s)
+          {
+            assert(left == 0);
+
+            // Move it to the start and resize
+            memmove(&storage[0], &storage[copy], s);
+            storage.resize(s);
+          }
+      }
+  }
+
+  // Next, get more input data from stream, and decode it
+  while(left)
+    {
+      AVPacket packet;
+
+      // Get the next packet, if any
+      if(av_read_frame(FmtCtx, &packet) < 0)
+        break;
+
+      // We only allow one stream per file at the moment
+      assert((int)StreamNum == packet.stream_index);
+
+      // Decode the packet
+      int len = AVCODEC_MAX_AUDIO_FRAME_SIZE;
+      int tmp = avcodec_decode_audio2(CodecCtx, (int16_t*)outBuf,
+                                      &len, packet.data, packet.size);
+      assert(tmp < 0 || tmp == packet.size);
+
+      // We don't need the input packet any longer
+      av_free_packet(&packet);
+
+      if(tmp < 0)
+        fail("Error decoding audio stream");
+
+      // Copy whatever data we got, and advance the pointer
+      if(len > 0)
+        {
+          // copy = how many bytes do we copy now
+          size_t copy = len;
+          if(copy > left)
+            copy = left;
+
+          // len = how many bytes are left uncopied
+          len -= copy;
+
+          // copy data
+          memcpy(outPtr, outBuf, copy);
+
+          // left = how much space is left in the caller output
+          // buffer. This loop repeats as long left is > 0
+          left -= copy;
+          outPtr += copy;
+          assert(left >= 0);
+
+          if(len > 0)
+            {
+              // There were uncopied bytes. Store them for later.
+              assert(left == 0);
+              storage.resize(len);
+              memcpy(&storage[0], outBuf, len);
+            }
+        }
+    }
+
+  // End of loop. Return the number of bytes copied.
+  assert(left <= length);
+
+  // If we're returning less than asked for, then we're done
+  if(left > 0)
+    isEof = true;
+
+  return length - left;
+}

libs/mangle/sound/sources/ffmpeg_source.hpp

@@ -0,0 +1,52 @@
+#ifndef MANGLE_SOUND_FFMPEG_H
+#define MANGLE_SOUND_FFMPEG_H
+
+#include "../source.hpp"
+#include <vector>
+#include <assert.h>
+
+extern "C"
+{
+#include <avcodec.h>
+#include <avformat.h>
+}
+
+namespace Mangle {
+namespace Sound {
+
+class FFMpegSource : public SampleSource
+{
+  AVFormatContext *FmtCtx;
+  AVCodecContext *CodecCtx;
+  unsigned int StreamNum;
+
+  std::vector<uint8_t> storage;
+
+ public:
+  /// Decode the given sound file
+  FFMpegSource(const std::string &file);
+
+  /// Decode the given sound stream (not supported by FFmpeg)
+  FFMpegSource(Mangle::Stream::StreamPtr src) { assert(0); }
+
+  ~FFMpegSource();
+
+  // Overrides
+  void getInfo(int32_t *rate, int32_t *channels, int32_t *bits);
+  size_t read(void *data, size_t length);
+};
+
+#include "loadertemplate.hpp"
+
+/// A factory that loads FFMpegSources from file
+class FFMpegLoader : public SSL_Template<FFMpegSource,false,true>
+{
+ public:
+
+  /// Sets up the libavcodec library. If you want to do your own
+  /// setup, send a setup=false parameter.
+  FFMpegLoader(bool setup=true);
+};
+
+}} // namespaces
+#endif

libs/mangle/sound/sources/libsndfile.cpp

@@ -0,0 +1,48 @@
+#include "libsndfile.hpp"
+
+#include <stdexcept>
+#include <sndfile.h>
+
+using namespace Mangle::Stream;
+
+static void fail(const std::string &msg)
+{ throw std::runtime_error("Mangle::libsndfile: " + msg); }
+
+using namespace Mangle::Sound;
+
+void SndFileSource::getInfo(int32_t *_rate, int32_t *_channels, int32_t *_bits)
+{
+  *_rate = rate;
+  *_channels = channels;
+  *_bits = bits;
+}
+
+size_t SndFileSource::readSamples(void *data, size_t length)
+{
+  // readf_* reads entire frames, including channels
+  return sf_readf_short((SNDFILE*)handle, (short*)data, length);
+}
+
+SndFileSource::SndFileSource(const std::string &file)
+{
+  SF_INFO info;
+  info.format = 0;
+  handle = sf_open(file.c_str(), SFM_READ, &info);
+  if(handle == NULL)
+    fail("Failed to open " + file);
+
+  // I THINK that using sf_read_short forces the library to convert to
+  // 16 bits no matter what, but the libsndfile docs aren't exactly
+  // very clear on this point.
+  channels = info.channels;
+  rate = info.samplerate;
+  bits = 16;
+
+  // 16 bits per sample times number of channels
+  setup(2*channels);
+}
+
+SndFileSource::~SndFileSource()
+{
+  sf_close((SNDFILE*)handle);
+}

libs/mangle/sound/sources/libsndfile.hpp

@@ -0,0 +1,36 @@
+#ifndef MANGLE_SOUND_SNDFILE_SOURCE_H
+#define MANGLE_SOUND_SNDFILE_SOURCE_H
+
+#include "sample_reader.hpp"
+
+namespace Mangle {
+namespace Sound {
+
+/// A sample source that decodes files using libsndfile. Supports most
+/// formats except mp3.
+class SndFileSource : public SampleReader
+{
+  void *handle;
+  int channels, rate, bits;
+
+  size_t readSamples(void *data, size_t length);
+
+ public:
+  /// Decode the given sound file
+  SndFileSource(const std::string &file);
+
+  /// Decode the given sound stream (not supported)
+  SndFileSource(Mangle::Stream::StreamPtr src) { assert(0); }
+
+  ~SndFileSource();
+
+  void getInfo(int32_t *rate, int32_t *channels, int32_t *bits);
+};
+
+#include "loadertemplate.hpp"
+
+/// A factory that loads SndFileSources from file and stream
+typedef SSL_Template<SndFileSource,false,true> SndFileLoader;
+
+}} // Namespace
+#endif

libs/mangle/sound/sources/loadertemplate.hpp

@@ -0,0 +1,28 @@
+#ifndef SSL_TEMPL_H
+#define SSL_TEMPL_H
+
+template <class SourceT, bool stream, bool file>
+class SSL_Template : public SampleSourceLoader
+{
+ public:
+
+  SSL_Template()
+    {
+      canLoadStream = stream;
+      canLoadFile = file;
+    }
+
+  SampleSourcePtr load(const std::string &filename)
+  {
+    assert(canLoadFile);
+    return SampleSourcePtr(new SourceT(filename));
+  }
+
+  SampleSourcePtr load(Stream::StreamPtr input)
+  {
+    assert(canLoadStream);
+    return SampleSourcePtr(new SourceT(input));
+  }
+};
+
+#endif

libs/mangle/sound/sources/mpg123_source.cpp

@@ -0,0 +1,115 @@
+#include "mpg123_source.hpp"
+
+#include <stdexcept>
+
+#include <mpg123.h>
+
+using namespace Mangle::Stream;
+
+/*
+  TODOs:
+
+  - mpg123 impressively enough supports custom stream reading. Which
+    means we could (and SHOULD!) support reading from Mangle::Streams
+    as well. But I'll save it til I need it.
+
+    An alternative way to do this is through feeding (which they also
+    support), but that's more messy.
+
+  - the library also supports output, via various other sources,
+    including ALSA, OSS, PortAudio, PulseAudio and SDL. Using this
+    library as a pure output library (if that is possible) would be a
+    nice shortcut over using those libraries - OTOH it's another
+    dependency.
+
+  - we could implement seek(), tell() and size(), but they aren't
+    really necessary. Furthermore, since the returned size is only a
+    guess, it is not safe to rely on it.
+ */
+
+static void fail(const std::string &msg)
+{ throw std::runtime_error("Mangle::Mpg123 exception: " + msg); }
+
+static void checkError(int err, void *mh = NULL)
+{
+  if(err != MPG123_OK)
+    {
+      std::string msg;
+      if(mh) msg = mpg123_strerror((mpg123_handle*)mh);
+      else msg = mpg123_plain_strerror(err);
+      fail(msg);
+    }
+}
+
+using namespace Mangle::Sound;
+
+void Mpg123Source::getInfo(int32_t *pRate, int32_t *pChannels, int32_t *pBits)
+{
+  // Use the values we found in the constructor
+  *pRate = rate;
+  *pChannels = channels;
+  *pBits = bits;
+}
+
+size_t Mpg123Source::read(void *data, size_t length)
+{
+  size_t done;
+  // This is extraordinarily nice. I like this library.
+  int err = mpg123_read((mpg123_handle*)mh, (unsigned char*)data, length, &done);
+  assert(done <= length);
+  if(err == MPG123_DONE)
+    isEof = true;
+  else
+    checkError(err, mh);
+  return done;
+}
+
+Mpg123Loader::Mpg123Loader(bool setup)
+{
+  // Do as we're told
+  if(setup)
+    {
+      int err = mpg123_init();
+      checkError(err);
+    }
+  didSetup = setup;
+}
+
+Mpg123Loader::~Mpg123Loader()
+{
+  // Deinitialize the library on exit
+  if(didSetup)
+    mpg123_exit();
+}
+
+Mpg123Source::Mpg123Source(const std::string &file)
+{
+  int err;
+
+  // Create a new handle
+  mh = mpg123_new(NULL, &err);
+  if(mh == NULL)
+    checkError(err, mh);
+
+  mpg123_handle *mhh = (mpg123_handle*)mh;
+
+  // Open the file (hack around constness)
+  err = mpg123_open(mhh, (char*)file.c_str());
+  checkError(err, mh);
+
+  // Get the format
+  int encoding;
+  err = mpg123_getformat(mhh, &rate, &channels, &encoding);
+  checkError(err, mh);
+  if(encoding != MPG123_ENC_SIGNED_16)
+    fail("Unsupported encoding in " + file);
+
+  // This is the only bit size we support.
+  bits = 16;
+}
+
+Mpg123Source::~Mpg123Source()
+{
+  mpg123_close((mpg123_handle*)mh);
+  mpg123_delete((mpg123_handle*)mh);
+}

libs/mangle/sound/sources/mpg123_source.hpp

@@ -0,0 +1,47 @@
+#ifndef MANGLE_SOUND_MPG123_SOURCE_H
+#define MANGLE_SOUND_MPG123_SOURCE_H
+
+#include "../source.hpp"
+#include <assert.h>
+
+namespace Mangle {
+namespace Sound {
+
+/// A sample source that decodes files using libmpg123. Only supports
+/// MP3 files.
+class Mpg123Source : public SampleSource
+{
+  void *mh;
+  long int rate;
+  int channels, bits;
+
+ public:
+  /// Decode the given sound file
+  Mpg123Source(const std::string &file);
+
+  /// Needed by SSL_Template but not yet supported
+  Mpg123Source(Mangle::Stream::StreamPtr data)
+  { assert(0); }
+
+  ~Mpg123Source();
+
+  void getInfo(int32_t *rate, int32_t *channels, int32_t *bits);
+  size_t read(void *data, size_t length);
+};
+
+#include "loadertemplate.hpp"
+
+/// A factory that loads Mpg123Sources from file and stream
+struct Mpg123Loader : SSL_Template<Mpg123Source,false,true>
+{
+  /** Sets up libmpg123 for you, and closes it on destruction. If you
+      want to do this yourself, send setup=false.
+   */
+  Mpg123Loader(bool setup=true);
+  ~Mpg123Loader();
+private:
+  bool didSetup;
+};
+
+}} // Namespace
+#endif

libs/mangle/sound/sources/sample_reader.cpp

@@ -0,0 +1,99 @@
+#include "sample_reader.hpp"
+
+#include <string.h>
+
+using namespace Mangle::Sound;
+
+void SampleReader::setup(int size)
+{
+  pullSize = 0;
+  frameSize = size;
+  pullOver = new char[size];
+}
+
+SampleReader::~SampleReader()
+{
+  if(pullOver)
+    delete[] pullOver;
+}
+
+size_t SampleReader::read(void *_data, size_t length)
+{
+  if(isEof) return 0;
+  char *data = (char*)_data;
+
+  // Pullsize holds the number of bytes that were copied "extra" at
+  // the end of LAST round. If non-zero, it also means there is data
+  // left in the pullOver buffer.
+  if(pullSize)
+    {
+      // Amount of data left
+      size_t doRead = frameSize - pullSize;
+      assert(doRead > 0);
+
+      // Make sure we don't read more than we're supposed to
+      if(doRead > length) doRead = length;
+
+      memcpy(data, pullOver+pullSize, doRead);
+
+      // Update the number of bytes now copied
+      pullSize += doRead;
+      assert(pullSize <= frameSize);
+
+      if(pullSize < frameSize)
+        {
+          // There is STILL data left in the pull buffer, and we've
+          // done everything we were supposed to. Leave it and return.
+          assert(doRead == length);
+          return doRead;
+        }
+
+      // Set up variables for further reading below. No need to update
+      // pullSize, it is overwritten anyway.
+      length -= doRead;
+      data += doRead;
+    }
+
+  // Number of whole frames
+  size_t frames = length / frameSize;
+
+  // Read the data
+  size_t res = readSamples(data, frames);
+  assert(res <= frames);
+
+  // Total bytes read
+  size_t num = res*frameSize;
+  data += num;
+
+  if(res < frames)
+    {
+      // End of stream.
+      isEof = true;
+      // Determine how much we read
+      return data-(char*)_data;
+    }
+
+  // Determine the overshoot
+  pullSize = length - num;
+  assert(pullSize < frameSize && pullSize >= 0);
+
+  // Are we missing data?
+  if(pullSize)
+    {
+      // Fill in one sample
+      res = readSamples(pullOver,1);
+      assert(res == 1 || res == 0);
+      if(res)
+        {
+          // Move as much as we can into the output buffer
+          memcpy(data, pullOver, pullSize);
+          data += pullSize;
+        }
+      else
+        // Failed reading, we're out of data
+        isEof = true;
+    }
+
+  // Return the total number of bytes stored
+  return data-(char*)_data;
+}

libs/mangle/sound/sources/sample_reader.hpp

@@ -0,0 +1,48 @@
+#ifndef MANGLE_SOUND_SAMPLE_READER_H
+#define MANGLE_SOUND_SAMPLE_READER_H
+
+#include "../source.hpp"
+
+namespace Mangle {
+namespace Sound {
+
+  /* This is a helper base class for other SampleSource
+     implementations. Certain sources (like Audiere and libsndfile)
+     insist on reading whole samples rather than bytes. This class
+     compensates for that, and allows you to read bytes rather than
+     samples.
+
+     There are two ways for subclasses to use this class. EITHER call
+     setup() with the size of frameSize. This will allocate a buffer,
+     which the destructor frees. OR set frameSize manually and
+     manipulate the pullOver pointer yourself. In that case you MUST
+     reset it to NULL if you don't want the destructor to call
+     delete[] on it.
+   */
+class SampleReader : public SampleSource
+{
+  // How much of the above buffer is in use.
+  int pullSize;
+
+protected:
+  // Pullover buffer
+  char* pullOver;
+
+  // Size of one frame, in bytes. This is also the size of the
+  // pullOver buffer.
+  int frameSize;
+
+  // The parameter gives the size of one sample/frame, in bytes.
+  void setup(int);
+
+  // Read the given number of samples, in multiples of frameSize. Does
+  // not have to set or respect isEof.
+  virtual size_t readSamples(void *data, size_t num) = 0;
+
+ public:
+  SampleReader() : pullSize(0), pullOver(NULL) {}
+  ~SampleReader();
+  size_t read(void *data, size_t length);
+};
+}} // Namespace
+#endif

libs/mangle/sound/sources/stream_source.hpp

@@ -0,0 +1,47 @@
+#ifndef MANGLE_SOUND_STREAMSOURCE_H
+#define MANGLE_SOUND_STREAMSOURCE_H
+
+#include "../source.hpp"
+
+namespace Mangle {
+namespace Sound {
+
+/// A class for reading raw samples directly from a stream.
+class Stream2Samples : public SampleSource
+{
+  Mangle::Stream::StreamPtr inp;
+  int32_t rate, channels, bits;
+
+ public:
+  Stream2Samples(Mangle::Stream::StreamPtr _inp, int32_t _rate, int32_t _channels, int32_t _bits)
+   : inp(_inp), rate(_rate), channels(_channels), bits(_bits)
+    {
+      isSeekable = inp->isSeekable;
+      hasPosition = inp->hasPosition;
+      hasSize = inp->hasSize;
+      hasPtr = inp->hasPtr;
+    }
+
+  /// Get the sample rate, number of channels, and bits per
+  /// sample. NULL parameters are ignored.
+  void getInfo(int32_t *_rate, int32_t *_channels, int32_t *_bits)
+  {
+    if(_rate) *_rate = rate;
+    if(_channels) *_channels = channels;
+    if(_bits) *_bits = bits;
+  }
+
+  size_t read(void *out, size_t count)
+    { return inp->read(out, count); }
+
+  void seek(size_t pos) { inp->seek(pos); }
+  size_t tell() const { return inp->tell(); }
+  size_t size() const { return inp->size(); }
+  bool eof() const { return inp->eof(); }
+  const void *getPtr() { return inp->getPtr(); }
+  const void *getPtr(size_t size) { return inp->getPtr(size); }
+  const void *getPtr(size_t pos, size_t size) { return inp->getPtr(pos, size); }
+};
+
+}} // namespaces
+#endif

libs/mangle/sound/sources/wav_source.cpp

@@ -0,0 +1,99 @@
+#include "wav_source.hpp"
+
+#include "../../stream/servers/file_stream.hpp"
+
+#include <stdexcept>
+
+using namespace Mangle::Stream;
+using namespace Mangle::Sound;
+
+static void fail(const std::string &msg)
+{ throw std::runtime_error("Mangle::Wav exception: " + msg); }
+
+void WavSource::getInfo(int32_t *pRate, int32_t *pChannels, int32_t *pBits)
+{
+  // Use the values we found in the constructor
+  *pRate = rate;
+  *pChannels = channels;
+  *pBits = bits;
+}
+
+void WavSource::seek(size_t pos)
+{
+  // Seek the stream and set 'left'
+  assert(isSeekable);
+  if(pos > total) pos = total;
+  input->seek(dataOffset + pos);
+  left = total-pos;
+}
+
+size_t WavSource::read(void *data, size_t length)
+{
+  if(length > left)
+    length = left;
+  size_t read = input->read(data, length);
+  if(read < length)
+    // Something went wrong
+    fail("WAV read error");
+  return length;
+}
+
+void WavSource::open(Mangle::Stream::StreamPtr data)
+{
+  input = data;
+
+  hasPosition = true;
+  hasSize = true;
+  // If we can check position and seek in the input stream, then we
+  // can seek the wav data too.
+  isSeekable = input->isSeekable && input->hasPosition;
+
+  // Read header
+  unsigned int val;
+
+  input->read(&val,4);  // header
+  if(val != 0x46464952) // "RIFF"
+    fail("Not a WAV file");
+
+  input->read(&val,4);  // size (ignored)
+  input->read(&val,4);  // file format
+  if(val != 0x45564157) // "WAVE"
+    fail("Not a valid WAV file");
+
+  input->read(&val,4);  // "fmt "
+  input->read(&val,4);  // chunk size (must be 16)
+  if(val != 16)
+    fail("Unsupported WAV format");
+
+  input->read(&val,2);
+  if(val != 1)
+    fail("Non-PCM (compressed) WAV files not supported");
+
+  // Sound data specification
+  channels = 0;
+  input->read(&channels,2);
+  input->read(&rate, 4);
+
+  // Skip next 6 bytes
+  input->read(&val, 4);
+  input->read(&val, 2);
+
+  // Bits per sample
+  bits = 0;
+  input->read(&bits,2);
+
+  input->read(&val,4);  // Data header
+  if(val != 0x61746164) // "data"
+    fail("Expected data block");
+
+  // Finally, read the data size
+  input->read(&total,4);
+  left = total;
+
+  // Store the beginning of the data block for later
+  if(input->hasPosition)
+    dataOffset = input->tell();
+}
+
+WavSource::WavSource(const std::string &file)
+{ open(StreamPtr(new FileStream(file))); }

libs/mangle/sound/sources/wav_source.hpp

@@ -0,0 +1,49 @@
+#ifndef MANGLE_SOUND_WAV_SOURCE_H
+#define MANGLE_SOUND_WAV_SOURCE_H
+
+#include "../source.hpp"
+#include <assert.h>
+
+namespace Mangle {
+namespace Sound {
+
+/// WAV file decoder. Has no external library dependencies.
+class WavSource : public SampleSource
+{
+  // Sound info
+  uint32_t rate, channels, bits;
+
+  // Total size (of output) and bytes left
+  uint32_t total, left;
+
+  // Offset in input of the beginning of the data block
+  size_t dataOffset;
+
+  Mangle::Stream::StreamPtr input;
+
+  void open(Mangle::Stream::StreamPtr);
+
+ public:
+  /// Decode the given sound file
+  WavSource(const std::string&);
+
+  /// Decode from stream
+  WavSource(Mangle::Stream::StreamPtr s)
+  { open(s); }
+
+  void getInfo(int32_t *rate, int32_t *channels, int32_t *bits);
+  size_t read(void *data, size_t length);
+
+  void seek(size_t);
+  size_t tell() const { return total-left; }
+  size_t size() const { return total; }
+  bool eof() const { return left > 0; }
+};
+
+#include "loadertemplate.hpp"
+
+/// A factory that loads WavSources from file and stream
+typedef SSL_Template<WavSource,true,true> WavLoader;
+
+}} // Namespace
+#endif

libs/mangle/sound/tests/.gitignore

@@ -0,0 +1 @@
+*_test

libs/mangle/sound/tests/Makefile

@@ -0,0 +1,38 @@
+GCC=g++ -I../ -Wall
+
+all: audiere_source_test ffmpeg_source_test openal_output_test openal_audiere_test openal_ffmpeg_test openal_mpg123_test openal_sndfile_test wav_source_test openal_various_test
+
+L_FFMPEG=$(shell pkg-config --libs libavcodec libavformat)
+I_FFMPEG=-I/usr/include/libavcodec -I/usr/include/libavformat
+L_OPENAL=$(shell pkg-config --libs openal)
+L_AUDIERE=-laudiere
+
+wav_source_test: wav_source_test.cpp ../sources/wav_source.cpp
+	$(GCC) $^ -o $@
+
+openal_various_test: openal_various_test.cpp ../sources/mpg123_source.cpp ../sources/wav_source.cpp ../outputs/openal_out.cpp
+	$(GCC) $^ -o $@ -lmpg123 ${L_OPENAL}
+
+openal_audiere_test: openal_audiere_test.cpp ../sources/audiere_source.cpp ../sources/sample_reader.cpp ../outputs/openal_out.cpp ../../stream/clients/audiere_file.cpp
+	$(GCC) $^ -o $@ $(L_AUDIERE) $(L_OPENAL)
+
+openal_ffmpeg_test: openal_ffmpeg_test.cpp ../sources/ffmpeg_source.cpp ../outputs/openal_out.cpp
+	$(GCC) $^ -o $@ $(L_FFMPEG) $(L_OPENAL) $(I_FFMPEG)
+
+openal_mpg123_test: openal_mpg123_test.cpp ../sources/mpg123_source.cpp ../outputs/openal_out.cpp
+	$(GCC) $^ -o $@ -lmpg123 ${L_OPENAL}
+
+openal_sndfile_test: openal_sndfile_test.cpp ../sources/libsndfile.cpp ../sources/sample_reader.cpp ../outputs/openal_out.cpp
+	$(GCC) $^ -o $@ -lsndfile ${L_OPENAL}
+
+openal_output_test: openal_output_test.cpp ../outputs/openal_out.cpp
+	$(GCC) $^ -o $@ $(L_OPENAL)
+
+audiere_source_test: audiere_source_test.cpp ../sources/audiere_source.cpp ../../stream/clients/audiere_file.cpp ../sources/sample_reader.cpp
+	$(GCC) $^ -o $@ $(L_AUDIERE)
+
+ffmpeg_source_test: ffmpeg_source_test.cpp ../sources/ffmpeg_source.cpp
+	$(GCC) $^ -o $@ $(L_FFMPEG) $(I_FFMPEG)
+
+clean:
+	rm *_test

libs/mangle/sound/tests/audiere_source_test.cpp

@@ -0,0 +1,68 @@
+#include <iostream>
+
+#include "../../stream/servers/file_stream.hpp"
+#include "../sources/audiere_source.hpp"
+
+#include <assert.h>
+#include <string.h>
+
+using namespace std;
+using namespace Mangle::Stream;
+using namespace Mangle::Sound;
+
+// Contents and size of cow.raw
+void *orig;
+size_t orig_size;
+
+void run(SampleSourcePtr &src)
+{
+  size_t ss = src->size();
+  assert(ss == orig_size);
+
+  cout << "Source size: " << ss << endl;
+  int rate, channels, bits;
+  src->getInfo(&rate, &channels, &bits);
+  cout << "rate=" << rate << "\nchannels=" << channels
+       << "\nbits=" << bits << endl;
+
+  cout << "Reading entire buffer into memory\n";
+  void *buf = malloc(ss);
+  src->read(buf, ss);
+
+  cout << "Comparing...\n";
+  if(memcmp(buf, orig, ss) != 0)
+    {
+      cout << "Oops!\n";
+      assert(0);
+    }
+
+  cout << "Done\n";
+}
+
+int main()
+{
+  {
+    cout << "Reading cow.raw first\n";
+    FileStream tmp("cow.raw");
+    orig_size = tmp.size();
+    cout << "Size: " << orig_size << endl;
+    orig = malloc(orig_size);
+    tmp.read(orig, orig_size);
+    cout << "Done\n";
+  }
+
+  {
+    cout << "\nLoading cow.wav by filename:\n";
+    SampleSourcePtr cow_file( new AudiereSource("cow.wav") );
+    run(cow_file);
+  }
+
+  {
+    cout << "\nLoading cow.wav by stream:\n";
+    StreamPtr inp( new FileStream("cow.wav") );
+    SampleSourcePtr cow_stream( new AudiereSource(inp) );
+    run(cow_stream);
+  }
+
+  return 0;
+}

libs/mangle/sound/tests/ffmpeg_source_test.cpp

@@ -0,0 +1,62 @@
+#include <iostream>
+
+#include "../../stream/servers/file_stream.hpp"
+#include "../sources/ffmpeg_source.hpp"
+
+#include <assert.h>
+#include <string.h>
+
+using namespace std;
+using namespace Mangle::Stream;
+using namespace Mangle::Sound;
+
+// Contents and size of cow.raw
+void *orig;
+size_t orig_size;
+
+void run(SampleSourcePtr &src)
+{
+  int rate, channels, bits;
+  src->getInfo(&rate, &channels, &bits);
+  cout << "rate=" << rate << "\nchannels=" << channels
+       << "\nbits=" << bits << endl;
+
+  cout << "Reading entire buffer into memory\n";
+  void *buf = malloc(orig_size);
+  size_t ss = src->read(buf, orig_size);
+  cout << "Actually read: " << ss << endl;
+  assert(ss == orig_size);
+
+  cout << "Comparing...\n";
+  if(memcmp(buf, orig, ss) != 0)
+    {
+      cout << "Oops!\n";
+      assert(0);
+    }
+
+  cout << "Done\n";
+}
+
+int main()
+{
+  {
+    cout << "Reading cow.raw first\n";
+    FileStream tmp("cow.raw");
+    orig_size = tmp.size();
+    cout << "Size: " << orig_size << endl;
+    orig = malloc(orig_size);
+    tmp.read(orig, orig_size);
+    cout << "Done\n";
+  }
+
+  // Initializes the library, not used for anything else.
+  FFMpegLoader fm;
+
+  {
+    cout << "\nLoading cow.wav by filename:\n";
+    SampleSourcePtr cow_file( new FFMpegSource("cow.wav") );
+    run(cow_file);
+  }
+
+  return 0;
+}

libs/mangle/sound/tests/openal_audiere_test.cpp

@@ -0,0 +1,52 @@
+#include <iostream>
+#include <exception>
+
+#include "../../stream/servers/file_stream.hpp"
+#include "../filters/openal_audiere.hpp"
+
+using namespace std;
+using namespace Mangle::Stream;
+using namespace Mangle::Sound;
+
+OpenAL_Audiere_Factory mg;
+
+void play(const char* name, bool stream=false)
+{
+  // Only load streams if the backend supports it
+  if(stream && !mg.canLoadStream)
+    return;
+
+  cout << "Playing " << name;
+  if(stream) cout << " (from stream)";
+  cout << "\n";
+
+  SoundPtr snd;
+
+  try
+    {
+      if(stream)
+        snd = mg.load(StreamPtr(new FileStream(name)));
+      else
+        snd = mg.load(name);
+
+      snd->play();
+
+      while(snd->isPlaying())
+        {
+          usleep(10000);
+          if(mg.needsUpdate) mg.update();
+        }
+    }
+  catch(exception &e)
+    {
+      cout << "  ERROR: " << e.what() << "\n";
+    }
+}
+
+int main()
+{
+  play("cow.wav");
+  play("owl.ogg");
+  play("cow.wav", true);
+  return 0;
+}

libs/mangle/sound/tests/openal_ffmpeg_test.cpp

@@ -0,0 +1,52 @@
+#include <iostream>
+#include <exception>
+
+#include "../../stream/servers/file_stream.hpp"
+#include "../filters/openal_ffmpeg.hpp"
+
+using namespace std;
+using namespace Mangle::Stream;
+using namespace Mangle::Sound;
+
+OpenAL_FFMpeg_Factory mg;
+
+void play(const char* name, bool stream=false)
+{
+  // Only load streams if the backend supports it
+  if(stream && !mg.canLoadStream)
+    return;
+
+  cout << "Playing " << name;
+  if(stream) cout << " (from stream)";
+  cout << "\n";
+
+  SoundPtr snd;
+
+  try
+    {
+      if(stream)
+        snd = mg.load(StreamPtr(new FileStream(name)));
+      else
+        snd = mg.load(name);
+
+      snd->play();
+
+      while(snd->isPlaying())
+        {
+          usleep(10000);
+          if(mg.needsUpdate) mg.update();
+        }
+    }
+  catch(exception &e)
+    {
+      cout << "  ERROR: " << e.what() << "\n";
+    }
+}
+
+int main()
+{
+  play("cow.wav");
+  play("owl.ogg");
+  play("cow.wav", true);
+  return 0;
+}

libs/mangle/sound/tests/openal_mpg123_test.cpp

@@ -0,0 +1,54 @@
+#include <iostream>
+#include <exception>
+
+#include "../../stream/servers/file_stream.hpp"
+#include "../filters/openal_mpg123.hpp"
+
+using namespace std;
+using namespace Mangle::Stream;
+using namespace Mangle::Sound;
+
+OpenAL_Mpg123_Factory mg;
+
+void play(const char* name, bool stream=false)
+{
+  // Only load streams if the backend supports it
+  if(stream && !mg.canLoadStream)
+    return;
+
+  cout << "Playing " << name;
+  if(stream) cout << " (from stream)";
+  cout << "\n";
+
+  SoundPtr snd;
+
+  try
+    {
+      if(stream)
+        snd = mg.load(StreamPtr(new FileStream(name)));
+      else
+        snd = mg.load(name);
+
+      snd->setStreaming(true);
+      snd->play();
+
+      while(snd->isPlaying())
+        {
+          usleep(10000);
+          if(mg.needsUpdate) mg.update();
+        }
+    }
+  catch(exception &e)
+    {
+      cout << "  ERROR: " << e.what() << "\n";
+    }
+}
+
+int main(int argc, char**argv)
+{
+  if(argc != 2)
+    cout << "Please specify an MP3 file\n";
+  else
+    play(argv[1]);
+  return 0;
+}

libs/mangle/sound/tests/openal_output_test.cpp

@@ -0,0 +1,59 @@
+#include <iostream>
+#include <exception>
+
+#include "../../stream/servers/file_stream.hpp"
+#include "../sources/stream_source.hpp"
+#include "../outputs/openal_out.hpp"
+
+using namespace std;
+using namespace Mangle::Stream;
+using namespace Mangle::Sound;
+
+int main()
+{
+  cout << "Loading cow.raw\n";
+
+  int rate = 11025;
+  int chan = 1;
+  int bits = 16;
+
+  cout << "  rate=" << rate << "\n  channels=" << chan
+       << "\n  bits=" << bits << endl;
+
+  StreamPtr file( new FileStream("cow.raw") );
+  SampleSourcePtr source( new Stream2Samples( file, rate, chan, bits));
+
+  cout << "Playing\n";
+
+  OpenAL_Factory mg;
+
+  SoundPtr snd = mg.loadRaw(source);
+
+  try
+    {
+      // Try setting all kinds of stuff before playing. OpenAL_Sound
+      // uses delayed buffer loading, but these should still work
+      // without a buffer.
+      snd->stop();
+      snd->pause();
+      snd->setVolume(0.8);
+      snd->setPitch(0.9);
+
+      // Also test streaming, since all the other examples test
+      // non-streaming sounds.
+      snd->setStreaming(true);
+
+      snd->play();
+
+      while(snd->isPlaying())
+        {
+          usleep(10000);
+          mg.update();
+        }
+    }
+  catch(exception &e)
+    {
+      cout << "  ERROR: " << e.what() << "\n";
+    }
+  return 0;
+}

libs/mangle/sound/tests/openal_sndfile_test.cpp

@@ -0,0 +1,52 @@
+#include <iostream>
+#include <exception>
+
+#include "../../stream/servers/file_stream.hpp"
+#include "../filters/openal_sndfile.hpp"
+
+using namespace std;
+using namespace Mangle::Stream;
+using namespace Mangle::Sound;
+
+OpenAL_SndFile_Factory mg;
+
+void play(const char* name, bool stream=false)
+{
+  // Only load streams if the backend supports it
+  if(stream && !mg.canLoadStream)
+    return;
+
+  cout << "Playing " << name;
+  if(stream) cout << " (from stream)";
+  cout << "\n";
+
+  SoundPtr snd;
+
+  try
+    {
+      if(stream)
+        snd = mg.load(StreamPtr(new FileStream(name)));
+      else
+        snd = mg.load(name);
+
+      snd->play();
+
+      while(snd->isPlaying())
+        {
+          usleep(10000);
+          if(mg.needsUpdate) mg.update();
+        }
+    }
+  catch(exception &e)
+    {
+      cout << "  ERROR: " << e.what() << "\n";
+    }
+}
+
+int main()
+{
+  play("cow.wav");
+  play("owl.ogg");
+  play("cow.wav", true);
+  return 0;
+}

libs/mangle/sound/tests/openal_various_test.cpp

@@ -0,0 +1,51 @@
+#include <iostream>
+#include <exception>
+
+#include "../../stream/servers/file_stream.hpp"
+#include "../filters/openal_various.hpp"
+
+using namespace std;
+using namespace Mangle::Stream;
+using namespace Mangle::Sound;
+
+OpenAL_Various_Factory mg;
+
+void play(const char* name, bool stream=false)
+{
+  // Only load streams if the backend supports it
+  if(stream && !mg.canLoadStream)
+    return;
+
+  cout << "Playing " << name;
+  if(stream) cout << " (from stream)";
+  cout << "\n";
+
+  SoundPtr snd;
+
+  try
+    {
+      if(stream)
+        snd = mg.load(StreamPtr(new FileStream(name)));
+      else
+        snd = mg.load(name);
+
+      snd->play();
+
+      while(snd->isPlaying())
+        {
+          usleep(10000);
+          if(mg.needsUpdate) mg.update();
+        }
+    }
+  catch(exception &e)
+    {
+      cout << "  ERROR: " << e.what() << "\n";
+    }
+}
+
+int main()
+{
+  play("cow.wav");
+  play("cow.wav", true);
+  return 0;
+}

libs/mangle/sound/tests/output/audiere_source_test.out

@@ -0,0 +1,21 @@
+Reading cow.raw first
+Size: 37502
+Done
+
+Loading cow.wav by filename:
+Source size: 37502
+rate=11025
+channels=1
+bits=16
+Reading entire buffer into memory
+Comparing...
+Done
+
+Loading cow.wav by stream:
+Source size: 37502
+rate=11025
+channels=1
+bits=16
+Reading entire buffer into memory
+Comparing...
+Done

libs/mangle/sound/tests/output/ffmpeg_source_test.out

@@ -0,0 +1,12 @@
+Reading cow.raw first
+Size: 37502
+Done
+
+Loading cow.wav by filename:
+rate=11025
+channels=1
+bits=16
+Reading entire buffer into memory
+Actually read: 37502
+Comparing...
+Done

libs/mangle/sound/tests/output/openal_audiere_test.out

@@ -0,0 +1,3 @@
+Playing cow.wav
+Playing owl.ogg
+Playing cow.wav (from stream)

libs/mangle/sound/tests/output/openal_ffmpeg_test.out

@@ -0,0 +1,2 @@
+Playing cow.wav
+Playing owl.ogg

libs/mangle/sound/tests/output/openal_mpg123_test.out

@@ -0,0 +1 @@
+Please specify an MP3 file

libs/mangle/sound/tests/output/openal_output_test.out

@@ -0,0 +1,5 @@
+Loading cow.raw
+  rate=11025
+  channels=1
+  bits=16
+Playing

libs/mangle/sound/tests/output/openal_sndfile_test.out

@@ -0,0 +1,2 @@
+Playing cow.wav
+Playing owl.ogg

libs/mangle/sound/tests/output/openal_various_test.out

@@ -0,0 +1 @@
+Playing cow.wav

libs/mangle/sound/tests/output/wav_source_test.out

@@ -0,0 +1,12 @@
+Source size: 37502
+rate=11025
+channels=1
+bits=16
+Reading entire buffer into memory
+
+Reading cow.raw
+Size: 37502
+
+Comparing...
+
+Done

libs/mangle/sound/tests/test.sh

@@ -0,0 +1,18 @@
+#!/bin/bash
+
+make || exit
+
+mkdir -p output
+
+PROGS=*_test
+
+for a in $PROGS; do
+    if [ -f "output/$a.out" ]; then
+        echo "Running $a:"
+        ./$a | diff output/$a.out -
+    else
+        echo "Creating $a.out"
+        ./$a > "output/$a.out"
+        git add "output/$a.out"
+    fi
+done

libs/mangle/sound/tests/wav_source_test.cpp

@@ -0,0 +1,48 @@
+#include <iostream>
+
+#include "../sources/wav_source.hpp"
+#include "../../stream/servers/file_stream.hpp"
+
+#include <assert.h>
+#include <string.h>
+
+using namespace std;
+using namespace Mangle::Sound;
+using namespace Mangle::Stream;
+
+int main()
+{
+  WavSource wav("cow.wav");
+
+  cout << "Source size: " << wav.size() << endl;
+  int rate, channels, bits;
+  wav.getInfo(&rate, &channels, &bits);
+  cout << "rate=" << rate << "\nchannels=" << channels
+       << "\nbits=" << bits << endl;
+
+  cout << "Reading entire buffer into memory\n";
+  void *buf = malloc(wav.size());
+  wav.read(buf, wav.size());
+
+  cout << "\nReading cow.raw\n";
+  FileStream tmp("cow.raw");
+  cout << "Size: " << tmp.size() << endl;
+  void *buf2 = malloc(tmp.size());
+  tmp.read(buf2, tmp.size());
+
+  cout << "\nComparing...\n";
+  if(tmp.size() != wav.size())
+    {
+      cout << "SIZE MISMATCH!\n";
+      assert(0);
+    }
+
+  if(memcmp(buf, buf2, wav.size()) != 0)
+    {
+      cout << "CONTENT MISMATCH!\n";
+      assert(0);
+    }
+
+  cout << "\nDone\n";
+  return 0;
+}

libs/mangle/stream/clients/audiere_file.cpp

@@ -0,0 +1,32 @@
+#include "audiere_file.hpp"
+
+using namespace audiere;
+using namespace Mangle::Stream;
+
+bool AudiereFile::seek(int pos, SeekMode mode)
+{
+  assert(inp->isSeekable);
+  assert(inp->hasPosition);
+
+  size_t newPos;
+
+  switch(mode)
+    {
+    case BEGIN: newPos = pos; break;
+    case CURRENT: newPos = pos+tell(); break;
+    case END:
+      // Seeking from the end. This requires that we're able to get
+      // the entire size of the stream. The pos also has to be
+      // non-positive.
+      assert(inp->hasSize);
+      assert(pos <= 0);
+      newPos = inp->size() + pos;
+      break;
+    default:
+      assert(0 && "invalid seek mode");
+    }
+
+  inp->seek(newPos);
+  return inp->tell() == newPos;
+
+}

libs/mangle/stream/clients/audiere_file.hpp

@@ -0,0 +1,38 @@
+#ifndef MANGLE_STREAM_AUDIERECLIENT_H
+#define MANGLE_STREAM_AUDIERECLIENT_H
+
+#include <audiere.h>
+#include <assert.h>
+
+#include "../stream.hpp"
+
+namespace Mangle {
+namespace Stream {
+
+/** @brief An Audiere::File that wraps a Mangle::Stream input.
+
+    This lets Audiere read sound files from any generic archive or
+    file manager that supports Mangle streams.
+ */
+class AudiereFile : public audiere::RefImplementation<audiere::File>
+{
+  StreamPtr inp;
+
+ public:
+  AudiereFile(StreamPtr _inp)
+    : inp(_inp) {}
+
+  /// Read 'count' bytes, return bytes successfully read
+  int ADR_CALL read(void *buf, int count)
+    { return inp->read(buf,count); }
+
+  /// Seek, relative to specified seek mode. Returns true if successful.
+  bool ADR_CALL seek(int pos, audiere::File::SeekMode mode);
+
+  /// Get current position
+  int ADR_CALL tell()
+    { assert(inp->hasPosition); return inp->tell(); }
+};
+
+}} // namespaces
+#endif

libs/mangle/stream/clients/io_stream.cpp

@@ -0,0 +1,221 @@
+#include "io_stream.hpp"
+
+// This seems to work
+#ifndef EOF
+#define EOF -1
+#endif
+
+using namespace Mangle::Stream;
+
+#define BSIZE 1024
+
+// Streambuf for normal stream reading
+class _istreambuf : public std::streambuf
+{
+  StreamPtr client;
+  char buf[BSIZE];
+
+public:
+  _istreambuf(StreamPtr strm) : client(strm)
+  {
+    // Make sure we picked the right class
+    assert(client->isReadable);
+    assert(!client->hasPtr);
+
+    // Tell streambuf to delegate reading operations to underflow()
+    setg(NULL,NULL,NULL);
+
+    // Disallow writing
+    setp(NULL,NULL);
+  }
+
+  /* Underflow is called when there is no more info to read in the
+     input buffer. We need to refill buf with new data (if any), and
+     set up the internal pointers with setg() to reflect the new
+     state.
+  */
+  int underflow()
+  {
+    // Read some more data
+    size_t read = client->read(buf, BSIZE);
+    assert(read <= BSIZE);
+
+    // If we're out of data, then EOF
+    if(read == 0)
+      return EOF;
+
+    // Otherwise, set up input buffer
+    setg(buf, buf, buf+read);
+
+    // Return the first char
+    return *((unsigned char*)buf);
+  }
+
+  // Seek stream, if the source supports it. Ignores the second
+  // parameter as Mangle doesn't separate input and output pointers.
+  std::streampos seekpos(std::streampos pos, std::ios_base::openmode = std::ios_base::in)
+  {
+    // Does this stream know how to seek?
+    if(!client->isSeekable || !client->hasPosition)
+      // If not, signal an error.
+      return -1;
+
+    // Set stream position and reset the buffer.
+    client->seek(pos);
+    setg(NULL,NULL,NULL);
+
+    return client->tell();
+  }
+};
+
+// Streambuf optimized for pointer-based input streams
+class _ptrstreambuf : public std::streambuf
+{
+  StreamPtr client;
+
+public:
+  _ptrstreambuf(StreamPtr strm) : client(strm)
+  {
+    // Make sure we picked the right class
+    assert(client->isReadable);
+    assert(client->hasPtr);
+
+    // seekpos() does all the work
+    seekpos(0);
+  }
+
+  // Underflow is only called when we're at the end of the file
+  int underflow() { return EOF; }
+
+  // Seek to a new position within the memory stream. This bypasses
+  // client->seek() entirely so isSeekable doesn't have to be set.
+  std::streampos seekpos(std::streampos pos, std::ios_base::openmode = std::ios_base::in)
+  {
+    // All pointer streams need a size
+    assert(client->hasSize);
+
+    // Figure out how much will be left of the stream after seeking
+    size_t size = client->size() - pos;
+
+    // Get a pointer
+    char* ptr = (char*)client->getPtr(pos,size);
+
+    // And use it
+    setg(ptr,ptr,ptr+size);
+
+    return pos;
+  }
+};
+
+// Streambuf for stream writing
+class _ostreambuf : public std::streambuf
+{
+  StreamPtr client;
+  char buf[BSIZE];
+
+public:
+  _ostreambuf(StreamPtr strm) : client(strm)
+  {
+    // Make sure we picked the right class
+    assert(client->isWritable);
+
+    // Inform streambuf about our nice buffer
+    setp(buf, buf+BSIZE);
+
+    // Disallow reading
+    setg(NULL,NULL,NULL);
+  }
+
+  /* Sync means to flush (write) all current data to the output
+     stream. It will also set up the entire output buffer to be usable
+     again.
+  */
+  int sync()
+  {
+    // Get the number of bytes that streambuf wants us to write
+    int num = pptr() - pbase();
+    assert(num >= 0);
+
+    // Is there any work to do?
+    if(num == 0) return 0;
+
+    if((int)client->write(pbase(), num) != num)
+      // Inform caller that writing failed
+      return -1;
+
+    // Reset output buffer pointers
+    setp(buf, buf+BSIZE);
+
+    // No error
+    return 0;
+  }
+
+  /* Called whenever the output buffer is full.
+   */
+  int overflow(int c)
+  {
+    // First, write all existing data
+    if(sync()) return EOF;
+
+    // Put the requested character in the next round of output
+    if(c != EOF)
+      {
+        *pptr() = c;
+        pbump(1);
+      }
+
+    // No error
+    return 0;
+  }
+
+  // Seek stream, if the source supports it.
+  std::streampos seekpos(std::streampos pos, std::ios_base::openmode = std::ios_base::out)
+  {
+    if(!client->isSeekable || !client->hasPosition)
+      return -1;
+
+    // Flush data and reset buffers
+    sync();
+
+    // Set stream position
+    client->seek(pos);
+
+    return client->tell();
+  }
+};
+
+MangleIStream::MangleIStream(StreamPtr inp)
+  : std::istream(NULL)
+{
+  assert(inp->isReadable);
+
+  // Pick the right streambuf implementation based on whether the
+  // input supports pointers or not.
+  if(inp->hasPtr)
+    buf = new _ptrstreambuf(inp);
+  else
+    buf = new _istreambuf(inp);
+
+  rdbuf(buf);
+}
+
+MangleIStream::~MangleIStream()
+{
+  delete buf;
+}
+
+MangleOStream::MangleOStream(StreamPtr out)
+  : std::ostream(NULL)
+{
+  assert(out->isWritable);
+  buf = new _ostreambuf(out);
+
+  rdbuf(buf);
+}
+
+MangleOStream::~MangleOStream()
+{
+  // Make sure we don't have lingering data on exit
+  flush();
+  delete buf;
+}

libs/mangle/stream/clients/io_stream.hpp

@@ -0,0 +1,43 @@
+#ifndef MANGLE_STREAM_IOSTREAM_H
+#define MANGLE_STREAM_IOSTREAM_H
+
+#include <assert.h>
+#include "../stream.hpp"
+#include <iostream>
+
+namespace Mangle {
+namespace Stream {
+
+  /** This file contains classes for wrapping an std::istream or
+      std::ostream around a Mangle::Stream.
+
+      This allows you to use Mangle streams in places that require std
+      streams.
+
+      This is much easier than trying to make your own custom streams
+      into iostreams. The std::iostream interface is horrible and NOT
+      designed for easy subclassing. Create a Mangle::Stream instead,
+      and use this wrapper.
+  */
+
+  // An istream wrapping a readable Mangle::Stream. Has extra
+  // optimizations for pointer-based streams.
+  class MangleIStream : public std::istream
+  {
+    std::streambuf *buf;
+  public:
+    MangleIStream(StreamPtr inp);
+    ~MangleIStream();
+  };
+
+  // An ostream wrapping a writable Mangle::Stream.
+  class MangleOStream : public std::ostream
+  {
+    std::streambuf *buf;
+  public:
+    MangleOStream(StreamPtr inp);
+    ~MangleOStream();
+  };
+
+}} // namespaces
+#endif