* included SDL src as dep, but disabled build for now (now you do no longer need to install the precompiled SDL libs)

* some corrections to project files
* object classes improvements
* worked a bit on UPDATE_OBJECT stuff
* minor stuff i dont remember
* plz test VC2005 compatibility

src/Client/PseuWoW.cpp

@@ -41,8 +41,8 @@ void PseuInstanceRunnable::sleep(uint32 msecs)
 PseuInstance::PseuInstance(PseuInstanceRunnable *run)
 {
     _runnable=run;
-    _ver="PseuWoW Alpha Build 12" DEBUG_APPENDIX;
+    _ver="PseuWoW Alpha Build 13 development version 1" DEBUG_APPENDIX;
-    _ver_short="A12" DEBUG_APPENDIX;
+    _ver_short="A13-dev1" DEBUG_APPENDIX;
     _wsession=NULL;
     _rsession=NULL;
     _scp=NULL;
@@ -84,11 +84,6 @@ bool PseuInstance::Init(void) {
 	srand((unsigned)time(NULL));
 	RAND_set_rand_method(RAND_SSLeay()); // init openssl randomizer
 	
-	if(SDL_Init(0)==-1) {
-			log("SDL_Init: %s", SDL_GetError());
-			return false;
-		}
-	
 	_scp=new DefScriptPackage();
     _scp->SetParentMethod((void*)this);
 	_conf=new PseuInstanceConf();	

src/Client/World/ObjMgr.cpp

@@ -4,40 +4,46 @@
 
 ObjMgr::~ObjMgr()
 {
-    for(ObjList::iterator i = _obj.begin(); i!=_obj.end(); i++)
-    {
-        delete *i;
-    }
     for(ItemProtoList::iterator i = _iproto.begin(); i!=_iproto.end(); i++)
     {
         delete *i;
     }
+    // need to remove other objects also
 }
 
-
+void ObjMgr::Remove(uint64 guid)
-void ObjMgr::Add(Object *o)
 {
-    _obj.push_back(o);
+    _RemovePlayer(guid);
+    _RemoveItem(guid);
+    //_RemoveGO(guid);
+    //_RemoveDO(guid);
+    //_RemoveNpc(guid);
+    //_RemoveCorpse(guid);
 }
 
-Object *ObjMgr::GetObj(uint64 guid)
+void ObjMgr::_RemovePlayer(uint64 guid)
 {
-    for(ObjList::iterator i = _obj.begin(); i!=_obj.end(); i++)
+    for(PlayerList::iterator i = _players.begin(); i!=_players.end(); i++)
-        if((*i)->GetGUID() == guid)
-            return (*i);
-    return NULL;
-}
-
-void ObjMgr::RemoveObject(uint64 guid)
-{
-    for(ObjList::iterator i = _obj.begin(); i!=_obj.end(); i++)
     if((*i)->GetGUID() == guid)
     {
         delete *i;
-            _obj.erase(i);
+        _players.erase(i);
     }
 }
 
+void ObjMgr::Add(Player *o)
+{
+    _players.push_back(o);
+}
+
+Player *ObjMgr::GetPlayer(uint64 guid)
+{
+    for(PlayerList::iterator i = _players.begin(); i!=_players.end(); i++)
+        if((*i)->GetGUID() == guid)
+            return (*i);
+    return NULL;
+}
+
 void ObjMgr::Add(ItemProto *proto)
 {
     _iproto.push_back(proto);
@@ -71,5 +77,41 @@ bool ObjMgr::ItemNonExistent(uint32 id)
     return false;
 }
 
+void ObjMgr::_RemoveItem(uint64 guid)
+{
+    for(ItemList::iterator i = _items.begin(); i!=_items.end(); i++)
+        if((*i)->GetGUID() == guid)
+        {
+            delete *i;
+            _items.erase(i);
+        }
+}
+
+void ObjMgr::Add(Item *o)
+{
+    _items.push_back(o);
+}
+
+Item *ObjMgr::GetItem(uint64 guid)
+{
+    for(ItemList::iterator i = _items.begin(); i!=_items.end(); i++)
+        if((*i)->GetGUID() == guid)
+            return (*i);
+    return NULL;
+}
+
+Object *ObjMgr::GetObj(uint64 guid, uint8 type)
+{
+    switch (type)
+    {
+    case TYPEID_ITEM: return (Object*)GetItem(guid);
+    case TYPEID_PLAYER: return (Object*)GetPlayer(guid);
+    // TODO: need the other object types here
+    }
+    return NULL;
+}
+
+
+// TODO: add more object class functions here
 
     

src/Client/World/ObjMgr.h

@@ -2,32 +2,71 @@
 #define _OBJMGR_H
 
 #include <list>
+#include "Object.h"
+#include "Player.h"
+#include "Unit.h"
+#include "Item.h"
 
-class Object;
-struct ItemProto;
-
-typedef std::list<Object*> ObjList;
 typedef std::vector<ItemProto*> ItemProtoList;
+//typedef std::list<Npc*> NpcList;
+typedef std::list<Player*> PlayerList;
+typedef std::list<Item*> ItemList;
+//typedef std::list<Gameobject*> GOList;
+//typedef std::list<DynamicObject*> DOList;
+//typedef std::list<Corpse*> CorpseList;
+
 
 
 class ObjMgr
 {
 public:
     ~ObjMgr();
-    void Add(Object*);
+
-    void Add(ItemProto*);
+    // Item Prototype functions
-    void AddNonexistentItem(uint32);
-    bool ItemNonExistent(uint32);
-    Object *GetObj(uint64);
-    void RemoveObject(uint64);
-    uint32 GetObjectCount(void) { return _obj.size(); }
     uint32 GetItemProtoCount(void) { return _iproto.size(); }
     ItemProto *GetItemProto(uint32);
     ItemProto *GetItemProtoByPos(uint32);
+    void Add(ItemProto*);
+
+    // nonexistent items handler
+    void AddNonexistentItem(uint32);
+    bool ItemNonExistent(uint32);
+
+    // Player functions
+    void Add(Player*);
+    Player *GetPlayer(uint64 guid);
+    uint32 GetPlayersCount(void) { return _players.size(); }
+
+    // Item functions
+    void Add(Item*);
+    Item *GetItem(uint64);
+    uint32 GetItemsCount(void) { return _items.size(); }
+
+    // generic functions
+    void Remove(uint64); // remove all objects with that guid (should be only 1 object in total anyway)
+    Object *GetObj(uint64 guid, uint8 type = 0);
+
+
+private:
+    void _RemovePlayer(uint64);
+    void _RemoveItem(uint64);
+    //void _RemoveGO(uint64);
+    //void _RemoveDO(uint64);
+    //void _RemoveNpc(uint64);
+    //void _RemoveCorpse(uint64);
+
+
+
+
+
+
+
 
 private:
-    ObjList _obj;
     ItemProtoList _iproto;
+    PlayerList _players;
+    ItemList _items;
+
     std::vector<uint32> _noitem;
 
 };

src/Client/World/Object.cpp

@@ -13,6 +13,7 @@ Object::Object()
 
 Object::~Object()
 {
+    DEBUG(logdebug("~Object() id=%u ptr=0x%X valuesptr=0x%X",this->GetTypeId(),this,_uint32values));
     if(_uint32values)
         delete [] _uint32values;
 }
@@ -49,26 +50,13 @@ void WorldObject::SetPosition(float x, float y, float z, float o, uint16 _map)
     _o = o;
     _m = _map;
 }
-/*
-void WorldObject::_Create( uint64 guid, uint32 mapid, float x, float y, float z, float ang, uint32 entry )
-{
-Object::_Create(guid);
-
-    SetUInt32Value( OBJECT_FIELD_ENTRY,entry);
-
-    _m = mapid;
-    _x = x;
-    _y = y;
-    _z = z;
-    _o = ang;
-}
-*/
 
 void WorldSession::_HandleDestroyObjectOpcode(WorldPacket& recvPacket)
 {
     uint64 guid;
     recvPacket >> guid;
     logdebug("Destroy Object "I64FMT,guid);
-    objmgr.RemoveObject(guid);
+    objmgr.Remove(guid);
 }
 
+

src/Client/World/Object.h

@@ -71,6 +71,8 @@ public:
         _uint32values[ index ] = value;
     }
 
+    static uint32 GetValuesCountByTypeId(uint8);
+    
 protected:
     void _Create(uint64 guid);
     void _InitValues(void);
@@ -100,6 +102,22 @@ protected:
 
 };
 
+inline uint32 GetValuesCountByTypeId(uint8 tid)
+{
+    switch(tid)
+    {
+    case TYPEID_OBJECT: return OBJECT_END;
+    case TYPEID_UNIT: return UNIT_END;
+    case TYPEID_PLAYER: return PLAYER_END;
+    case TYPEID_ITEM: return ITEM_END;
+    case TYPEID_CONTAINER: return CONTAINER_END;
+    case TYPEID_GAMEOBJECT: return GAMEOBJECT_END;
+    case TYPEID_DYNAMICOBJECT: return DYNAMICOBJECT_END;
+    case TYPEID_CORPSE: return CORPSE_END;
+    }
+    return 0;
+}
+
 
 
 #endif

src/Client/World/Player.cpp

@@ -10,18 +10,18 @@
 #include "WorldSession.h"
 
 
-/*void Player::Init(PlayerEnum player)
+Player::Player() : Unit()
 {
-	this->player = player;
+    _type = TYPE_PLAYER;
+    _typeid = TYPEID_PLAYER;
+    _valuescount = PLAYER_END;
 }
 
-void PlayerSettings::SetActionButtons(WorldPacket &data)
+void Player::Create(uint64 guid)
 {
-	if (!init)
+    Object::_Create(guid);
-		return;
+}
 
-	// TODO: Implent this
-}*/
 
 /*void PlayerSettings::SetSpells(WorldPacket &data)
 {

src/Client/World/Player.h

@@ -4,6 +4,7 @@
 #include <vector>
 #include "WorldPacket.h"
 #include "SysDefs.h"
+#include "Unit.h"
 
 struct PlayerEnumItem
 {
@@ -41,15 +42,14 @@ private:
     
 };
 
-class Player
+class Player : public Unit
 {
 public:
-	void Init(PlayerEnum player);
+    Player();
+    void Create(uint64);
 
 private:
-	int hp;
+
-	int bar; // Mana/Energy/Rage
-	PlayerEnum player;
 };
 
 
@@ -59,11 +59,7 @@ private:
 class MyCharacter : public Player
 {
 public:
-    MyCharacter(WorldSession *ws)
+    MyCharacter();
-	{
-        _worldSession = ws;
-		_isbusy = false;
-	}
 
 	/*void SetActionButtons(WorldPacket &data);
 	void SetSpells(WorldPacket &data);
@@ -71,8 +67,7 @@ public:
 	void HandleCastResultOpcode(WorldPacket &packet);*/
 
 private:
-	bool _isbusy;
+
-	WorldSession *_worldSession;
 };
 
 

src/Client/World/Unit.cpp

@@ -5,5 +5,6 @@ Unit::Unit() : WorldObject()
 {
     _type = TYPE_UNIT;
     _typeid = TYPEID_UNIT;
+    _valuescount = UNIT_END;
 }
 

src/Client/World/UpdateData.cpp

@@ -4,6 +4,7 @@
 #include "UpdateData.h"
 #include "UpdateFields.h"
 #include "Object.h"
+#include "Unit.h"
 #include "ObjMgr.h"
 #include "UpdateMask.h"
 
@@ -33,33 +34,31 @@ void WorldSession::_HandleCompressedUpdateObjectOpcode(WorldPacket& recvPacket)
 
 void WorldSession::_HandleUpdateObjectOpcode(WorldPacket& recvPacket)
 {
-	//recvPacket.hexlike();
 	uint8 utype;
 	uint8 unk8;
 	uint32 usize, ublocks;
 	uint64 uguid;
 	recvPacket >> ublocks >> unk8;
 	logdebug("UpdateObject: ublocks=%u unk=%u",ublocks,unk8);
-	//while(true) // need to read full packet as soon as the structure is 100% known & implemented
+	while(true) // TODO: find out correct packet structure or this loop will fail!
-	// for now reading first object is enough
 	{
 		recvPacket >> utype;
-		logdebug("UpdateObject: utype=%u",utype);
+		logdebug("-UpdateObject: utype=%u",utype);
 		switch(utype)
 		{
 		case UPDATETYPE_VALUES:
 			{
 				uint8 blockcount, masksize;
-				uint32 value, valuesCount = 1500;
+                uint32 value, valuesCount = GetValuesCountByTypeId(utype);
 				uguid = recvPacket.GetPackedGuid();
                 
-				Object *obj = objmgr.GetObj(uguid);
+                Object *obj = objmgr.GetObj(uguid,utype);
 
 				if (obj)
 				{
 					recvPacket >> blockcount;
 					masksize = blockcount * 4;
-					logdebug("UPDATETYPE_VALUES: guid="I64FMT" blockcount=%u masksize=%d",uguid,blockcount, masksize);
+					logdebug("--UPDATETYPE_VALUES: guid="I64FMT" blockcount=%u masksize=%d",uguid,blockcount, masksize);
 
 					uint32 *updateMask = new uint32[100];
 					UpdateMask umask;
@@ -95,19 +94,19 @@ void WorldSession::_HandleUpdateObjectOpcode(WorldPacket& recvPacket)
 				}
 				else
 				{
-					logerror("Got UpdateObject_Values for unknown object "I64FMT,uguid);
+					logerror("--Got UpdateObject_Values for unknown object "I64FMT,uguid);
 				}
 			}
 			break;
 
 		case UPDATETYPE_MOVEMENT:
 			{
-                recvPacket >> uguid;
+                recvPacket >> uguid; // the guid is NOT packed here!
-                Object *obj = objmgr.GetObj(uguid);
+                Object *obj = objmgr.GetObj(uguid,utype);
                 if(obj)
 				    this->_MovementUpdate(obj->GetTypeId(),uguid,recvPacket);
                 else
-                    logerror("Got UpdateObject_Movement for unknown object "I64FMT,uguid);
+                    logerror("--Got UpdateObject_Movement for unknown object "I64FMT,uguid);
 			}
 			break;
 
@@ -115,49 +114,76 @@ void WorldSession::_HandleUpdateObjectOpcode(WorldPacket& recvPacket)
 		case UPDATETYPE_CREATE_OBJECT2:
 			{
 				uguid = recvPacket.GetPackedGuid();
-				uint8 objtypeid, flags;
+				uint8 objtypeid;
-				recvPacket >> objtypeid >> flags;
+				recvPacket >> objtypeid;
-				logdebug("Create Object type %u with guid "I64FMT,objtypeid,uguid);
+				logdebug("--Create Object type %u with guid "I64FMT,objtypeid,uguid);
-                //Object *obj = new Object;
-                //obj->_Create(uguid);
-                //objmgr.Add((Object*)obj);
 
-				this->_MovementUpdate(objtypeid, uguid, recvPacket); // i think thats the wrong place for this [FG]
-																	 // Double checked - seems right - if i really am wrong, please correct [Mini]
                 
-				// TODO: Add object to objmgr
+
+                switch(objtypeid)
+                {
+                case TYPEID_OBJECT: // no data to read
+                    {
+                        logerror("--Got UPDATE_OBJECT for Object!"); // getting this should not be the case
+                    }
+                case TYPEID_ITEM:
+                    {
+                        Item *item = new Item();
+                        // item needs to be created, e.g. item->Create(uguid);
+                        objmgr.Add(item);
+                        break;
+                    }
+                 //case TYPEID_CONTAINER: // not yet handled
+                case TYPEID_UNIT:
+                    {
+                        logerror("--Got UPDATE_OBJECT for Unit!");
+                        break;
+                    }
+                case TYPEID_PLAYER:
+                    {
+                    logdetail("--DEBUG: create player");
+                    recvPacket.hexlike();
+                    Player *player = new Player();
+                    player->Create(uguid);
+                    objmgr.Add(player);
+                    break;
+                    }
+                }
+
+                this->_MovementUpdate(objtypeid, uguid, recvPacket);
 			}
 			break;
 
+
 		case UPDATETYPE_OUT_OF_RANGE_OBJECTS:
 			recvPacket >> usize;
 			for(uint16 i=0;i<usize;i++)
 			{
 				uguid = recvPacket.GetPackedGuid(); // not 100% sure if this is correct
-				logdebug("GUID "I64FMT" out of range",uguid);
+				logdebug("--GUID "I64FMT" out of range",uguid);
-				objmgr.RemoveObject(uguid);
+				objmgr.Remove(uguid);
 			}
 			break;
 
 		default:
-            logerror("Got unk updatetype 0x%X",utype);
+            logerror("-Got unk updatetype 0x%X",utype);
-			break;
+            return;
-		}
+        } // switch
-	}
+    } // while
-}
+} // func
 
 void WorldSession::_MovementUpdate(uint8 objtypeid, uint64 uguid, WorldPacket& recvPacket)
 {
 	if(objtypeid==TYPEID_PLAYER)
 	{
 		uint32 flags, flags2, time;
-		uint64 tguid,guid;
+		uint64 tguid;
 		float nul;
 		float x, y, z, o;
 		float tx, ty, tz, to;
 		float speedWalk, speedRun, speedSwimBack, speedSwim, speedWalkBack, speedTurn;
 
-		recvPacket >> guid >> flags >> flags2 >> time;
+		recvPacket >> flags >> flags2 >> time;
 
 		if (flags2 & 0x02000000) // On a transport
 		{

src/Client/World/WorldSession.cpp

@@ -15,7 +15,7 @@
 
 WorldSession::WorldSession(PseuInstance *in)
 {
-    logdebug("-> Starting WorldSession");
+    logdebug("-> Starting WorldSession from instance 0x%X",in); // should never output a null ptr
     _instance = in;
     _valid=_authed=_logged=false;
     _socket=new WorldSocket(_sh,this);

src/PseuWoW.vcproj

@@ -36,16 +36,16 @@
 				EnableFunctionLevelLinking="FALSE"
 				EnableEnhancedInstructionSet="1"
 				PrecompiledHeaderFile=".\Release/PseuWoW.pch"
-				AssemblerListingLocation="$(SolutionDir)/temp/$(ProjectName)/"
+				AssemblerListingLocation="$(SolutionDir)/temp/$(ProjectName)/$(ConfigurationName)/"
-				ObjectFile="$(SolutionDir)/temp/$(ProjectName)/"
+				ObjectFile="$(SolutionDir)/temp/$(ProjectName)/$(ConfigurationName)/"
-				ProgramDataBaseFileName="$(SolutionDir)/temp/$(ProjectName)/"
+				ProgramDataBaseFileName="$(SolutionDir)/temp/$(ProjectName)/$(ConfigurationName)/"
 				WarningLevel="3"
 				SuppressStartupBanner="TRUE"/>
 			<Tool
 				Name="VCCustomBuildTool"/>
 			<Tool
 				Name="VCLinkerTool"
-				AdditionalDependencies="odbc32.lib odbccp32.lib sdl.lib sdlmain.lib libeay32MT.lib WS2_32.LIB"
+				AdditionalDependencies="odbc32.lib odbccp32.lib libeay32MT.lib WS2_32.LIB"
 				ShowProgress="0"
 				OutputFile="$(OutDir)/$(InputName).exe"
 				LinkIncremental="1"
@@ -55,6 +55,8 @@
 				AssemblyDebug="0"
 				ProgramDatabaseFile="$(SolutionDir)/temp/$(ProjectName)/Release/PseuWoW.pdb"
 				SubSystem="1"
+				OptimizeReferences="2"
+				SetChecksum="TRUE"
 				TargetMachine="1"/>
 			<Tool
 				Name="VCMIDLTool"
@@ -98,9 +100,9 @@
 				BasicRuntimeChecks="3"
 				RuntimeLibrary="3"
 				PrecompiledHeaderFile=""
-				AssemblerListingLocation="$(SolutionDir)/temp/$(ProjectName)/"
+				AssemblerListingLocation="$(SolutionDir)/temp/$(ProjectName)/$(ConfigurationName)/"
-				ObjectFile="$(SolutionDir)/temp/$(ProjectName)/"
+				ObjectFile="$(SolutionDir)/temp/$(ProjectName)/$(ConfigurationName)/"
-				ProgramDataBaseFileName="$(SolutionDir)/temp/$(ProjectName)/"
+				ProgramDataBaseFileName="$(SolutionDir)/temp/$(ProjectName)/$(ConfigurationName)/"
 				BrowseInformation="1"
 				WarningLevel="3"
 				SuppressStartupBanner="TRUE"
@@ -109,14 +111,15 @@
 				Name="VCCustomBuildTool"/>
 			<Tool
 				Name="VCLinkerTool"
-				AdditionalDependencies="odbc32.lib odbccp32.lib sdl.lib sdlmain.lib libeay32MT.lib WS2_32.LIB"
+				AdditionalDependencies="odbc32.lib odbccp32.lib libeay32MT.lib WS2_32.LIB"
-				OutputFile="$(OutDir)/$(InputName).exe"
+				OutputFile="$(OutDir)/$(InputName)_debug.exe"
 				LinkIncremental="2"
 				SuppressStartupBanner="TRUE"
 				AdditionalLibraryDirectories=""
 				GenerateDebugInformation="TRUE"
 				ProgramDatabaseFile="$(SolutionDir)/temp/$(ProjectName)/PseuWoW.pdb"
 				SubSystem="1"
+				OptimizeReferences="1"
 				TargetMachine="1"/>
 			<Tool
 				Name="VCMIDLTool"
@@ -247,16 +250,6 @@
 					RelativePath=".\Client\DefScript\VarSet.h">
 				</File>
 			</Filter>
-			<Filter
-				Name="Realm"
-				Filter="">
-				<File
-					RelativePath=".\Client\Realm\RealmSocket.cpp">
-				</File>
-				<File
-					RelativePath=".\Client\Realm\RealmSocket.h">
-				</File>
-			</Filter>
 			<Filter
 				Name="World"
 				Filter="">
@@ -345,6 +338,16 @@
 					RelativePath=".\Client\World\WorldSocket.h">
 				</File>
 			</Filter>
+			<Filter
+				Name="Realm"
+				Filter="">
+				<File
+					RelativePath=".\Client\Realm\RealmSocket.cpp">
+				</File>
+				<File
+					RelativePath=".\Client\Realm\RealmSocket.h">
+				</File>
+			</Filter>
 		</Filter>
 		<Filter
 			Name="Resource Files"

src/SDL.vcproj

@@ -0,0 +1,462 @@
+<?xml version="1.0" encoding="Windows-1252"?>
+<VisualStudioProject
+	ProjectType="Visual C++"
+	Version="7.10"
+	Name="SDL"
+	ProjectGUID="{81CE8DAF-EBB2-4761-8E45-B71ABCCA8C68}"
+	RootNamespace="SDL">
+	<Platforms>
+		<Platform
+			Name="Win32"/>
+	</Platforms>
+	<Configurations>
+		<Configuration
+			Name="Debug|Win32"
+			OutputDirectory="$(SolutionDir)/temp/$(ProjectName)/$(ConfigurationName)"
+			IntermediateDirectory="$(SolutionDir)/temp/$(ProjectName)/$(ConfigurationName)"
+			ConfigurationType="4"
+			UseOfMFC="0"
+			ATLMinimizesCRunTimeLibraryUsage="FALSE">
+			<Tool
+				Name="VCCLCompilerTool"
+				Optimization="0"
+				AdditionalIncludeDirectories="dep/include/SDL;dep/src/SDL;dep/include"
+				PreprocessorDefinitions="_CRT_SECURE_NO_DEPRECATE;_DEBUG;_WINDOWS;_WIN32_WINNT=0x0400"
+				RuntimeLibrary="2"
+				BufferSecurityCheck="FALSE"
+				UsePrecompiledHeader="0"
+				PrecompiledHeaderFile=".\Debug/SDL.pch"
+				AssemblerListingLocation="$(SolutionDir)/temp/$(ProjectName)/$(ConfigurationName)/"
+				ObjectFile="$(SolutionDir)/temp/$(ProjectName)/$(ConfigurationName)/"
+				ProgramDataBaseFileName="$(SolutionDir)/temp/$(ProjectName)/$(ConfigurationName)/"
+				WarningLevel="3"
+				SuppressStartupBanner="TRUE"
+				Detect64BitPortabilityProblems="FALSE"
+				DebugInformationFormat="4"
+				CompileAs="0"/>
+			<Tool
+				Name="VCCustomBuildTool"/>
+			<Tool
+				Name="VCLibrarianTool"
+				OutputFile="dep/lib/debug/SDL.lib"/>
+			<Tool
+				Name="VCMIDLTool"
+				PreprocessorDefinitions="_DEBUG"
+				MkTypLibCompatible="TRUE"
+				SuppressStartupBanner="TRUE"
+				TargetEnvironment="1"
+				TypeLibraryName=".\Debug/SDL.tlb"/>
+			<Tool
+				Name="VCPostBuildEventTool"/>
+			<Tool
+				Name="VCPreBuildEventTool"/>
+			<Tool
+				Name="VCPreLinkEventTool"/>
+			<Tool
+				Name="VCResourceCompilerTool"
+				PreprocessorDefinitions="_DEBUG"
+				Culture="1033"/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"/>
+			<Tool
+				Name="VCManagedWrapperGeneratorTool"/>
+			<Tool
+				Name="VCAuxiliaryManagedWrapperGeneratorTool"/>
+		</Configuration>
+		<Configuration
+			Name="Release|Win32"
+			OutputDirectory="$(SolutionDir)/temp/$(ProjectName)/$(ConfigurationName)"
+			IntermediateDirectory="$(SolutionDir)/temp/$(ProjectName)/$(ConfigurationName)"
+			ConfigurationType="4"
+			UseOfMFC="0"
+			ATLMinimizesCRunTimeLibraryUsage="FALSE">
+			<Tool
+				Name="VCCLCompilerTool"
+				InlineFunctionExpansion="1"
+				EnableIntrinsicFunctions="FALSE"
+				AdditionalIncludeDirectories="dep/include/SDL;dep/src/SDL;dep/include"
+				PreprocessorDefinitions="_CRT_SECURE_NO_DEPRECATE;NDEBUG;_WINDOWS;_WIN32_WINNT=0x0400"
+				StringPooling="TRUE"
+				RuntimeLibrary="2"
+				BufferSecurityCheck="FALSE"
+				EnableFunctionLevelLinking="TRUE"
+				UsePrecompiledHeader="0"
+				PrecompiledHeaderFile=".\Release/SDL.pch"
+				AssemblerListingLocation="$(SolutionDir)/temp/$(ProjectName)/$(ConfigurationName)/"
+				ObjectFile="$(SolutionDir)/temp/$(ProjectName)/$(ConfigurationName)/"
+				ProgramDataBaseFileName="$(SolutionDir)/temp/$(ProjectName)/$(ConfigurationName)/"
+				WarningLevel="3"
+				SuppressStartupBanner="TRUE"
+				Detect64BitPortabilityProblems="FALSE"
+				CompileAs="0"/>
+			<Tool
+				Name="VCCustomBuildTool"/>
+			<Tool
+				Name="VCLibrarianTool"
+				OutputFile="dep/lib/release/SDL.lib"/>
+			<Tool
+				Name="VCMIDLTool"
+				PreprocessorDefinitions="NDEBUG"
+				MkTypLibCompatible="TRUE"
+				SuppressStartupBanner="TRUE"
+				TargetEnvironment="1"
+				TypeLibraryName=".\Release/SDL.tlb"/>
+			<Tool
+				Name="VCPostBuildEventTool"/>
+			<Tool
+				Name="VCPreBuildEventTool"/>
+			<Tool
+				Name="VCPreLinkEventTool"/>
+			<Tool
+				Name="VCResourceCompilerTool"
+				PreprocessorDefinitions="NDEBUG"
+				Culture="1033"/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"/>
+			<Tool
+				Name="VCManagedWrapperGeneratorTool"/>
+			<Tool
+				Name="VCAuxiliaryManagedWrapperGeneratorTool"/>
+		</Configuration>
+	</Configurations>
+	<References>
+	</References>
+	<Files>
+		<File
+			RelativePath="dep\src\SDL\SDL.c">
+		</File>
+		<File
+			RelativePath="dep\src\SDL\events\SDL_active.c">
+		</File>
+		<File
+			RelativePath="dep\src\SDL\audio\SDL_audio.c">
+		</File>
+		<File
+			RelativePath="dep\src\SDL\audio\SDL_audio_c.h">
+		</File>
+		<File
+			RelativePath="dep\src\SDL\audio\SDL_audiocvt.c">
+		</File>
+		<File
+			RelativePath="dep\src\SDL\audio\SDL_audiomem.h">
+		</File>
+		<File
+			RelativePath="dep\src\SDL\video\SDL_blit.c">
+		</File>
+		<File
+			RelativePath="dep\src\SDL\video\SDL_blit.h">
+		</File>
+		<File
+			RelativePath="dep\src\SDL\video\SDL_blit_0.c">
+		</File>
+		<File
+			RelativePath="dep\src\SDL\video\SDL_blit_1.c">
+		</File>
+		<File
+			RelativePath="dep\src\SDL\video\SDL_blit_A.c">
+		</File>
+		<File
+			RelativePath="dep\src\SDL\video\SDL_blit_A.h">
+		</File>
+		<File
+			RelativePath="dep\src\SDL\video\SDL_blit_N.c">
+		</File>
+		<File
+			RelativePath="dep\src\SDL\video\SDL_bmp.c">
+		</File>
+		<File
+			RelativePath="dep\src\SDL\cdrom\SDL_cdrom.c">
+		</File>
+		<File
+			RelativePath="dep\src\SDL\cpuinfo\SDL_cpuinfo.c">
+		</File>
+		<File
+			RelativePath="dep\src\SDL\video\SDL_cursor.c">
+		</File>
+		<File
+			RelativePath="dep\src\SDL\video\SDL_cursor_c.h">
+		</File>
+		<File
+			RelativePath="dep\src\SDL\audio\windib\SDL_dibaudio.c">
+		</File>
+		<File
+			RelativePath="dep\src\SDL\audio\windib\SDL_dibaudio.h">
+		</File>
+		<File
+			RelativePath="dep\src\SDL\video\windib\SDL_dibevents.c">
+		</File>
+		<File
+			RelativePath="dep\src\SDL\video\windib\SDL_dibevents_c.h">
+		</File>
+		<File
+			RelativePath="dep\src\SDL\video\windib\SDL_dibvideo.c">
+		</File>
+		<File
+			RelativePath="dep\src\SDL\video\windib\SDL_dibvideo.h">
+		</File>
+		<File
+			RelativePath="dep\src\SDL\audio\disk\SDL_diskaudio.c">
+		</File>
+		<File
+			RelativePath="dep\src\SDL\audio\disk\SDL_diskaudio.h">
+		</File>
+		<File
+			RelativePath="dep\src\SDL\audio\dummy\SDL_dummyaudio.c">
+		</File>
+		<File
+			RelativePath="dep\src\SDL\audio\dummy\SDL_dummyaudio.h">
+		</File>
+		<File
+			RelativePath="dep\src\SDL\audio\windx5\SDL_dx5audio.c">
+		</File>
+		<File
+			RelativePath="dep\src\SDL\audio\windx5\SDL_dx5audio.h">
+		</File>
+		<File
+			RelativePath="dep\src\SDL\video\Windx5\SDL_dx5events.c">
+		</File>
+		<File
+			RelativePath="dep\src\SDL\video\Windx5\SDL_dx5events_c.h">
+		</File>
+		<File
+			RelativePath="dep\src\SDL\video\Windx5\SDL_dx5video.c">
+		</File>
+		<File
+			RelativePath="dep\src\SDL\video\Windx5\SDL_dx5video.h">
+		</File>
+		<File
+			RelativePath="dep\src\SDL\video\windx5\SDL_dx5yuv.c">
+		</File>
+		<File
+			RelativePath="dep\src\SDL\video\windx5\SDL_dx5yuv_c.h">
+		</File>
+		<File
+			RelativePath="dep\src\SDL\SDL_error.c">
+		</File>
+		<File
+			RelativePath="dep\src\SDL\SDL_error_c.h">
+		</File>
+		<File
+			RelativePath="dep\src\SDL\events\SDL_events.c">
+		</File>
+		<File
+			RelativePath="dep\src\SDL\events\SDL_events_c.h">
+		</File>
+		<File
+			RelativePath="dep\src\SDL\events\SDL_expose.c">
+		</File>
+		<File
+			RelativePath="dep\src\SDL\SDL_fatal.c">
+		</File>
+		<File
+			RelativePath="dep\src\SDL\SDL_fatal.h">
+		</File>
+		<File
+			RelativePath="dep\src\SDL\video\SDL_gamma.c">
+		</File>
+		<File
+			RelativePath="dep\src\SDL\stdlib\SDL_getenv.c">
+		</File>
+		<File
+			RelativePath="dep\src\SDL\stdlib\SDL_iconv.c">
+		</File>
+		<File
+			RelativePath="dep\src\SDL\joystick\SDL_joystick.c">
+		</File>
+		<File
+			RelativePath="dep\src\SDL\joystick\SDL_joystick_c.h">
+		</File>
+		<File
+			RelativePath="dep\src\SDL\events\SDL_keyboard.c">
+		</File>
+		<File
+			RelativePath="dep\src\SDL\video\SDL_leaks.h">
+		</File>
+		<File
+			RelativePath="dep\src\SDL\video\wincommon\SDL_lowvideo.h">
+		</File>
+		<File
+			RelativePath="dep\src\SDL\stdlib\SDL_malloc.c">
+		</File>
+		<File
+			RelativePath="dep\src\SDL\audio\SDL_mixer.c">
+		</File>
+		<File
+			RelativePath="dep\src\SDL\audio\SDL_mixer_MMX_VC.c">
+		</File>
+		<File
+			RelativePath="dep\src\SDL\joystick\win32\SDL_mmjoystick.c">
+		</File>
+		<File
+			RelativePath="dep\src\SDL\events\SDL_mouse.c">
+		</File>
+		<File
+			RelativePath="dep\src\SDL\video\dummy\SDL_nullevents.c">
+		</File>
+		<File
+			RelativePath="dep\src\SDL\video\dummy\SDL_nullevents_c.h">
+		</File>
+		<File
+			RelativePath="dep\src\SDL\video\dummy\SDL_nullmouse.c">
+		</File>
+		<File
+			RelativePath="dep\src\SDL\video\dummy\SDL_nullmouse_c.h">
+		</File>
+		<File
+			RelativePath="dep\src\SDL\video\dummy\SDL_nullvideo.c">
+		</File>
+		<File
+			RelativePath="dep\src\SDL\video\dummy\SDL_nullvideo.h">
+		</File>
+		<File
+			RelativePath="dep\src\SDL\video\SDL_pixels.c">
+		</File>
+		<File
+			RelativePath="dep\src\SDL\video\SDL_pixels_c.h">
+		</File>
+		<File
+			RelativePath="dep\src\SDL\stdlib\SDL_qsort.c">
+		</File>
+		<File
+			RelativePath="dep\src\SDL\events\SDL_quit.c">
+		</File>
+		<File
+			RelativePath="dep\src\SDL\events\SDL_resize.c">
+		</File>
+		<File
+			RelativePath="dep\src\SDL\video\SDL_RLEaccel.c">
+		</File>
+		<File
+			RelativePath="dep\src\SDL\video\SDL_RLEaccel_c.h">
+		</File>
+		<File
+			RelativePath="dep\src\SDL\file\SDL_rwops.c">
+		</File>
+		<File
+			RelativePath="dep\src\SDL\stdlib\SDL_stdlib.c">
+		</File>
+		<File
+			RelativePath="dep\src\SDL\video\SDL_stretch.c">
+		</File>
+		<File
+			RelativePath="dep\src\SDL\video\SDL_stretch_c.h">
+		</File>
+		<File
+			RelativePath="dep\src\SDL\stdlib\SDL_string.c">
+		</File>
+		<File
+			RelativePath="dep\src\SDL\video\SDL_surface.c">
+		</File>
+		<File
+			RelativePath="dep\src\SDL\audio\SDL_sysaudio.h">
+		</File>
+		<File
+			RelativePath="dep\src\SDL\cdrom\win32\SDL_syscdrom.c">
+		</File>
+		<File
+			RelativePath="dep\src\SDL\cdrom\SDL_syscdrom.h">
+		</File>
+		<File
+			RelativePath="dep\src\SDL\thread\generic\SDL_syscond.c">
+		</File>
+		<File
+			RelativePath="dep\src\SDL\video\wincommon\SDL_sysevents.c">
+		</File>
+		<File
+			RelativePath="dep\src\SDL\events\SDL_sysevents.h">
+		</File>
+		<File
+			RelativePath="dep\src\SDL\joystick\SDL_sysjoystick.h">
+		</File>
+		<File
+			RelativePath="dep\src\SDL\loadso\win32\SDL_sysloadso.c">
+		</File>
+		<File
+			RelativePath="dep\src\SDL\video\wincommon\SDL_sysmouse.c">
+		</File>
+		<File
+			RelativePath="dep\src\SDL\video\wincommon\SDL_sysmouse_c.h">
+		</File>
+		<File
+			RelativePath="dep\src\SDL\thread\win32\SDL_sysmutex.c">
+		</File>
+		<File
+			RelativePath="dep\src\SDL\thread\win32\SDL_syssem.c">
+		</File>
+		<File
+			RelativePath="dep\src\SDL\thread\win32\SDL_systhread.c">
+		</File>
+		<File
+			RelativePath="dep\src\SDL\thread\SDL_systhread.h">
+		</File>
+		<File
+			RelativePath="dep\src\SDL\thread\win32\SDL_systhread_c.h">
+		</File>
+		<File
+			RelativePath="dep\src\SDL\timer\win32\SDL_systimer.c">
+		</File>
+		<File
+			RelativePath="dep\src\SDL\timer\SDL_systimer.h">
+		</File>
+		<File
+			RelativePath="dep\src\SDL\video\SDL_sysvideo.h">
+		</File>
+		<File
+			RelativePath="dep\src\SDL\video\wincommon\SDL_syswm.c">
+		</File>
+		<File
+			RelativePath="dep\src\SDL\video\wincommon\SDL_syswm_c.h">
+		</File>
+		<File
+			RelativePath="dep\src\SDL\thread\SDL_thread.c">
+		</File>
+		<File
+			RelativePath="dep\src\SDL\thread\SDL_thread_c.h">
+		</File>
+		<File
+			RelativePath="dep\src\SDL\timer\SDL_timer.c">
+		</File>
+		<File
+			RelativePath="dep\src\SDL\timer\SDL_timer_c.h">
+		</File>
+		<File
+			RelativePath="dep\src\SDL\video\SDL_video.c">
+		</File>
+		<File
+			RelativePath="dep\src\SDL\video\windib\SDL_vkeys.h">
+		</File>
+		<File
+			RelativePath="dep\src\SDL\audio\SDL_wave.c">
+		</File>
+		<File
+			RelativePath="dep\src\SDL\audio\SDL_wave.h">
+		</File>
+		<File
+			RelativePath="dep\src\SDL\video\wincommon\SDL_wingl.c">
+		</File>
+		<File
+			RelativePath="dep\src\SDL\video\wincommon\SDL_wingl_c.h">
+		</File>
+		<File
+			RelativePath="dep\src\SDL\video\SDL_yuv.c">
+		</File>
+		<File
+			RelativePath="dep\src\SDL\video\SDL_yuv_sw.c">
+		</File>
+		<File
+			RelativePath="dep\src\SDL\video\SDL_yuv_sw_c.h">
+		</File>
+		<File
+			RelativePath="dep\src\SDL\video\SDL_yuvfuncs.h">
+		</File>
+		<File
+			RelativePath="dep\src\SDL\video\wincommon\Wmmsg.h">
+		</File>
+	</Files>
+	<Globals>
+	</Globals>
+</VisualStudioProject>

src/dep/include/SDL/SDL.h

@@ -0,0 +1,94 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2006 Sam Lantinga
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+    Sam Lantinga
+    slouken@libsdl.org
+*/
+
+/* Main include header for the SDL library */
+
+#ifndef _SDL_H
+#define _SDL_H
+
+#include "SDL_main.h"
+#include "SDL_stdinc.h"
+#include "SDL_audio.h"
+#include "SDL_cdrom.h"
+#include "SDL_cpuinfo.h"
+#include "SDL_endian.h"
+#include "SDL_error.h"
+#include "SDL_events.h"
+#include "SDL_loadso.h"
+#include "SDL_mutex.h"
+#include "SDL_rwops.h"
+#include "SDL_thread.h"
+#include "SDL_timer.h"
+#include "SDL_video.h"
+#include "SDL_version.h"
+
+#include "begin_code.h"
+/* Set up for C function definitions, even when using C++ */
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* As of version 0.5, SDL is loaded dynamically into the application */
+
+/* These are the flags which may be passed to SDL_Init() -- you should
+   specify the subsystems which you will be using in your application.
+*/
+#define	SDL_INIT_TIMER		0x00000001
+#define SDL_INIT_AUDIO		0x00000010
+#define SDL_INIT_VIDEO		0x00000020
+#define SDL_INIT_CDROM		0x00000100
+#define SDL_INIT_JOYSTICK	0x00000200
+#define SDL_INIT_NOPARACHUTE	0x00100000	/* Don't catch fatal signals */
+#define SDL_INIT_EVENTTHREAD	0x01000000	/* Not supported on all OS's */
+#define SDL_INIT_EVERYTHING	0x0000FFFF
+
+/* This function loads the SDL dynamically linked library and initializes 
+ * the subsystems specified by 'flags' (and those satisfying dependencies)
+ * Unless the SDL_INIT_NOPARACHUTE flag is set, it will install cleanup
+ * signal handlers for some commonly ignored fatal signals (like SIGSEGV)
+ */
+extern DECLSPEC int SDLCALL SDL_Init(Uint32 flags);
+
+/* This function initializes specific SDL subsystems */
+extern DECLSPEC int SDLCALL SDL_InitSubSystem(Uint32 flags);
+
+/* This function cleans up specific SDL subsystems */
+extern DECLSPEC void SDLCALL SDL_QuitSubSystem(Uint32 flags);
+
+/* This function returns mask of the specified subsystems which have
+   been initialized.
+   If 'flags' is 0, it returns a mask of all initialized subsystems.
+*/
+extern DECLSPEC Uint32 SDLCALL SDL_WasInit(Uint32 flags);
+
+/* This function cleans up all initialized subsystems and unloads the
+ * dynamically linked library.  You should call it upon all exit conditions.
+ */
+extern DECLSPEC void SDLCALL SDL_Quit(void);
+
+/* Ends C function definitions when using C++ */
+#ifdef __cplusplus
+}
+#endif
+#include "close_code.h"
+
+#endif /* _SDL_H */

src/dep/include/SDL/SDL_active.h

@@ -0,0 +1,58 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2006 Sam Lantinga
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+    Sam Lantinga
+    slouken@libsdl.org
+*/
+
+/* Include file for SDL application focus event handling */
+
+#ifndef _SDL_active_h
+#define _SDL_active_h
+
+#include "SDL_stdinc.h"
+#include "SDL_error.h"
+
+#include "begin_code.h"
+/* Set up for C function definitions, even when using C++ */
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* The available application states */
+#define SDL_APPMOUSEFOCUS	0x01		/* The app has mouse coverage */
+#define SDL_APPINPUTFOCUS	0x02		/* The app has input focus */
+#define SDL_APPACTIVE		0x04		/* The application is active */
+
+/* Function prototypes */
+/* 
+ * This function returns the current state of the application, which is a
+ * bitwise combination of SDL_APPMOUSEFOCUS, SDL_APPINPUTFOCUS, and
+ * SDL_APPACTIVE.  If SDL_APPACTIVE is set, then the user is able to
+ * see your application, otherwise it has been iconified or disabled.
+ */
+extern DECLSPEC Uint8 SDLCALL SDL_GetAppState(void);
+
+
+/* Ends C function definitions when using C++ */
+#ifdef __cplusplus
+}
+#endif
+#include "close_code.h"
+
+#endif /* _SDL_active_h */

src/dep/include/SDL/SDL_audio.h

@@ -0,0 +1,253 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2006 Sam Lantinga
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+    Sam Lantinga
+    slouken@libsdl.org
+*/
+
+/* Access to the raw audio mixing buffer for the SDL library */
+
+#ifndef _SDL_audio_h
+#define _SDL_audio_h
+
+#include "SDL_stdinc.h"
+#include "SDL_error.h"
+#include "SDL_endian.h"
+#include "SDL_mutex.h"
+#include "SDL_thread.h"
+#include "SDL_rwops.h"
+
+#include "begin_code.h"
+/* Set up for C function definitions, even when using C++ */
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* The calculated values in this structure are calculated by SDL_OpenAudio() */
+typedef struct SDL_AudioSpec {
+	int freq;		/* DSP frequency -- samples per second */
+	Uint16 format;		/* Audio data format */
+	Uint8  channels;	/* Number of channels: 1 mono, 2 stereo */
+	Uint8  silence;		/* Audio buffer silence value (calculated) */
+	Uint16 samples;		/* Audio buffer size in samples (power of 2) */
+	Uint16 padding;		/* Necessary for some compile environments */
+	Uint32 size;		/* Audio buffer size in bytes (calculated) */
+	/* This function is called when the audio device needs more data.
+	   'stream' is a pointer to the audio data buffer
+	   'len' is the length of that buffer in bytes.
+	   Once the callback returns, the buffer will no longer be valid.
+	   Stereo samples are stored in a LRLRLR ordering.
+	*/
+	void (SDLCALL *callback)(void *userdata, Uint8 *stream, int len);
+	void  *userdata;
+} SDL_AudioSpec;
+
+/* Audio format flags (defaults to LSB byte order) */
+#define AUDIO_U8	0x0008	/* Unsigned 8-bit samples */
+#define AUDIO_S8	0x8008	/* Signed 8-bit samples */
+#define AUDIO_U16LSB	0x0010	/* Unsigned 16-bit samples */
+#define AUDIO_S16LSB	0x8010	/* Signed 16-bit samples */
+#define AUDIO_U16MSB	0x1010	/* As above, but big-endian byte order */
+#define AUDIO_S16MSB	0x9010	/* As above, but big-endian byte order */
+#define AUDIO_U16	AUDIO_U16LSB
+#define AUDIO_S16	AUDIO_S16LSB
+
+/* Native audio byte ordering */
+#if SDL_BYTEORDER == SDL_LIL_ENDIAN
+#define AUDIO_U16SYS	AUDIO_U16LSB
+#define AUDIO_S16SYS	AUDIO_S16LSB
+#else
+#define AUDIO_U16SYS	AUDIO_U16MSB
+#define AUDIO_S16SYS	AUDIO_S16MSB
+#endif
+
+
+/* A structure to hold a set of audio conversion filters and buffers */
+typedef struct SDL_AudioCVT {
+	int needed;			/* Set to 1 if conversion possible */
+	Uint16 src_format;		/* Source audio format */
+	Uint16 dst_format;		/* Target audio format */
+	double rate_incr;		/* Rate conversion increment */
+	Uint8 *buf;			/* Buffer to hold entire audio data */
+	int    len;			/* Length of original audio buffer */
+	int    len_cvt;			/* Length of converted audio buffer */
+	int    len_mult;		/* buffer must be len*len_mult big */
+	double len_ratio; 	/* Given len, final size is len*len_ratio */
+	void (SDLCALL *filters[10])(struct SDL_AudioCVT *cvt, Uint16 format);
+	int filter_index;		/* Current audio conversion function */
+} SDL_AudioCVT;
+
+
+/* Function prototypes */
+
+/* These functions are used internally, and should not be used unless you
+ * have a specific need to specify the audio driver you want to use.
+ * You should normally use SDL_Init() or SDL_InitSubSystem().
+ */
+extern DECLSPEC int SDLCALL SDL_AudioInit(const char *driver_name);
+extern DECLSPEC void SDLCALL SDL_AudioQuit(void);
+
+/* This function fills the given character buffer with the name of the
+ * current audio driver, and returns a pointer to it if the audio driver has
+ * been initialized.  It returns NULL if no driver has been initialized.
+ */
+extern DECLSPEC char * SDLCALL SDL_AudioDriverName(char *namebuf, int maxlen);
+
+/*
+ * This function opens the audio device with the desired parameters, and
+ * returns 0 if successful, placing the actual hardware parameters in the
+ * structure pointed to by 'obtained'.  If 'obtained' is NULL, the audio
+ * data passed to the callback function will be guaranteed to be in the
+ * requested format, and will be automatically converted to the hardware
+ * audio format if necessary.  This function returns -1 if it failed 
+ * to open the audio device, or couldn't set up the audio thread.
+ *
+ * When filling in the desired audio spec structure,
+ *  'desired->freq' should be the desired audio frequency in samples-per-second.
+ *  'desired->format' should be the desired audio format.
+ *  'desired->samples' is the desired size of the audio buffer, in samples.
+ *     This number should be a power of two, and may be adjusted by the audio
+ *     driver to a value more suitable for the hardware.  Good values seem to
+ *     range between 512 and 8096 inclusive, depending on the application and
+ *     CPU speed.  Smaller values yield faster response time, but can lead
+ *     to underflow if the application is doing heavy processing and cannot
+ *     fill the audio buffer in time.  A stereo sample consists of both right
+ *     and left channels in LR ordering.
+ *     Note that the number of samples is directly related to time by the
+ *     following formula:  ms = (samples*1000)/freq
+ *  'desired->size' is the size in bytes of the audio buffer, and is
+ *     calculated by SDL_OpenAudio().
+ *  'desired->silence' is the value used to set the buffer to silence,
+ *     and is calculated by SDL_OpenAudio().
+ *  'desired->callback' should be set to a function that will be called
+ *     when the audio device is ready for more data.  It is passed a pointer
+ *     to the audio buffer, and the length in bytes of the audio buffer.
+ *     This function usually runs in a separate thread, and so you should
+ *     protect data structures that it accesses by calling SDL_LockAudio()
+ *     and SDL_UnlockAudio() in your code.
+ *  'desired->userdata' is passed as the first parameter to your callback
+ *     function.
+ *
+ * The audio device starts out playing silence when it's opened, and should
+ * be enabled for playing by calling SDL_PauseAudio(0) when you are ready
+ * for your audio callback function to be called.  Since the audio driver
+ * may modify the requested size of the audio buffer, you should allocate
+ * any local mixing buffers after you open the audio device.
+ */
+extern DECLSPEC int SDLCALL SDL_OpenAudio(SDL_AudioSpec *desired, SDL_AudioSpec *obtained);
+
+/*
+ * Get the current audio state:
+ */
+typedef enum {
+	SDL_AUDIO_STOPPED = 0,
+	SDL_AUDIO_PLAYING,
+	SDL_AUDIO_PAUSED
+} SDL_audiostatus;
+extern DECLSPEC SDL_audiostatus SDLCALL SDL_GetAudioStatus(void);
+
+/*
+ * This function pauses and unpauses the audio callback processing.
+ * It should be called with a parameter of 0 after opening the audio
+ * device to start playing sound.  This is so you can safely initialize
+ * data for your callback function after opening the audio device.
+ * Silence will be written to the audio device during the pause.
+ */
+extern DECLSPEC void SDLCALL SDL_PauseAudio(int pause_on);
+
+/*
+ * This function loads a WAVE from the data source, automatically freeing
+ * that source if 'freesrc' is non-zero.  For example, to load a WAVE file,
+ * you could do:
+ *	SDL_LoadWAV_RW(SDL_RWFromFile("sample.wav", "rb"), 1, ...);
+ *
+ * If this function succeeds, it returns the given SDL_AudioSpec,
+ * filled with the audio data format of the wave data, and sets
+ * 'audio_buf' to a malloc()'d buffer containing the audio data,
+ * and sets 'audio_len' to the length of that audio buffer, in bytes.
+ * You need to free the audio buffer with SDL_FreeWAV() when you are 
+ * done with it.
+ *
+ * This function returns NULL and sets the SDL error message if the 
+ * wave file cannot be opened, uses an unknown data format, or is 
+ * corrupt.  Currently raw and MS-ADPCM WAVE files are supported.
+ */
+extern DECLSPEC SDL_AudioSpec * SDLCALL SDL_LoadWAV_RW(SDL_RWops *src, int freesrc, SDL_AudioSpec *spec, Uint8 **audio_buf, Uint32 *audio_len);
+
+/* Compatibility convenience function -- loads a WAV from a file */
+#define SDL_LoadWAV(file, spec, audio_buf, audio_len) \
+	SDL_LoadWAV_RW(SDL_RWFromFile(file, "rb"),1, spec,audio_buf,audio_len)
+
+/*
+ * This function frees data previously allocated with SDL_LoadWAV_RW()
+ */
+extern DECLSPEC void SDLCALL SDL_FreeWAV(Uint8 *audio_buf);
+
+/*
+ * This function takes a source format and rate and a destination format
+ * and rate, and initializes the 'cvt' structure with information needed
+ * by SDL_ConvertAudio() to convert a buffer of audio data from one format
+ * to the other.
+ * This function returns 0, or -1 if there was an error.
+ */
+extern DECLSPEC int SDLCALL SDL_BuildAudioCVT(SDL_AudioCVT *cvt,
+		Uint16 src_format, Uint8 src_channels, int src_rate,
+		Uint16 dst_format, Uint8 dst_channels, int dst_rate);
+
+/* Once you have initialized the 'cvt' structure using SDL_BuildAudioCVT(),
+ * created an audio buffer cvt->buf, and filled it with cvt->len bytes of
+ * audio data in the source format, this function will convert it in-place
+ * to the desired format.
+ * The data conversion may expand the size of the audio data, so the buffer
+ * cvt->buf should be allocated after the cvt structure is initialized by
+ * SDL_BuildAudioCVT(), and should be cvt->len*cvt->len_mult bytes long.
+ */
+extern DECLSPEC int SDLCALL SDL_ConvertAudio(SDL_AudioCVT *cvt);
+
+/*
+ * This takes two audio buffers of the playing audio format and mixes
+ * them, performing addition, volume adjustment, and overflow clipping.
+ * The volume ranges from 0 - 128, and should be set to SDL_MIX_MAXVOLUME
+ * for full audio volume.  Note this does not change hardware volume.
+ * This is provided for convenience -- you can mix your own audio data.
+ */
+#define SDL_MIX_MAXVOLUME 128
+extern DECLSPEC void SDLCALL SDL_MixAudio(Uint8 *dst, const Uint8 *src, Uint32 len, int volume);
+
+/*
+ * The lock manipulated by these functions protects the callback function.
+ * During a LockAudio/UnlockAudio pair, you can be guaranteed that the
+ * callback function is not running.  Do not call these from the callback
+ * function or you will cause deadlock.
+ */
+extern DECLSPEC void SDLCALL SDL_LockAudio(void);
+extern DECLSPEC void SDLCALL SDL_UnlockAudio(void);
+
+/*
+ * This function shuts down audio processing and closes the audio device.
+ */
+extern DECLSPEC void SDLCALL SDL_CloseAudio(void);
+
+
+/* Ends C function definitions when using C++ */
+#ifdef __cplusplus
+}
+#endif
+#include "close_code.h"
+
+#endif /* _SDL_audio_h */

src/dep/include/SDL/SDL_byteorder.h

@@ -0,0 +1,24 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2006 Sam Lantinga
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+    Sam Lantinga
+    slouken@libsdl.org
+*/
+
+/* DEPRECATED */
+#include "SDL_endian.h"

src/dep/include/SDL/SDL_cdrom.h

@@ -0,0 +1,171 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2006 Sam Lantinga
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+    Sam Lantinga
+    slouken@libsdl.org
+*/
+
+/* This is the CD-audio control API for Simple DirectMedia Layer */
+
+#ifndef _SDL_cdrom_h
+#define _SDL_cdrom_h
+
+#include "SDL_stdinc.h"
+#include "SDL_error.h"
+
+#include "begin_code.h"
+/* Set up for C function definitions, even when using C++ */
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* In order to use these functions, SDL_Init() must have been called
+   with the SDL_INIT_CDROM flag.  This causes SDL to scan the system
+   for CD-ROM drives, and load appropriate drivers.
+*/
+
+/* The maximum number of CD-ROM tracks on a disk */
+#define SDL_MAX_TRACKS	99
+
+/* The types of CD-ROM track possible */
+#define SDL_AUDIO_TRACK	0x00
+#define SDL_DATA_TRACK	0x04
+
+/* The possible states which a CD-ROM drive can be in. */
+typedef enum {
+	CD_TRAYEMPTY,
+	CD_STOPPED,
+	CD_PLAYING,
+	CD_PAUSED,
+	CD_ERROR = -1
+} CDstatus;
+
+/* Given a status, returns true if there's a disk in the drive */
+#define CD_INDRIVE(status)	((int)(status) > 0)
+
+typedef struct SDL_CDtrack {
+	Uint8 id;		/* Track number */
+	Uint8 type;		/* Data or audio track */
+	Uint16 unused;
+	Uint32 length;		/* Length, in frames, of this track */
+	Uint32 offset;		/* Offset, in frames, from start of disk */
+} SDL_CDtrack;
+
+/* This structure is only current as of the last call to SDL_CDStatus() */
+typedef struct SDL_CD {
+	int id;			/* Private drive identifier */
+	CDstatus status;	/* Current drive status */
+
+	/* The rest of this structure is only valid if there's a CD in drive */
+	int numtracks;		/* Number of tracks on disk */
+	int cur_track;		/* Current track position */
+	int cur_frame;		/* Current frame offset within current track */
+	SDL_CDtrack track[SDL_MAX_TRACKS+1];
+} SDL_CD;
+
+/* Conversion functions from frames to Minute/Second/Frames and vice versa */
+#define CD_FPS	75
+#define FRAMES_TO_MSF(f, M,S,F)	{					\
+	int value = f;							\
+	*(F) = value%CD_FPS;						\
+	value /= CD_FPS;						\
+	*(S) = value%60;						\
+	value /= 60;							\
+	*(M) = value;							\
+}
+#define MSF_TO_FRAMES(M, S, F)	((M)*60*CD_FPS+(S)*CD_FPS+(F))
+
+/* CD-audio API functions: */
+
+/* Returns the number of CD-ROM drives on the system, or -1 if
+   SDL_Init() has not been called with the SDL_INIT_CDROM flag.
+ */
+extern DECLSPEC int SDLCALL SDL_CDNumDrives(void);
+
+/* Returns a human-readable, system-dependent identifier for the CD-ROM.
+   Example:
+	"/dev/cdrom"
+	"E:"
+	"/dev/disk/ide/1/master"
+*/
+extern DECLSPEC const char * SDLCALL SDL_CDName(int drive);
+
+/* Opens a CD-ROM drive for access.  It returns a drive handle on success,
+   or NULL if the drive was invalid or busy.  This newly opened CD-ROM
+   becomes the default CD used when other CD functions are passed a NULL
+   CD-ROM handle.
+   Drives are numbered starting with 0.  Drive 0 is the system default CD-ROM.
+*/
+extern DECLSPEC SDL_CD * SDLCALL SDL_CDOpen(int drive);
+
+/* This function returns the current status of the given drive.
+   If the drive has a CD in it, the table of contents of the CD and current
+   play position of the CD will be stored in the SDL_CD structure.
+*/
+extern DECLSPEC CDstatus SDLCALL SDL_CDStatus(SDL_CD *cdrom);
+
+/* Play the given CD starting at 'start_track' and 'start_frame' for 'ntracks'
+   tracks and 'nframes' frames.  If both 'ntrack' and 'nframe' are 0, play 
+   until the end of the CD.  This function will skip data tracks.
+   This function should only be called after calling SDL_CDStatus() to 
+   get track information about the CD.
+   For example:
+	// Play entire CD:
+	if ( CD_INDRIVE(SDL_CDStatus(cdrom)) )
+		SDL_CDPlayTracks(cdrom, 0, 0, 0, 0);
+	// Play last track:
+	if ( CD_INDRIVE(SDL_CDStatus(cdrom)) ) {
+		SDL_CDPlayTracks(cdrom, cdrom->numtracks-1, 0, 0, 0);
+	}
+	// Play first and second track and 10 seconds of third track:
+	if ( CD_INDRIVE(SDL_CDStatus(cdrom)) )
+		SDL_CDPlayTracks(cdrom, 0, 0, 2, 10);
+
+   This function returns 0, or -1 if there was an error.
+*/
+extern DECLSPEC int SDLCALL SDL_CDPlayTracks(SDL_CD *cdrom,
+		int start_track, int start_frame, int ntracks, int nframes);
+
+/* Play the given CD starting at 'start' frame for 'length' frames.
+   It returns 0, or -1 if there was an error.
+*/
+extern DECLSPEC int SDLCALL SDL_CDPlay(SDL_CD *cdrom, int start, int length);
+
+/* Pause play -- returns 0, or -1 on error */
+extern DECLSPEC int SDLCALL SDL_CDPause(SDL_CD *cdrom);
+
+/* Resume play -- returns 0, or -1 on error */
+extern DECLSPEC int SDLCALL SDL_CDResume(SDL_CD *cdrom);
+
+/* Stop play -- returns 0, or -1 on error */
+extern DECLSPEC int SDLCALL SDL_CDStop(SDL_CD *cdrom);
+
+/* Eject CD-ROM -- returns 0, or -1 on error */
+extern DECLSPEC int SDLCALL SDL_CDEject(SDL_CD *cdrom);
+
+/* Closes the handle for the CD-ROM drive */
+extern DECLSPEC void SDLCALL SDL_CDClose(SDL_CD *cdrom);
+
+
+/* Ends C function definitions when using C++ */
+#ifdef __cplusplus
+}
+#endif
+#include "close_code.h"
+
+#endif /* _SDL_video_h */

src/dep/include/SDL/SDL_config.h

@@ -0,0 +1,45 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2006 Sam Lantinga
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+    Sam Lantinga
+    slouken@libsdl.org
+*/
+
+#ifndef _SDL_config_h
+#define _SDL_config_h
+
+#include "SDL_platform.h"
+
+/* Add any platform that doesn't build using the configure system */
+#if defined(__AMIGA__)
+#include "SDL_config_amiga.h"
+#elif defined(__DREAMCAST__)
+#include "SDL_config_dreamcast.h"
+#elif defined(__MACOS__)
+#include "SDL_config_macos.h"
+#elif defined(__MACOSX__)
+#include "SDL_config_macosx.h"
+#elif defined(__WIN32__)
+#include "SDL_config_win32.h"
+#elif defined(__OS2__)
+#include "SDL_config_os2.h"
+#else
+#include "SDL_config_minimal.h"
+#endif /* platform config */
+
+#endif /* _SDL_config_h */

src/dep/include/SDL/SDL_config.h.default

@@ -0,0 +1,45 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2006 Sam Lantinga
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+    Sam Lantinga
+    slouken@libsdl.org
+*/
+
+#ifndef _SDL_config_h
+#define _SDL_config_h
+
+#include "SDL_platform.h"
+
+/* Add any platform that doesn't build using the configure system */
+#if defined(__AMIGA__)
+#include "SDL_config_amiga.h"
+#elif defined(__DREAMCAST__)
+#include "SDL_config_dreamcast.h"
+#elif defined(__MACOS__)
+#include "SDL_config_macos.h"
+#elif defined(__MACOSX__)
+#include "SDL_config_macosx.h"
+#elif defined(__WIN32__)
+#include "SDL_config_win32.h"
+#elif defined(__OS2__)
+#include "SDL_config_os2.h"
+#else
+#include "SDL_config_minimal.h"
+#endif /* platform config */
+
+#endif /* _SDL_config_h */

src/dep/include/SDL/SDL_config.h.in

@@ -0,0 +1,305 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2006 Sam Lantinga
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+    Sam Lantinga
+    slouken@libsdl.org
+*/
+
+#ifndef _SDL_config_h
+#define _SDL_config_h
+
+/* This is a set of defines to configure the SDL features */
+
+/* General platform specific identifiers */
+#include "SDL_platform.h"
+
+/* C language features */
+#undef const
+#undef inline
+#undef volatile
+
+/* C datatypes */
+#undef size_t
+#undef int8_t
+#undef uint8_t
+#undef int16_t
+#undef uint16_t
+#undef int32_t
+#undef uint32_t
+#undef int64_t
+#undef uint64_t
+#undef uintptr_t
+#undef SDL_HAS_64BIT_TYPE
+
+/* Endianness */
+#undef SDL_BYTEORDER
+
+/* Comment this if you want to build without any C library requirements */
+#undef HAVE_LIBC
+#if HAVE_LIBC
+
+/* Useful headers */
+#undef HAVE_ALLOCA_H
+#undef HAVE_SYS_TYPES_H
+#undef HAVE_STDIO_H
+#undef STDC_HEADERS
+#undef HAVE_STDLIB_H
+#undef HAVE_STDARG_H
+#undef HAVE_MALLOC_H
+#undef HAVE_MEMORY_H
+#undef HAVE_STRING_H
+#undef HAVE_STRINGS_H
+#undef HAVE_INTTYPES_H
+#undef HAVE_STDINT_H
+#undef HAVE_CTYPE_H
+#undef HAVE_MATH_H
+#undef HAVE_ICONV_H
+#undef HAVE_SIGNAL_H
+#undef HAVE_ALTIVEC_H
+
+/* C library functions */
+#undef HAVE_MALLOC
+#undef HAVE_CALLOC
+#undef HAVE_REALLOC
+#undef HAVE_FREE
+#undef HAVE_ALLOCA
+#ifndef _WIN32 /* Don't use C runtime versions of these on Windows */
+#undef HAVE_GETENV
+#undef HAVE_PUTENV
+#undef HAVE_UNSETENV
+#endif
+#undef HAVE_QSORT
+#undef HAVE_ABS
+#undef HAVE_BCOPY
+#undef HAVE_MEMSET
+#undef HAVE_MEMCPY
+#undef HAVE_MEMMOVE
+#undef HAVE_MEMCMP
+#undef HAVE_STRLEN
+#undef HAVE_STRLCPY
+#undef HAVE_STRLCAT
+#undef HAVE_STRDUP
+#undef HAVE__STRREV
+#undef HAVE__STRUPR
+#undef HAVE__STRLWR
+#undef HAVE_INDEX
+#undef HAVE_RINDEX
+#undef HAVE_STRCHR
+#undef HAVE_STRRCHR
+#undef HAVE_STRSTR
+#undef HAVE_ITOA
+#undef HAVE__LTOA
+#undef HAVE__UITOA
+#undef HAVE__ULTOA
+#undef HAVE_STRTOL
+#undef HAVE_STRTOUL
+#undef HAVE__I64TOA
+#undef HAVE__UI64TOA
+#undef HAVE_STRTOLL
+#undef HAVE_STRTOULL
+#undef HAVE_STRTOD
+#undef HAVE_ATOI
+#undef HAVE_ATOF
+#undef HAVE_STRCMP
+#undef HAVE_STRNCMP
+#undef HAVE__STRICMP
+#undef HAVE_STRCASECMP
+#undef HAVE__STRNICMP
+#undef HAVE_STRNCASECMP
+#undef HAVE_SSCANF
+#undef HAVE_SNPRINTF
+#undef HAVE_VSNPRINTF
+#undef HAVE_ICONV
+#undef HAVE_SIGACTION
+#undef HAVE_SETJMP
+#undef HAVE_NANOSLEEP
+#undef HAVE_CLOCK_GETTIME
+#undef HAVE_DLVSYM
+
+#else
+/* We may need some replacement for stdarg.h here */
+#include <stdarg.h>
+#endif /* HAVE_LIBC */
+
+/* Allow disabling of core subsystems */
+#undef SDL_AUDIO_DISABLED
+#undef SDL_CDROM_DISABLED
+#undef SDL_CPUINFO_DISABLED
+#undef SDL_EVENTS_DISABLED
+#undef SDL_FILE_DISABLED
+#undef SDL_JOYSTICK_DISABLED
+#undef SDL_LOADSO_DISABLED
+#undef SDL_THREADS_DISABLED
+#undef SDL_TIMERS_DISABLED
+#undef SDL_VIDEO_DISABLED
+
+/* Enable various audio drivers */
+#undef SDL_AUDIO_DRIVER_AHI
+#undef SDL_AUDIO_DRIVER_ALSA
+#undef SDL_AUDIO_DRIVER_ALSA_DYNAMIC
+#undef SDL_AUDIO_DRIVER_ARTS
+#undef SDL_AUDIO_DRIVER_ARTS_DYNAMIC
+#undef SDL_AUDIO_DRIVER_BAUDIO
+#undef SDL_AUDIO_DRIVER_BSD
+#undef SDL_AUDIO_DRIVER_COREAUDIO
+#undef SDL_AUDIO_DRIVER_DART
+#undef SDL_AUDIO_DRIVER_DC
+#undef SDL_AUDIO_DRIVER_DISK
+#undef SDL_AUDIO_DRIVER_DUMMY
+#undef SDL_AUDIO_DRIVER_DMEDIA
+#undef SDL_AUDIO_DRIVER_DSOUND
+#undef SDL_AUDIO_DRIVER_ESD
+#undef SDL_AUDIO_DRIVER_ESD_DYNAMIC
+#undef SDL_AUDIO_DRIVER_MINT
+#undef SDL_AUDIO_DRIVER_MMEAUDIO
+#undef SDL_AUDIO_DRIVER_NAS
+#undef SDL_AUDIO_DRIVER_OSS
+#undef SDL_AUDIO_DRIVER_OSS_SOUNDCARD_H
+#undef SDL_AUDIO_DRIVER_PAUD
+#undef SDL_AUDIO_DRIVER_QNXNTO
+#undef SDL_AUDIO_DRIVER_SNDMGR
+#undef SDL_AUDIO_DRIVER_SUNAUDIO
+#undef SDL_AUDIO_DRIVER_WAVEOUT
+
+/* Enable various cdrom drivers */
+#undef SDL_CDROM_AIX
+#undef SDL_CDROM_BEOS
+#undef SDL_CDROM_BSDI
+#undef SDL_CDROM_DC
+#undef SDL_CDROM_DUMMY
+#undef SDL_CDROM_FREEBSD
+#undef SDL_CDROM_LINUX
+#undef SDL_CDROM_MACOS
+#undef SDL_CDROM_MACOSX
+#undef SDL_CDROM_MINT
+#undef SDL_CDROM_OPENBSD
+#undef SDL_CDROM_OS2
+#undef SDL_CDROM_OSF
+#undef SDL_CDROM_QNX
+#undef SDL_CDROM_WIN32
+
+/* Enable various input drivers */
+#undef SDL_INPUT_TSLIB
+#undef SDL_JOYSTICK_AMIGA
+#undef SDL_JOYSTICK_BEOS
+#undef SDL_JOYSTICK_DC
+#undef SDL_JOYSTICK_DUMMY
+#undef SDL_JOYSTICK_IOKIT
+#undef SDL_JOYSTICK_LINUX
+#undef SDL_JOYSTICK_LINUXEV
+#undef SDL_JOYSTICK_MACOS
+#undef SDL_JOYSTICK_MINT
+#undef SDL_JOYSTICK_OS2
+#undef SDL_JOYSTICK_RISCOS
+#undef SDL_JOYSTICK_WINMM
+#undef SDL_JOYSTICK_USBHID
+#undef SDL_JOYSTICK_USBHID_MACHINE_JOYSTICK_H
+
+/* Enable various shared object loading systems */
+#undef SDL_LOADSO_BEOS
+#undef SDL_LOADSO_DLCOMPAT
+#undef SDL_LOADSO_DLOPEN
+#undef SDL_LOADSO_DUMMY
+#undef SDL_LOADSO_LDG
+#undef SDL_LOADSO_MACOS
+#undef SDL_LOADSO_OS2
+#undef SDL_LOADSO_WIN32
+
+/* Enable various threading systems */
+#undef SDL_THREAD_AMIGA
+#undef SDL_THREAD_BEOS
+#undef SDL_THREAD_DC
+#undef SDL_THREAD_EPOC
+#undef SDL_THREAD_OS2
+#undef SDL_THREAD_PTH
+#undef SDL_THREAD_PTHREAD
+#undef SDL_THREAD_PTHREAD_RECURSIVE_MUTEX
+#undef SDL_THREAD_PTHREAD_RECURSIVE_MUTEX_NP
+#undef SDL_THREAD_SPROC
+#undef SDL_THREAD_WIN32
+
+/* Enable various timer systems */
+#undef SDL_TIMER_AMIGA
+#undef SDL_TIMER_BEOS
+#undef SDL_TIMER_DC
+#undef SDL_TIMER_DUMMY
+#undef SDL_TIMER_EPOC
+#undef SDL_TIMER_MACOS
+#undef SDL_TIMER_MINT
+#undef SDL_TIMER_OS2
+#undef SDL_TIMER_RISCOS
+#undef SDL_TIMER_UNIX
+#undef SDL_TIMER_WIN32
+#undef SDL_TIMER_WINCE
+
+/* Enable various video drivers */
+#undef SDL_VIDEO_DRIVER_AALIB
+#undef SDL_VIDEO_DRIVER_BWINDOW
+#undef SDL_VIDEO_DRIVER_CYBERGRAPHICS
+#undef SDL_VIDEO_DRIVER_DC
+#undef SDL_VIDEO_DRIVER_DDRAW
+#undef SDL_VIDEO_DRIVER_DGA
+#undef SDL_VIDEO_DRIVER_DIRECTFB
+#undef SDL_VIDEO_DRIVER_DRAWSPROCKET
+#undef SDL_VIDEO_DRIVER_DUMMY
+#undef SDL_VIDEO_DRIVER_EPOC
+#undef SDL_VIDEO_DRIVER_FBCON
+#undef SDL_VIDEO_DRIVER_GAPI
+#undef SDL_VIDEO_DRIVER_GEM
+#undef SDL_VIDEO_DRIVER_GGI
+#undef SDL_VIDEO_DRIVER_IPOD
+#undef SDL_VIDEO_DRIVER_NANOX
+#undef SDL_VIDEO_DRIVER_OS2FS
+#undef SDL_VIDEO_DRIVER_PHOTON
+#undef SDL_VIDEO_DRIVER_PICOGUI
+#undef SDL_VIDEO_DRIVER_PS2GS
+#undef SDL_VIDEO_DRIVER_QTOPIA
+#undef SDL_VIDEO_DRIVER_QUARTZ
+#undef SDL_VIDEO_DRIVER_RISCOS
+#undef SDL_VIDEO_DRIVER_SVGALIB
+#undef SDL_VIDEO_DRIVER_TOOLBOX
+#undef SDL_VIDEO_DRIVER_VGL
+#undef SDL_VIDEO_DRIVER_WINDIB
+#undef SDL_VIDEO_DRIVER_WSCONS
+#undef SDL_VIDEO_DRIVER_X11
+#undef SDL_VIDEO_DRIVER_X11_DGAMOUSE
+#undef SDL_VIDEO_DRIVER_X11_DPMS
+#undef SDL_VIDEO_DRIVER_X11_DYNAMIC
+#undef SDL_VIDEO_DRIVER_X11_DYNAMIC_XEXT
+#undef SDL_VIDEO_DRIVER_X11_DYNAMIC_XRANDR
+#undef SDL_VIDEO_DRIVER_X11_DYNAMIC_XRENDER
+#undef SDL_VIDEO_DRIVER_X11_VIDMODE
+#undef SDL_VIDEO_DRIVER_X11_XINERAMA
+#undef SDL_VIDEO_DRIVER_X11_XME
+#undef SDL_VIDEO_DRIVER_X11_XRANDR
+#undef SDL_VIDEO_DRIVER_X11_XV
+#undef SDL_VIDEO_DRIVER_XBIOS
+
+/* Enable OpenGL support */
+#undef SDL_VIDEO_OPENGL
+#undef SDL_VIDEO_OPENGL_GLX
+#undef SDL_VIDEO_OPENGL_WGL
+#undef SDL_VIDEO_OPENGL_OSMESA
+#undef SDL_VIDEO_OPENGL_OSMESA_DYNAMIC
+
+/* Enable assembly routines */
+#undef SDL_ASSEMBLY_ROUTINES
+#undef SDL_HERMES_BLITTERS
+#undef SDL_ALTIVEC_BLITTERS
+
+#endif /* _SDL_config_h */

src/dep/include/SDL/SDL_config_amiga.h

@@ -0,0 +1,80 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2006 Sam Lantinga
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+    Sam Lantinga
+    slouken@libsdl.org
+*/
+
+#ifndef _SDL_config_amiga_h
+#define _SDL_config_amiga_h
+
+#include "SDL_platform.h"
+
+/* This is a set of defines to configure the SDL features */
+
+#define SDL_HAS_64BIT_TYPE	1
+
+/* Useful headers */
+#define HAVE_SYS_TYPES_H	1
+#define HAVE_STDIO_H	1
+#define STDC_HEADERS	1
+#define HAVE_STRING_H	1
+#define HAVE_INTTYPES_H	1
+#define HAVE_SIGNAL_H	1
+
+/* C library functions */
+#define HAVE_MALLOC	1
+#define HAVE_CALLOC	1
+#define HAVE_REALLOC	1
+#define HAVE_FREE	1
+#define HAVE_ALLOCA	1
+#define HAVE_GETENV	1
+#define HAVE_PUTENV	1
+#define HAVE_MEMSET	1
+#define HAVE_MEMCPY	1
+#define HAVE_MEMMOVE	1
+#define HAVE_MEMCMP	1
+
+/* Enable various audio drivers */
+#define SDL_AUDIO_DRIVER_AHI	1
+#define SDL_AUDIO_DRIVER_DISK	1
+#define SDL_AUDIO_DRIVER_DUMMY	1
+
+/* Enable various cdrom drivers */
+#define SDL_CDROM_DUMMY	1
+
+/* Enable various input drivers */
+#define SDL_JOYSTICK_AMIGA	1
+
+/* Enable various shared object loading systems */
+#define SDL_LOADSO_DUMMY	1
+
+/* Enable various threading systems */
+#define SDL_THREAD_AMIGA	1
+
+/* Enable various timer systems */
+#define SDL_TIMER_AMIGA	1
+
+/* Enable various video drivers */
+#define SDL_VIDEO_DRIVER_CYBERGRAPHICS	1
+#define SDL_VIDEO_DRIVER_DUMMY	1
+
+/* Enable OpenGL support */
+#define SDL_VIDEO_OPENGL	1
+
+#endif /* _SDL_config_amiga_h */

src/dep/include/SDL/SDL_config_dreamcast.h

@@ -0,0 +1,106 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2006 Sam Lantinga
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+    Sam Lantinga
+    slouken@libsdl.org
+*/
+
+#ifndef _SDL_config_dreamcast_h
+#define _SDL_config_dreamcast_h
+
+#include "SDL_platform.h"
+
+/* This is a set of defines to configure the SDL features */
+
+typedef signed char int8_t;
+typedef unsigned char uint8_t;
+typedef signed short int16_t;
+typedef unsigned short uint16_t;
+typedef signed int int32_t;
+typedef unsigned int uint32_t;
+typedef signed long long int64_t;
+typedef unsigned long long uint64_t;
+typedef unsigned long uintptr_t;
+#define SDL_HAS_64BIT_TYPE	1
+
+/* Useful headers */
+#define HAVE_SYS_TYPES_H	1
+#define HAVE_STDIO_H	1
+#define STDC_HEADERS	1
+#define HAVE_STRING_H	1
+#define HAVE_CTYPE_H	1
+
+/* C library functions */
+#define HAVE_MALLOC	1
+#define HAVE_CALLOC	1
+#define HAVE_REALLOC	1
+#define HAVE_FREE	1
+#define HAVE_ALLOCA	1
+#define HAVE_GETENV	1
+#define HAVE_PUTENV	1
+#define HAVE_QSORT	1
+#define HAVE_ABS	1
+#define HAVE_BCOPY	1
+#define HAVE_MEMSET	1
+#define HAVE_MEMCPY	1
+#define HAVE_MEMMOVE	1
+#define HAVE_MEMCMP	1
+#define HAVE_STRLEN	1
+#define HAVE_STRDUP	1
+#define HAVE_INDEX	1
+#define HAVE_RINDEX	1
+#define HAVE_STRCHR	1
+#define HAVE_STRRCHR	1
+#define HAVE_STRSTR	1
+#define HAVE_STRTOL	1
+#define HAVE_STRTOD	1
+#define HAVE_ATOI	1
+#define HAVE_ATOF	1
+#define HAVE_STRCMP	1
+#define HAVE_STRNCMP	1
+#define HAVE_STRICMP	1
+#define HAVE_STRCASECMP	1
+#define HAVE_SSCANF	1
+#define HAVE_SNPRINTF	1
+#define HAVE_VSNPRINTF	1
+
+/* Enable various audio drivers */
+#define SDL_AUDIO_DRIVER_DC	1
+#define SDL_AUDIO_DRIVER_DISK	1
+#define SDL_AUDIO_DRIVER_DUMMY	1
+
+/* Enable various cdrom drivers */
+#define SDL_CDROM_DC	1
+
+/* Enable various input drivers */
+#define SDL_JOYSTICK_DC	1
+
+/* Enable various shared object loading systems */
+#define SDL_LOADSO_DUMMY	1
+
+/* Enable various threading systems */
+#define SDL_THREAD_DC	1
+
+/* Enable various timer systems */
+#define SDL_TIMER_DC	1
+
+/* Enable various video drivers */
+#define SDL_VIDEO_DRIVER_DC	1
+#define SDL_VIDEO_DRIVER_DUMMY	1
+
+#endif /* _SDL_config_dreamcast_h */

src/dep/include/SDL/SDL_config_macos.h

@@ -0,0 +1,112 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2006 Sam Lantinga
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+    Sam Lantinga
+    slouken@libsdl.org
+*/
+
+#ifndef _SDL_config_macos_h
+#define _SDL_config_macos_h
+
+#include "SDL_platform.h"
+
+/* This is a set of defines to configure the SDL features */
+
+#include <MacTypes.h>
+
+typedef SInt8	int8_t;
+typedef UInt8	uint8_t;
+typedef SInt16	int16_t;
+typedef UInt16	uint16_t;
+typedef SInt32	int32_t;
+typedef UInt32	uint32_t;
+typedef SInt64	int64_t;
+typedef UInt64	uint64_t;
+typedef unsigned long	uintptr_t;
+
+#define SDL_HAS_64BIT_TYPE	1
+
+/* Useful headers */
+#define HAVE_STDIO_H	1
+#define STDC_HEADERS	1
+#define HAVE_STRING_H	1
+#define HAVE_CTYPE_H	1
+#define HAVE_MATH_H	1
+#define HAVE_SIGNAL_H	1
+
+/* C library functions */
+#define HAVE_MALLOC	1
+#define HAVE_CALLOC	1
+#define HAVE_REALLOC	1
+#define HAVE_FREE	1
+#define HAVE_ALLOCA	1
+#define HAVE_ABS	1
+#define HAVE_MEMSET	1
+#define HAVE_MEMCPY	1
+#define HAVE_MEMMOVE	1
+#define HAVE_MEMCMP	1
+#define HAVE_STRLEN	1
+#define HAVE_STRCHR	1
+#define HAVE_STRRCHR	1
+#define HAVE_STRSTR	1
+#define HAVE_ITOA	1
+#define HAVE_STRTOL	1
+#define HAVE_STRTOD	1
+#define HAVE_ATOI	1
+#define HAVE_ATOF	1
+#define HAVE_STRCMP	1
+#define HAVE_STRNCMP	1
+#define HAVE_SSCANF	1
+
+/* Enable various audio drivers */
+#define SDL_AUDIO_DRIVER_SNDMGR	1
+#define SDL_AUDIO_DRIVER_DISK	1
+#define SDL_AUDIO_DRIVER_DUMMY	1
+
+/* Enable various cdrom drivers */
+#if TARGET_API_MAC_CARBON
+#define SDL_CDROM_DUMMY		1
+#else
+#define SDL_CDROM_MACOS		1
+#endif
+
+/* Enable various input drivers */
+#if TARGET_API_MAC_CARBON
+#define SDL_JOYSTICK_DUMMY	1
+#else
+#define SDL_JOYSTICK_MACOS	1
+#endif
+
+/* Enable various shared object loading systems */
+#define SDL_LOADSO_MACOS	1
+
+/* Enable various threading systems */
+#define SDL_THREADS_DISABLED	1
+
+/* Enable various timer systems */
+#define SDL_TIMER_MACOS	1
+
+/* Enable various video drivers */
+#define SDL_VIDEO_DRIVER_DUMMY	1
+#define SDL_VIDEO_DRIVER_DRAWSPROCKET	1
+#define SDL_VIDEO_DRIVER_TOOLBOX	1
+
+/* Enable OpenGL support */
+#define SDL_VIDEO_OPENGL	1
+
+#endif /* _SDL_config_macos_h */

src/dep/include/SDL/SDL_config_macosx.h

@@ -0,0 +1,132 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2006 Sam Lantinga
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+    Sam Lantinga
+    slouken@libsdl.org
+*/
+
+#ifndef _SDL_config_macosx_h
+#define _SDL_config_macosx_h
+
+#include "SDL_platform.h"
+
+/* This is a set of defines to configure the SDL features */
+
+#define SDL_HAS_64BIT_TYPE	1
+
+/* Useful headers */
+/* If we specified an SDK or have a post-PowerPC chip, then alloca.h exists. */
+#if ( (MAC_OS_X_VERSION_MIN_REQUIRED >= 1030) || (!defined(__POWERPC__)) )
+#define HAVE_ALLOCA_H		1
+#endif
+#define HAVE_SYS_TYPES_H	1
+#define HAVE_STDIO_H	1
+#define STDC_HEADERS	1
+#define HAVE_STRING_H	1
+#define HAVE_INTTYPES_H	1
+#define HAVE_STDINT_H	1
+#define HAVE_CTYPE_H	1
+#define HAVE_MATH_H	1
+#define HAVE_SIGNAL_H	1
+
+/* C library functions */
+#define HAVE_MALLOC	1
+#define HAVE_CALLOC	1
+#define HAVE_REALLOC	1
+#define HAVE_FREE	1
+#define HAVE_ALLOCA	1
+#define HAVE_GETENV	1
+#define HAVE_PUTENV	1
+#define HAVE_UNSETENV	1
+#define HAVE_QSORT	1
+#define HAVE_ABS	1
+#define HAVE_BCOPY	1
+#define HAVE_MEMSET	1
+#define HAVE_MEMCPY	1
+#define HAVE_MEMMOVE	1
+#define HAVE_MEMCMP	1
+#define HAVE_STRLEN	1
+#define HAVE_STRLCPY	1
+#define HAVE_STRLCAT	1
+#define HAVE_STRDUP	1
+#define HAVE_STRCHR	1
+#define HAVE_STRRCHR	1
+#define HAVE_STRSTR	1
+#define HAVE_STRTOL	1
+#define HAVE_STRTOUL	1
+#define HAVE_STRTOLL	1
+#define HAVE_STRTOULL	1
+#define HAVE_STRTOD	1
+#define HAVE_ATOI	1
+#define HAVE_ATOF	1
+#define HAVE_STRCMP	1
+#define HAVE_STRNCMP	1
+#define HAVE_STRCASECMP	1
+#define HAVE_STRNCASECMP 1
+#define HAVE_SSCANF	1
+#define HAVE_SNPRINTF	1
+#define HAVE_VSNPRINTF	1
+#define HAVE_SIGACTION	1
+#define HAVE_SETJMP	1
+#define HAVE_NANOSLEEP	1
+
+/* Enable various audio drivers */
+#define SDL_AUDIO_DRIVER_COREAUDIO	1
+#define SDL_AUDIO_DRIVER_SNDMGR	1
+#define SDL_AUDIO_DRIVER_DISK	1
+#define SDL_AUDIO_DRIVER_DUMMY	1
+
+/* Enable various cdrom drivers */
+#define SDL_CDROM_MACOSX	1
+
+/* Enable various input drivers */
+#define SDL_JOYSTICK_IOKIT	1
+
+/* Enable various shared object loading systems */
+#ifdef __ppc__
+/* For Mac OS X 10.2 compatibility */
+#define SDL_LOADSO_DLCOMPAT	1
+#else
+#define SDL_LOADSO_DLOPEN	1
+#endif
+
+/* Enable various threading systems */
+#define SDL_THREAD_PTHREAD	1
+#define SDL_THREAD_PTHREAD_RECURSIVE_MUTEX	1
+
+/* Enable various timer systems */
+#define SDL_TIMER_UNIX	1
+
+/* Enable various video drivers */
+#define SDL_VIDEO_DRIVER_DUMMY	1
+#if TARGET_API_MAC_CARBON
+#define SDL_VIDEO_DRIVER_TOOLBOX	1
+#else
+#define SDL_VIDEO_DRIVER_QUARTZ	1
+#endif
+
+/* Enable OpenGL support */
+#define SDL_VIDEO_OPENGL	1
+
+/* Enable assembly routines */
+#define SDL_ASSEMBLY_ROUTINES	1
+#ifdef __ppc__
+#define SDL_ALTIVEC_BLITTERS	1
+#endif
+
+#endif /* _SDL_config_macosx_h */

src/dep/include/SDL/SDL_config_minimal.h

@@ -0,0 +1,62 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2006 Sam Lantinga
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+    Sam Lantinga
+    slouken@libsdl.org
+*/
+
+#ifndef _SDL_config_minimal_h
+#define _SDL_config_minimal_h
+
+#include "SDL_platform.h"
+
+/* This is the minimal configuration that can be used to build SDL */
+
+#include <stdarg.h>
+
+typedef signed char int8_t;
+typedef unsigned char uint8_t;
+typedef signed short int16_t;
+typedef unsigned short uint16_t;
+typedef signed int int32_t;
+typedef unsigned int uint32_t;
+typedef unsigned int size_t;
+typedef unsigned long uintptr_t;
+
+/* Enable the dummy audio driver (src/audio/dummy/\*.c) */
+#define SDL_AUDIO_DRIVER_DUMMY	1
+
+/* Enable the stub cdrom driver (src/cdrom/dummy/\*.c) */
+#define SDL_CDROM_DISABLED	1
+
+/* Enable the stub joystick driver (src/joystick/dummy/\*.c) */
+#define SDL_JOYSTICK_DISABLED	1
+
+/* Enable the stub shared object loader (src/loadso/dummy/\*.c) */
+#define SDL_LOADSO_DISABLED	1
+
+/* Enable the stub thread support (src/thread/generic/\*.c) */
+#define SDL_THREADS_DISABLED	1
+
+/* Enable the stub timer support (src/timer/dummy/\*.c) */
+#define SDL_TIMERS_DISABLED	1
+
+/* Enable the dummy video driver (src/video/dummy/\*.c) */
+#define SDL_VIDEO_DRIVER_DUMMY	1
+
+#endif /* _SDL_config_minimal_h */

src/dep/include/SDL/SDL_config_os2.h

@@ -0,0 +1,141 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2006 Sam Lantinga
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+    Sam Lantinga
+    slouken@libsdl.org
+*/
+
+#ifndef _SDL_config_os2_h
+#define _SDL_config_os2_h
+
+#include "SDL_platform.h"
+
+/* This is a set of defines to configure the SDL features */
+
+typedef signed char         int8_t;
+typedef unsigned char       uint8_t;
+typedef signed short        int16_t;
+typedef unsigned short      uint16_t;
+typedef signed int          int32_t;
+typedef unsigned int        uint32_t;
+typedef unsigned int        size_t;
+typedef unsigned long       uintptr_t;
+typedef signed long long    int64_t;
+typedef unsigned long long  uint64_t;
+
+#define SDL_HAS_64BIT_TYPE	1
+
+/* Use Watcom's LIBC */
+#define HAVE_LIBC 1
+
+/* Useful headers */
+#define HAVE_SYS_TYPES_H 1
+#define HAVE_STDIO_H 1
+#define STDC_HEADERS 1
+#define HAVE_STDLIB_H 1
+#define HAVE_STDARG_H 1
+#define HAVE_MALLOC_H 1
+#define HAVE_MEMORY_H 1
+#define HAVE_STRING_H 1
+#define HAVE_STRINGS_H 1
+#define HAVE_INTTYPES_H 1
+#define HAVE_STDINT_H 1
+#define HAVE_CTYPE_H 1
+#define HAVE_MATH_H 1
+#define HAVE_SIGNAL_H 1
+
+/* C library functions */
+#define HAVE_MALLOC 1
+#define HAVE_CALLOC 1
+#define HAVE_REALLOC 1
+#define HAVE_FREE 1
+#define HAVE_ALLOCA 1
+#define HAVE_GETENV 1
+#define HAVE_PUTENV 1
+#define HAVE_UNSETENV 1
+#define HAVE_QSORT 1
+#define HAVE_ABS 1
+#define HAVE_BCOPY 1
+#define HAVE_MEMSET 1
+#define HAVE_MEMCPY 1
+#define HAVE_MEMMOVE 1
+#define HAVE_MEMCMP 1
+#define HAVE_STRLEN 1
+#define HAVE_STRLCPY 1
+#define HAVE_STRLCAT 1
+#define HAVE_STRDUP 1
+#define HAVE__STRREV 1
+#define HAVE__STRUPR 1
+#define HAVE__STRLWR 1
+#define HAVE_INDEX 1
+#define HAVE_RINDEX 1
+#define HAVE_STRCHR 1
+#define HAVE_STRRCHR 1
+#define HAVE_STRSTR 1
+#define HAVE_ITOA 1
+#define HAVE__LTOA 1
+#define HAVE__UITOA 1
+#define HAVE__ULTOA 1
+#define HAVE_STRTOL 1
+#define HAVE__I64TOA 1
+#define HAVE__UI64TOA 1
+#define HAVE_STRTOLL 1
+#define HAVE_STRTOD 1
+#define HAVE_ATOI 1
+#define HAVE_ATOF 1
+#define HAVE_STRCMP 1
+#define HAVE_STRNCMP 1
+#define HAVE_STRICMP 1
+#define HAVE_STRCASECMP 1
+#define HAVE_SSCANF 1
+#define HAVE_SNPRINTF 1
+#define HAVE_VSNPRINTF 1
+#define HAVE_SETJMP 1
+#define HAVE_CLOCK_GETTIME 1
+
+/* Enable various audio drivers */
+#define SDL_AUDIO_DRIVER_DART	1
+#define SDL_AUDIO_DRIVER_DISK	1
+#define SDL_AUDIO_DRIVER_DUMMY	1
+
+/* Enable various cdrom drivers */
+#define SDL_CDROM_OS2	1
+
+/* Enable various input drivers */
+#define SDL_JOYSTICK_OS2	1
+
+/* Enable various shared object loading systems */
+#define SDL_LOADSO_OS2	1
+
+/* Enable various threading systems */
+#define SDL_THREAD_OS2	1
+
+/* Enable various timer systems */
+#define SDL_TIMER_OS2	1
+
+/* Enable various video drivers */
+#define SDL_VIDEO_DRIVER_DUMMY	1
+#define SDL_VIDEO_DRIVER_OS2FS	1
+
+/* Enable OpenGL support */
+/* Nothing here yet for OS/2... :( */
+
+/* Enable assembly routines where available */
+#define SDL_ASSEMBLY_ROUTINES	1
+
+#endif /* _SDL_config_os2_h */

src/dep/include/SDL/SDL_config_win32.h

@@ -0,0 +1,173 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2006 Sam Lantinga
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+    Sam Lantinga
+    slouken@libsdl.org
+*/
+
+#ifndef _SDL_config_win32_h
+#define _SDL_config_win32_h
+
+#include "SDL_platform.h"
+
+/* This is a set of defines to configure the SDL features */
+
+#ifdef __GNUC__
+#define HAVE_STDINT_H	1
+#elif defined(_MSC_VER)
+typedef signed __int8		int8_t;
+typedef unsigned __int8		uint8_t;
+typedef signed __int16		int16_t;
+typedef unsigned __int16	uint16_t;
+typedef signed __int32		int32_t;
+typedef unsigned __int32	uint32_t;
+typedef signed __int64		int64_t;
+typedef unsigned __int64	uint64_t;
+#ifndef _UINTPTR_T_DEFINED
+#ifdef  _WIN64
+typedef unsigned __int64    uintptr_t;
+#else
+typedef unsigned int   uintptr_t;
+#endif
+#define _UINTPTR_T_DEFINED
+#endif
+#else	/* !__GNUC__ && !_MSC_VER */
+typedef signed char int8_t;
+typedef unsigned char uint8_t;
+typedef signed short int16_t;
+typedef unsigned short uint16_t;
+typedef signed int int32_t;
+typedef unsigned int uint32_t;
+typedef signed long long int64_t;
+typedef unsigned long long uint64_t;
+#ifndef _SIZE_T_DEFINED_
+#define _SIZE_T_DEFINED_
+typedef unsigned int size_t;
+#endif
+typedef unsigned int uintptr_t;
+#endif /* __GNUC__ || _MSC_VER */
+#define SDL_HAS_64BIT_TYPE	1
+
+/* Enabled for SDL 1.2 (binary compatibility) */
+#define HAVE_LIBC	1
+#ifdef HAVE_LIBC
+/* Useful headers */
+#define HAVE_STDIO_H 1
+#define STDC_HEADERS 1
+#define HAVE_STRING_H 1
+#define HAVE_CTYPE_H 1
+#define HAVE_MATH_H 1
+#ifndef _WIN32_WCE
+#define HAVE_SIGNAL_H 1
+#endif
+
+/* C library functions */
+#define HAVE_MALLOC 1
+#define HAVE_CALLOC 1
+#define HAVE_REALLOC 1
+#define HAVE_FREE 1
+#define HAVE_ALLOCA 1
+#define HAVE_QSORT 1
+#define HAVE_ABS 1
+#define HAVE_MEMSET 1
+#define HAVE_MEMCPY 1
+#define HAVE_MEMMOVE 1
+#define HAVE_MEMCMP 1
+#define HAVE_STRLEN 1
+#define HAVE__STRREV 1
+#define HAVE__STRUPR 1
+#define HAVE__STRLWR 1
+#define HAVE_STRCHR 1
+#define HAVE_STRRCHR 1
+#define HAVE_STRSTR 1
+#define HAVE_ITOA 1
+#define HAVE__LTOA 1
+#define HAVE__ULTOA 1
+#define HAVE_STRTOL 1
+#define HAVE_STRTOUL 1
+#define HAVE_STRTOLL 1
+#define HAVE_STRTOD 1
+#define HAVE_ATOI 1
+#define HAVE_ATOF 1
+#define HAVE_STRCMP 1
+#define HAVE_STRNCMP 1
+#define HAVE__STRICMP 1
+#define HAVE__STRNICMP 1
+#define HAVE_SSCANF 1
+#else
+#define HAVE_STDARG_H	1
+#define HAVE_STDDEF_H	1
+#endif
+
+/* Enable various audio drivers */
+#ifndef _WIN32_WCE
+#define SDL_AUDIO_DRIVER_DSOUND	1
+#endif
+#define SDL_AUDIO_DRIVER_WAVEOUT	1
+#define SDL_AUDIO_DRIVER_DISK	1
+#define SDL_AUDIO_DRIVER_DUMMY	1
+
+/* Enable various cdrom drivers */
+#ifdef _WIN32_WCE
+#define SDL_CDROM_DISABLED      1
+#else
+#define SDL_CDROM_WIN32		1
+#endif
+
+/* Enable various input drivers */
+#ifdef _WIN32_WCE
+#define SDL_JOYSTICK_DISABLED   1
+#else
+#define SDL_JOYSTICK_WINMM	1
+#endif
+
+/* Enable various shared object loading systems */
+#define SDL_LOADSO_WIN32	1
+
+/* Enable various threading systems */
+#define SDL_THREAD_WIN32	1
+
+/* Enable various timer systems */
+#ifdef _WIN32_WCE
+#define SDL_TIMER_WINCE	1
+#else
+#define SDL_TIMER_WIN32	1
+#endif
+
+/* Enable various video drivers */
+#ifdef _WIN32_WCE
+#define SDL_VIDEO_DRIVER_GAPI	1
+#endif
+#ifndef _WIN32_WCE
+#define SDL_VIDEO_DRIVER_DDRAW	1
+#endif
+#define SDL_VIDEO_DRIVER_DUMMY	1
+#define SDL_VIDEO_DRIVER_WINDIB	1
+
+/* Enable OpenGL support */
+#ifndef _WIN32_WCE
+#define SDL_VIDEO_OPENGL	1
+#define SDL_VIDEO_OPENGL_WGL	1
+#endif
+
+/* Enable assembly routines (Win64 doesn't have inline asm) */
+#ifndef _WIN64
+#define SDL_ASSEMBLY_ROUTINES	1
+#endif
+
+#endif /* _SDL_config_win32_h */

src/dep/include/SDL/SDL_copying.h

@@ -0,0 +1,22 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2006 Sam Lantinga
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+    Sam Lantinga
+    slouken@libsdl.org
+*/
+

src/dep/include/SDL/SDL_cpuinfo.h

@@ -0,0 +1,75 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2006 Sam Lantinga
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+    Sam Lantinga
+    slouken@libsdl.org
+*/
+
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+/* CPU feature detection for SDL                                       */
+
+#ifndef _SDL_cpuinfo_h
+#define _SDL_cpuinfo_h
+
+#include "SDL_stdinc.h"
+
+#include "begin_code.h"
+/* Set up for C function definitions, even when using C++ */
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* This function returns true if the CPU has the RDTSC instruction
+ */
+extern DECLSPEC SDL_bool SDLCALL SDL_HasRDTSC(void);
+
+/* This function returns true if the CPU has MMX features
+ */
+extern DECLSPEC SDL_bool SDLCALL SDL_HasMMX(void);
+
+/* This function returns true if the CPU has MMX Ext. features
+ */
+extern DECLSPEC SDL_bool SDLCALL SDL_HasMMXExt(void);
+
+/* This function returns true if the CPU has 3DNow features
+ */
+extern DECLSPEC SDL_bool SDLCALL SDL_Has3DNow(void);
+
+/* This function returns true if the CPU has 3DNow! Ext. features
+ */
+extern DECLSPEC SDL_bool SDLCALL SDL_Has3DNowExt(void);
+
+/* This function returns true if the CPU has SSE features
+ */
+extern DECLSPEC SDL_bool SDLCALL SDL_HasSSE(void);
+
+/* This function returns true if the CPU has SSE2 features
+ */
+extern DECLSPEC SDL_bool SDLCALL SDL_HasSSE2(void);
+
+/* This function returns true if the CPU has AltiVec features
+ */
+extern DECLSPEC SDL_bool SDLCALL SDL_HasAltiVec(void);
+
+/* Ends C function definitions when using C++ */
+#ifdef __cplusplus
+}
+#endif
+#include "close_code.h"
+
+#endif /* _SDL_cpuinfo_h */

src/dep/include/SDL/SDL_endian.h

@@ -0,0 +1,192 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2006 Sam Lantinga
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+    Sam Lantinga
+    slouken@libsdl.org
+*/
+
+/* Functions for reading and writing endian-specific values */
+
+#ifndef _SDL_endian_h
+#define _SDL_endian_h
+
+#include "SDL_stdinc.h"
+
+/* The two types of endianness */
+#define SDL_LIL_ENDIAN	1234
+#define SDL_BIG_ENDIAN	4321
+
+#ifndef SDL_BYTEORDER	/* Not defined in SDL_config.h? */
+#if defined(__hppa__) || \
+    defined(__m68k__) || defined(mc68000) || defined(_M_M68K) || \
+    (defined(__MIPS__) && defined(__MISPEB__)) || \
+    defined(__ppc__) || defined(__POWERPC__) || defined(_M_PPC) || \
+    defined(__sparc__)
+#define SDL_BYTEORDER	SDL_BIG_ENDIAN
+#else
+#define SDL_BYTEORDER	SDL_LIL_ENDIAN
+#endif
+#endif /* !SDL_BYTEORDER */
+
+
+#include "begin_code.h"
+/* Set up for C function definitions, even when using C++ */
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Use inline functions for compilers that support them, and static
+   functions for those that do not.  Because these functions become
+   static for compilers that do not support inline functions, this
+   header should only be included in files that actually use them.
+*/
+#if defined(__GNUC__) && defined(__i386__) && \
+   !(__GNUC__ == 2 && __GNUC_MINOR__ == 95 /* broken gcc version */)
+static __inline__ Uint16 SDL_Swap16(Uint16 x)
+{
+	__asm__("xchgb %b0,%h0" : "=q" (x) :  "0" (x));
+	return x;
+}
+#elif defined(__GNUC__) && defined(__x86_64__)
+static __inline__ Uint16 SDL_Swap16(Uint16 x)
+{
+	__asm__("xchgb %b0,%h0" : "=Q" (x) :  "0" (x));
+	return x;
+}
+#elif defined(__GNUC__) && (defined(__powerpc__) || defined(__ppc__))
+static __inline__ Uint16 SDL_Swap16(Uint16 x)
+{
+	Uint16 result;
+
+	__asm__("rlwimi %0,%2,8,16,23" : "=&r" (result) : "0" (x >> 8), "r" (x));
+	return result;
+}
+#elif defined(__GNUC__) && (defined(__M68000__) || defined(__M68020__))
+static __inline__ Uint16 SDL_Swap16(Uint16 x)
+{
+	__asm__("rorw #8,%0" : "=d" (x) :  "0" (x) : "cc");
+	return x;
+}
+#else
+static __inline__ Uint16 SDL_Swap16(Uint16 x) {
+	return((x<<8)|(x>>8));
+}
+#endif
+
+#if defined(__GNUC__) && defined(__i386__)
+static __inline__ Uint32 SDL_Swap32(Uint32 x)
+{
+	__asm__("bswap %0" : "=r" (x) : "0" (x));
+	return x;
+}
+#elif defined(__GNUC__) && defined(__x86_64__)
+static __inline__ Uint32 SDL_Swap32(Uint32 x)
+{
+	__asm__("bswapl %0" : "=r" (x) : "0" (x));
+	return x;
+}
+#elif defined(__GNUC__) && (defined(__powerpc__) || defined(__ppc__))
+static __inline__ Uint32 SDL_Swap32(Uint32 x)
+{
+	Uint32 result;
+
+	__asm__("rlwimi %0,%2,24,16,23" : "=&r" (result) : "0" (x>>24), "r" (x));
+	__asm__("rlwimi %0,%2,8,8,15"   : "=&r" (result) : "0" (result),    "r" (x));
+	__asm__("rlwimi %0,%2,24,0,7"   : "=&r" (result) : "0" (result),    "r" (x));
+	return result;
+}
+#elif defined(__GNUC__) && (defined(__M68000__) || defined(__M68020__))
+static __inline__ Uint32 SDL_Swap32(Uint32 x)
+{
+	__asm__("rorw #8,%0\n\tswap %0\n\trorw #8,%0" : "=d" (x) :  "0" (x) : "cc");
+	return x;
+}
+#else
+static __inline__ Uint32 SDL_Swap32(Uint32 x) {
+	return((x<<24)|((x<<8)&0x00FF0000)|((x>>8)&0x0000FF00)|(x>>24));
+}
+#endif
+
+#ifdef SDL_HAS_64BIT_TYPE
+#if defined(__GNUC__) && defined(__i386__)
+static __inline__ Uint64 SDL_Swap64(Uint64 x)
+{
+	union { 
+		struct { Uint32 a,b; } s;
+		Uint64 u;
+	} v;
+	v.u = x;
+	__asm__("bswapl %0 ; bswapl %1 ; xchgl %0,%1" 
+	        : "=r" (v.s.a), "=r" (v.s.b) 
+	        : "0" (v.s.a), "1" (v.s.b)); 
+	return v.u;
+}
+#elif defined(__GNUC__) && defined(__x86_64__)
+static __inline__ Uint64 SDL_Swap64(Uint64 x)
+{
+	__asm__("bswapq %0" : "=r" (x) : "0" (x));
+	return x;
+}
+#else
+static __inline__ Uint64 SDL_Swap64(Uint64 x)
+{
+	Uint32 hi, lo;
+
+	/* Separate into high and low 32-bit values and swap them */
+	lo = (Uint32)(x&0xFFFFFFFF);
+	x >>= 32;
+	hi = (Uint32)(x&0xFFFFFFFF);
+	x = SDL_Swap32(lo);
+	x <<= 32;
+	x |= SDL_Swap32(hi);
+	return(x);
+}
+#endif
+#else
+/* This is mainly to keep compilers from complaining in SDL code.
+   If there is no real 64-bit datatype, then compilers will complain about
+   the fake 64-bit datatype that SDL provides when it compiles user code.
+*/
+#define SDL_Swap64(X)	(X)
+#endif /* SDL_HAS_64BIT_TYPE */
+
+
+/* Byteswap item from the specified endianness to the native endianness */
+#if SDL_BYTEORDER == SDL_LIL_ENDIAN
+#define SDL_SwapLE16(X)	(X)
+#define SDL_SwapLE32(X)	(X)
+#define SDL_SwapLE64(X)	(X)
+#define SDL_SwapBE16(X)	SDL_Swap16(X)
+#define SDL_SwapBE32(X)	SDL_Swap32(X)
+#define SDL_SwapBE64(X)	SDL_Swap64(X)
+#else
+#define SDL_SwapLE16(X)	SDL_Swap16(X)
+#define SDL_SwapLE32(X)	SDL_Swap32(X)
+#define SDL_SwapLE64(X)	SDL_Swap64(X)
+#define SDL_SwapBE16(X)	(X)
+#define SDL_SwapBE32(X)	(X)
+#define SDL_SwapBE64(X)	(X)
+#endif
+
+/* Ends C function definitions when using C++ */
+#ifdef __cplusplus
+}
+#endif
+#include "close_code.h"
+
+#endif /* _SDL_endian_h */

src/dep/include/SDL/SDL_error.h

@@ -0,0 +1,61 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2006 Sam Lantinga
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+    Sam Lantinga
+    slouken@libsdl.org
+*/
+
+/* Simple error message routines for SDL */
+
+#ifndef _SDL_error_h
+#define _SDL_error_h
+
+#include "SDL_stdinc.h"
+
+#include "begin_code.h"
+/* Set up for C function definitions, even when using C++ */
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Public functions */
+extern DECLSPEC void SDLCALL SDL_SetError(const char *fmt, ...);
+extern DECLSPEC char * SDLCALL SDL_GetError(void);
+extern DECLSPEC void SDLCALL SDL_ClearError(void);
+
+/* Private error message function - used internally */
+#define SDL_OutOfMemory()	SDL_Error(SDL_ENOMEM)
+#define SDL_Unsupported()	SDL_Error(SDL_UNSUPPORTED)
+typedef enum {
+	SDL_ENOMEM,
+	SDL_EFREAD,
+	SDL_EFWRITE,
+	SDL_EFSEEK,
+	SDL_UNSUPPORTED,
+	SDL_LASTERROR
+} SDL_errorcode;
+extern DECLSPEC void SDLCALL SDL_Error(SDL_errorcode code);
+
+
+/* Ends C function definitions when using C++ */
+#ifdef __cplusplus
+}
+#endif
+#include "close_code.h"
+
+#endif /* _SDL_error_h */

src/dep/include/SDL/SDL_events.h

@@ -0,0 +1,337 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2006 Sam Lantinga
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+    Sam Lantinga
+    slouken@libsdl.org
+*/
+
+/* Include file for SDL event handling */
+
+#ifndef _SDL_events_h
+#define _SDL_events_h
+
+#include "SDL_stdinc.h"
+#include "SDL_error.h"
+#include "SDL_active.h"
+#include "SDL_keyboard.h"
+#include "SDL_mouse.h"
+#include "SDL_joystick.h"
+#include "SDL_quit.h"
+
+#include "begin_code.h"
+/* Set up for C function definitions, even when using C++ */
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* General keyboard/mouse state definitions */
+#define SDL_RELEASED	0
+#define SDL_PRESSED	1
+
+/* Event enumerations */
+typedef enum {
+       SDL_NOEVENT = 0,			/* Unused (do not remove) */
+       SDL_ACTIVEEVENT,			/* Application loses/gains visibility */
+       SDL_KEYDOWN,			/* Keys pressed */
+       SDL_KEYUP,			/* Keys released */
+       SDL_MOUSEMOTION,			/* Mouse moved */
+       SDL_MOUSEBUTTONDOWN,		/* Mouse button pressed */
+       SDL_MOUSEBUTTONUP,		/* Mouse button released */
+       SDL_JOYAXISMOTION,		/* Joystick axis motion */
+       SDL_JOYBALLMOTION,		/* Joystick trackball motion */
+       SDL_JOYHATMOTION,		/* Joystick hat position change */
+       SDL_JOYBUTTONDOWN,		/* Joystick button pressed */
+       SDL_JOYBUTTONUP,			/* Joystick button released */
+       SDL_QUIT,			/* User-requested quit */
+       SDL_SYSWMEVENT,			/* System specific event */
+       SDL_EVENT_RESERVEDA,		/* Reserved for future use.. */
+       SDL_EVENT_RESERVEDB,		/* Reserved for future use.. */
+       SDL_VIDEORESIZE,			/* User resized video mode */
+       SDL_VIDEOEXPOSE,			/* Screen needs to be redrawn */
+       SDL_EVENT_RESERVED2,		/* Reserved for future use.. */
+       SDL_EVENT_RESERVED3,		/* Reserved for future use.. */
+       SDL_EVENT_RESERVED4,		/* Reserved for future use.. */
+       SDL_EVENT_RESERVED5,		/* Reserved for future use.. */
+       SDL_EVENT_RESERVED6,		/* Reserved for future use.. */
+       SDL_EVENT_RESERVED7,		/* Reserved for future use.. */
+       /* Events SDL_USEREVENT through SDL_MAXEVENTS-1 are for your use */
+       SDL_USEREVENT = 24,
+       /* This last event is only for bounding internal arrays
+	  It is the number of bits in the event mask datatype -- Uint32
+        */
+       SDL_NUMEVENTS = 32
+} SDL_EventType;
+
+/* Predefined event masks */
+#define SDL_EVENTMASK(X)	(1<<(X))
+typedef enum {
+	SDL_ACTIVEEVENTMASK	= SDL_EVENTMASK(SDL_ACTIVEEVENT),
+	SDL_KEYDOWNMASK		= SDL_EVENTMASK(SDL_KEYDOWN),
+	SDL_KEYUPMASK		= SDL_EVENTMASK(SDL_KEYUP),
+	SDL_KEYEVENTMASK	= SDL_EVENTMASK(SDL_KEYDOWN)|
+	                          SDL_EVENTMASK(SDL_KEYUP),
+	SDL_MOUSEMOTIONMASK	= SDL_EVENTMASK(SDL_MOUSEMOTION),
+	SDL_MOUSEBUTTONDOWNMASK	= SDL_EVENTMASK(SDL_MOUSEBUTTONDOWN),
+	SDL_MOUSEBUTTONUPMASK	= SDL_EVENTMASK(SDL_MOUSEBUTTONUP),
+	SDL_MOUSEEVENTMASK	= SDL_EVENTMASK(SDL_MOUSEMOTION)|
+	                          SDL_EVENTMASK(SDL_MOUSEBUTTONDOWN)|
+	                          SDL_EVENTMASK(SDL_MOUSEBUTTONUP),
+	SDL_JOYAXISMOTIONMASK	= SDL_EVENTMASK(SDL_JOYAXISMOTION),
+	SDL_JOYBALLMOTIONMASK	= SDL_EVENTMASK(SDL_JOYBALLMOTION),
+	SDL_JOYHATMOTIONMASK	= SDL_EVENTMASK(SDL_JOYHATMOTION),
+	SDL_JOYBUTTONDOWNMASK	= SDL_EVENTMASK(SDL_JOYBUTTONDOWN),
+	SDL_JOYBUTTONUPMASK	= SDL_EVENTMASK(SDL_JOYBUTTONUP),
+	SDL_JOYEVENTMASK	= SDL_EVENTMASK(SDL_JOYAXISMOTION)|
+	                          SDL_EVENTMASK(SDL_JOYBALLMOTION)|
+	                          SDL_EVENTMASK(SDL_JOYHATMOTION)|
+	                          SDL_EVENTMASK(SDL_JOYBUTTONDOWN)|
+	                          SDL_EVENTMASK(SDL_JOYBUTTONUP),
+	SDL_VIDEORESIZEMASK	= SDL_EVENTMASK(SDL_VIDEORESIZE),
+	SDL_VIDEOEXPOSEMASK	= SDL_EVENTMASK(SDL_VIDEOEXPOSE),
+	SDL_QUITMASK		= SDL_EVENTMASK(SDL_QUIT),
+	SDL_SYSWMEVENTMASK	= SDL_EVENTMASK(SDL_SYSWMEVENT)
+} SDL_EventMask ;
+#define SDL_ALLEVENTS		0xFFFFFFFF
+
+/* Application visibility event structure */
+typedef struct SDL_ActiveEvent {
+	Uint8 type;	/* SDL_ACTIVEEVENT */
+	Uint8 gain;	/* Whether given states were gained or lost (1/0) */
+	Uint8 state;	/* A mask of the focus states */
+} SDL_ActiveEvent;
+
+/* Keyboard event structure */
+typedef struct SDL_KeyboardEvent {
+	Uint8 type;	/* SDL_KEYDOWN or SDL_KEYUP */
+	Uint8 which;	/* The keyboard device index */
+	Uint8 state;	/* SDL_PRESSED or SDL_RELEASED */
+	SDL_keysym keysym;
+} SDL_KeyboardEvent;
+
+/* Mouse motion event structure */
+typedef struct SDL_MouseMotionEvent {
+	Uint8 type;	/* SDL_MOUSEMOTION */
+	Uint8 which;	/* The mouse device index */
+	Uint8 state;	/* The current button state */
+	Uint16 x, y;	/* The X/Y coordinates of the mouse */
+	Sint16 xrel;	/* The relative motion in the X direction */
+	Sint16 yrel;	/* The relative motion in the Y direction */
+} SDL_MouseMotionEvent;
+
+/* Mouse button event structure */
+typedef struct SDL_MouseButtonEvent {
+	Uint8 type;	/* SDL_MOUSEBUTTONDOWN or SDL_MOUSEBUTTONUP */
+	Uint8 which;	/* The mouse device index */
+	Uint8 button;	/* The mouse button index */
+	Uint8 state;	/* SDL_PRESSED or SDL_RELEASED */
+	Uint16 x, y;	/* The X/Y coordinates of the mouse at press time */
+} SDL_MouseButtonEvent;
+
+/* Joystick axis motion event structure */
+typedef struct SDL_JoyAxisEvent {
+	Uint8 type;	/* SDL_JOYAXISMOTION */
+	Uint8 which;	/* The joystick device index */
+	Uint8 axis;	/* The joystick axis index */
+	Sint16 value;	/* The axis value (range: -32768 to 32767) */
+} SDL_JoyAxisEvent;
+
+/* Joystick trackball motion event structure */
+typedef struct SDL_JoyBallEvent {
+	Uint8 type;	/* SDL_JOYBALLMOTION */
+	Uint8 which;	/* The joystick device index */
+	Uint8 ball;	/* The joystick trackball index */
+	Sint16 xrel;	/* The relative motion in the X direction */
+	Sint16 yrel;	/* The relative motion in the Y direction */
+} SDL_JoyBallEvent;
+
+/* Joystick hat position change event structure */
+typedef struct SDL_JoyHatEvent {
+	Uint8 type;	/* SDL_JOYHATMOTION */
+	Uint8 which;	/* The joystick device index */
+	Uint8 hat;	/* The joystick hat index */
+	Uint8 value;	/* The hat position value:
+			    SDL_HAT_LEFTUP   SDL_HAT_UP       SDL_HAT_RIGHTUP
+			    SDL_HAT_LEFT     SDL_HAT_CENTERED SDL_HAT_RIGHT
+			    SDL_HAT_LEFTDOWN SDL_HAT_DOWN     SDL_HAT_RIGHTDOWN
+			   Note that zero means the POV is centered.
+			*/
+} SDL_JoyHatEvent;
+
+/* Joystick button event structure */
+typedef struct SDL_JoyButtonEvent {
+	Uint8 type;	/* SDL_JOYBUTTONDOWN or SDL_JOYBUTTONUP */
+	Uint8 which;	/* The joystick device index */
+	Uint8 button;	/* The joystick button index */
+	Uint8 state;	/* SDL_PRESSED or SDL_RELEASED */
+} SDL_JoyButtonEvent;
+
+/* The "window resized" event
+   When you get this event, you are responsible for setting a new video
+   mode with the new width and height.
+ */
+typedef struct SDL_ResizeEvent {
+	Uint8 type;	/* SDL_VIDEORESIZE */
+	int w;		/* New width */
+	int h;		/* New height */
+} SDL_ResizeEvent;
+
+/* The "screen redraw" event */
+typedef struct SDL_ExposeEvent {
+	Uint8 type;	/* SDL_VIDEOEXPOSE */
+} SDL_ExposeEvent;
+
+/* The "quit requested" event */
+typedef struct SDL_QuitEvent {
+	Uint8 type;	/* SDL_QUIT */
+} SDL_QuitEvent;
+
+/* A user-defined event type */
+typedef struct SDL_UserEvent {
+	Uint8 type;	/* SDL_USEREVENT through SDL_NUMEVENTS-1 */
+	int code;	/* User defined event code */
+	void *data1;	/* User defined data pointer */
+	void *data2;	/* User defined data pointer */
+} SDL_UserEvent;
+
+/* If you want to use this event, you should include SDL_syswm.h */
+struct SDL_SysWMmsg;
+typedef struct SDL_SysWMmsg SDL_SysWMmsg;
+typedef struct SDL_SysWMEvent {
+	Uint8 type;
+	SDL_SysWMmsg *msg;
+} SDL_SysWMEvent;
+
+/* General event structure */
+typedef union SDL_Event {
+	Uint8 type;
+	SDL_ActiveEvent active;
+	SDL_KeyboardEvent key;
+	SDL_MouseMotionEvent motion;
+	SDL_MouseButtonEvent button;
+	SDL_JoyAxisEvent jaxis;
+	SDL_JoyBallEvent jball;
+	SDL_JoyHatEvent jhat;
+	SDL_JoyButtonEvent jbutton;
+	SDL_ResizeEvent resize;
+	SDL_ExposeEvent expose;
+	SDL_QuitEvent quit;
+	SDL_UserEvent user;
+	SDL_SysWMEvent syswm;
+} SDL_Event;
+
+
+/* Function prototypes */
+
+/* Pumps the event loop, gathering events from the input devices.
+   This function updates the event queue and internal input device state.
+   This should only be run in the thread that sets the video mode.
+*/
+extern DECLSPEC void SDLCALL SDL_PumpEvents(void);
+
+/* Checks the event queue for messages and optionally returns them.
+   If 'action' is SDL_ADDEVENT, up to 'numevents' events will be added to
+   the back of the event queue.
+   If 'action' is SDL_PEEKEVENT, up to 'numevents' events at the front
+   of the event queue, matching 'mask', will be returned and will not
+   be removed from the queue.
+   If 'action' is SDL_GETEVENT, up to 'numevents' events at the front 
+   of the event queue, matching 'mask', will be returned and will be
+   removed from the queue.
+   This function returns the number of events actually stored, or -1
+   if there was an error.  This function is thread-safe.
+*/
+typedef enum {
+	SDL_ADDEVENT,
+	SDL_PEEKEVENT,
+	SDL_GETEVENT
+} SDL_eventaction;
+/* */
+extern DECLSPEC int SDLCALL SDL_PeepEvents(SDL_Event *events, int numevents,
+				SDL_eventaction action, Uint32 mask);
+
+/* Polls for currently pending events, and returns 1 if there are any pending
+   events, or 0 if there are none available.  If 'event' is not NULL, the next
+   event is removed from the queue and stored in that area.
+ */
+extern DECLSPEC int SDLCALL SDL_PollEvent(SDL_Event *event);
+
+/* Waits indefinitely for the next available event, returning 1, or 0 if there
+   was an error while waiting for events.  If 'event' is not NULL, the next
+   event is removed from the queue and stored in that area.
+ */
+extern DECLSPEC int SDLCALL SDL_WaitEvent(SDL_Event *event);
+
+/* Add an event to the event queue.
+   This function returns 0 on success, or -1 if the event queue was full
+   or there was some other error.
+ */
+extern DECLSPEC int SDLCALL SDL_PushEvent(SDL_Event *event);
+
+/*
+  This function sets up a filter to process all events before they
+  change internal state and are posted to the internal event queue.
+
+  The filter is protypted as:
+*/
+typedef int (SDLCALL *SDL_EventFilter)(const SDL_Event *event);
+/*
+  If the filter returns 1, then the event will be added to the internal queue.
+  If it returns 0, then the event will be dropped from the queue, but the 
+  internal state will still be updated.  This allows selective filtering of
+  dynamically arriving events.
+
+  WARNING:  Be very careful of what you do in the event filter function, as 
+            it may run in a different thread!
+
+  There is one caveat when dealing with the SDL_QUITEVENT event type.  The
+  event filter is only called when the window manager desires to close the
+  application window.  If the event filter returns 1, then the window will
+  be closed, otherwise the window will remain open if possible.
+  If the quit event is generated by an interrupt signal, it will bypass the
+  internal queue and be delivered to the application at the next event poll.
+*/
+extern DECLSPEC void SDLCALL SDL_SetEventFilter(SDL_EventFilter filter);
+
+/*
+  Return the current event filter - can be used to "chain" filters.
+  If there is no event filter set, this function returns NULL.
+*/
+extern DECLSPEC SDL_EventFilter SDLCALL SDL_GetEventFilter(void);
+
+/*
+  This function allows you to set the state of processing certain events.
+  If 'state' is set to SDL_IGNORE, that event will be automatically dropped
+  from the event queue and will not event be filtered.
+  If 'state' is set to SDL_ENABLE, that event will be processed normally.
+  If 'state' is set to SDL_QUERY, SDL_EventState() will return the 
+  current processing state of the specified event.
+*/
+#define SDL_QUERY	-1
+#define SDL_IGNORE	 0
+#define SDL_DISABLE	 0
+#define SDL_ENABLE	 1
+extern DECLSPEC Uint8 SDLCALL SDL_EventState(Uint8 type, int state);
+
+
+/* Ends C function definitions when using C++ */
+#ifdef __cplusplus
+}
+#endif
+#include "close_code.h"
+
+#endif /* _SDL_events_h */

src/dep/include/SDL/SDL_getenv.h

@@ -0,0 +1,24 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2006 Sam Lantinga
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+    Sam Lantinga
+    slouken@libsdl.org
+*/
+
+/* DEPRECATED */
+#include "SDL_stdinc.h"

src/dep/include/SDL/SDL_joystick.h

@@ -0,0 +1,167 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2006 Sam Lantinga
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+    Sam Lantinga
+    slouken@libsdl.org
+*/
+
+/* Include file for SDL joystick event handling */
+
+#ifndef _SDL_joystick_h
+#define _SDL_joystick_h
+
+#include "SDL_stdinc.h"
+#include "SDL_error.h"
+
+#include "begin_code.h"
+/* Set up for C function definitions, even when using C++ */
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* In order to use these functions, SDL_Init() must have been called
+   with the SDL_INIT_JOYSTICK flag.  This causes SDL to scan the system
+   for joysticks, and load appropriate drivers.
+*/
+
+/* The joystick structure used to identify an SDL joystick */
+struct _SDL_Joystick;
+typedef struct _SDL_Joystick SDL_Joystick;
+
+
+/* Function prototypes */
+/*
+ * Count the number of joysticks attached to the system
+ */
+extern DECLSPEC int SDLCALL SDL_NumJoysticks(void);
+
+/*
+ * Get the implementation dependent name of a joystick.
+ * This can be called before any joysticks are opened.
+ * If no name can be found, this function returns NULL.
+ */
+extern DECLSPEC const char * SDLCALL SDL_JoystickName(int device_index);
+
+/*
+ * Open a joystick for use - the index passed as an argument refers to
+ * the N'th joystick on the system.  This index is the value which will
+ * identify this joystick in future joystick events.
+ *
+ * This function returns a joystick identifier, or NULL if an error occurred.
+ */
+extern DECLSPEC SDL_Joystick * SDLCALL SDL_JoystickOpen(int device_index);
+
+/*
+ * Returns 1 if the joystick has been opened, or 0 if it has not.
+ */
+extern DECLSPEC int SDLCALL SDL_JoystickOpened(int device_index);
+
+/*
+ * Get the device index of an opened joystick.
+ */
+extern DECLSPEC int SDLCALL SDL_JoystickIndex(SDL_Joystick *joystick);
+
+/*
+ * Get the number of general axis controls on a joystick
+ */
+extern DECLSPEC int SDLCALL SDL_JoystickNumAxes(SDL_Joystick *joystick);
+
+/*
+ * Get the number of trackballs on a joystick
+ * Joystick trackballs have only relative motion events associated
+ * with them and their state cannot be polled.
+ */
+extern DECLSPEC int SDLCALL SDL_JoystickNumBalls(SDL_Joystick *joystick);
+
+/*
+ * Get the number of POV hats on a joystick
+ */
+extern DECLSPEC int SDLCALL SDL_JoystickNumHats(SDL_Joystick *joystick);
+
+/*
+ * Get the number of buttons on a joystick
+ */
+extern DECLSPEC int SDLCALL SDL_JoystickNumButtons(SDL_Joystick *joystick);
+
+/*
+ * Update the current state of the open joysticks.
+ * This is called automatically by the event loop if any joystick
+ * events are enabled.
+ */
+extern DECLSPEC void SDLCALL SDL_JoystickUpdate(void);
+
+/*
+ * Enable/disable joystick event polling.
+ * If joystick events are disabled, you must call SDL_JoystickUpdate()
+ * yourself and check the state of the joystick when you want joystick
+ * information.
+ * The state can be one of SDL_QUERY, SDL_ENABLE or SDL_IGNORE.
+ */
+extern DECLSPEC int SDLCALL SDL_JoystickEventState(int state);
+
+/*
+ * Get the current state of an axis control on a joystick
+ * The state is a value ranging from -32768 to 32767.
+ * The axis indices start at index 0.
+ */
+extern DECLSPEC Sint16 SDLCALL SDL_JoystickGetAxis(SDL_Joystick *joystick, int axis);
+
+/*
+ * Get the current state of a POV hat on a joystick
+ * The return value is one of the following positions:
+ */
+#define SDL_HAT_CENTERED	0x00
+#define SDL_HAT_UP		0x01
+#define SDL_HAT_RIGHT		0x02
+#define SDL_HAT_DOWN		0x04
+#define SDL_HAT_LEFT		0x08
+#define SDL_HAT_RIGHTUP		(SDL_HAT_RIGHT|SDL_HAT_UP)
+#define SDL_HAT_RIGHTDOWN	(SDL_HAT_RIGHT|SDL_HAT_DOWN)
+#define SDL_HAT_LEFTUP		(SDL_HAT_LEFT|SDL_HAT_UP)
+#define SDL_HAT_LEFTDOWN	(SDL_HAT_LEFT|SDL_HAT_DOWN)
+/*
+ * The hat indices start at index 0.
+ */
+extern DECLSPEC Uint8 SDLCALL SDL_JoystickGetHat(SDL_Joystick *joystick, int hat);
+
+/*
+ * Get the ball axis change since the last poll
+ * This returns 0, or -1 if you passed it invalid parameters.
+ * The ball indices start at index 0.
+ */
+extern DECLSPEC int SDLCALL SDL_JoystickGetBall(SDL_Joystick *joystick, int ball, int *dx, int *dy);
+
+/*
+ * Get the current state of a button on a joystick
+ * The button indices start at index 0.
+ */
+extern DECLSPEC Uint8 SDLCALL SDL_JoystickGetButton(SDL_Joystick *joystick, int button);
+
+/*
+ * Close a joystick previously opened with SDL_JoystickOpen()
+ */
+extern DECLSPEC void SDLCALL SDL_JoystickClose(SDL_Joystick *joystick);
+
+
+/* Ends C function definitions when using C++ */
+#ifdef __cplusplus
+}
+#endif
+#include "close_code.h"
+
+#endif /* _SDL_joystick_h */

src/dep/include/SDL/SDL_keyboard.h

@@ -0,0 +1,121 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2006 Sam Lantinga
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+    Sam Lantinga
+    slouken@libsdl.org
+*/
+
+/* Include file for SDL keyboard event handling */
+
+#ifndef _SDL_keyboard_h
+#define _SDL_keyboard_h
+
+#include "SDL_stdinc.h"
+#include "SDL_error.h"
+#include "SDL_keysym.h"
+
+#include "begin_code.h"
+/* Set up for C function definitions, even when using C++ */
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Keysym structure
+   - The scancode is hardware dependent, and should not be used by general
+     applications.  If no hardware scancode is available, it will be 0.
+
+   - The 'unicode' translated character is only available when character
+     translation is enabled by the SDL_EnableUNICODE() API.  If non-zero,
+     this is a UNICODE character corresponding to the keypress.  If the
+     high 9 bits of the character are 0, then this maps to the equivalent
+     ASCII character:
+	char ch;
+	if ( (keysym.unicode & 0xFF80) == 0 ) {
+		ch = keysym.unicode & 0x7F;
+	} else {
+		An international character..
+	}
+ */
+typedef struct SDL_keysym {
+	Uint8 scancode;			/* hardware specific scancode */
+	SDLKey sym;			/* SDL virtual keysym */
+	SDLMod mod;			/* current key modifiers */
+	Uint16 unicode;			/* translated character */
+} SDL_keysym;
+
+/* This is the mask which refers to all hotkey bindings */
+#define SDL_ALL_HOTKEYS		0xFFFFFFFF
+
+/* Function prototypes */
+/*
+ * Enable/Disable UNICODE translation of keyboard input.
+ * This translation has some overhead, so translation defaults off.
+ * If 'enable' is 1, translation is enabled.
+ * If 'enable' is 0, translation is disabled.
+ * If 'enable' is -1, the translation state is not changed.
+ * It returns the previous state of keyboard translation.
+ */
+extern DECLSPEC int SDLCALL SDL_EnableUNICODE(int enable);
+
+/*
+ * Enable/Disable keyboard repeat.  Keyboard repeat defaults to off.
+ * 'delay' is the initial delay in ms between the time when a key is
+ * pressed, and keyboard repeat begins.
+ * 'interval' is the time in ms between keyboard repeat events.
+ */
+#define SDL_DEFAULT_REPEAT_DELAY	500
+#define SDL_DEFAULT_REPEAT_INTERVAL	30
+/*
+ * If 'delay' is set to 0, keyboard repeat is disabled.
+ */
+extern DECLSPEC int SDLCALL SDL_EnableKeyRepeat(int delay, int interval);
+extern DECLSPEC void SDLCALL SDL_GetKeyRepeat(int *delay, int *interval);
+
+/*
+ * Get a snapshot of the current state of the keyboard.
+ * Returns an array of keystates, indexed by the SDLK_* syms.
+ * Used:
+ * 	Uint8 *keystate = SDL_GetKeyState(NULL);
+ *	if ( keystate[SDLK_RETURN] ) ... <RETURN> is pressed.
+ */
+extern DECLSPEC Uint8 * SDLCALL SDL_GetKeyState(int *numkeys);
+
+/*
+ * Get the current key modifier state
+ */
+extern DECLSPEC SDLMod SDLCALL SDL_GetModState(void);
+
+/*
+ * Set the current key modifier state
+ * This does not change the keyboard state, only the key modifier flags.
+ */
+extern DECLSPEC void SDLCALL SDL_SetModState(SDLMod modstate);
+
+/*
+ * Get the name of an SDL virtual keysym
+ */
+extern DECLSPEC char * SDLCALL SDL_GetKeyName(SDLKey key);
+
+
+/* Ends C function definitions when using C++ */
+#ifdef __cplusplus
+}
+#endif
+#include "close_code.h"
+
+#endif /* _SDL_keyboard_h */

src/dep/include/SDL/SDL_keysym.h

@@ -0,0 +1,311 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2006 Sam Lantinga
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+    Sam Lantinga
+    slouken@libsdl.org
+*/
+
+#ifndef _SDL_keysym_h
+#define _SDL_keysym_h
+
+/* What we really want is a mapping of every raw key on the keyboard.
+   To support international keyboards, we use the range 0xA1 - 0xFF
+   as international virtual keycodes.  We'll follow in the footsteps of X11...
+   The names of the keys
+ */
+ 
+typedef enum {
+	/* The keyboard syms have been cleverly chosen to map to ASCII */
+	SDLK_UNKNOWN		= 0,
+	SDLK_FIRST		= 0,
+	SDLK_BACKSPACE		= 8,
+	SDLK_TAB		= 9,
+	SDLK_CLEAR		= 12,
+	SDLK_RETURN		= 13,
+	SDLK_PAUSE		= 19,
+	SDLK_ESCAPE		= 27,
+	SDLK_SPACE		= 32,
+	SDLK_EXCLAIM		= 33,
+	SDLK_QUOTEDBL		= 34,
+	SDLK_HASH		= 35,
+	SDLK_DOLLAR		= 36,
+	SDLK_AMPERSAND		= 38,
+	SDLK_QUOTE		= 39,
+	SDLK_LEFTPAREN		= 40,
+	SDLK_RIGHTPAREN		= 41,
+	SDLK_ASTERISK		= 42,
+	SDLK_PLUS		= 43,
+	SDLK_COMMA		= 44,
+	SDLK_MINUS		= 45,
+	SDLK_PERIOD		= 46,
+	SDLK_SLASH		= 47,
+	SDLK_0			= 48,
+	SDLK_1			= 49,
+	SDLK_2			= 50,
+	SDLK_3			= 51,
+	SDLK_4			= 52,
+	SDLK_5			= 53,
+	SDLK_6			= 54,
+	SDLK_7			= 55,
+	SDLK_8			= 56,
+	SDLK_9			= 57,
+	SDLK_COLON		= 58,
+	SDLK_SEMICOLON		= 59,
+	SDLK_LESS		= 60,
+	SDLK_EQUALS		= 61,
+	SDLK_GREATER		= 62,
+	SDLK_QUESTION		= 63,
+	SDLK_AT			= 64,
+	/* 
+	   Skip uppercase letters
+	 */
+	SDLK_LEFTBRACKET	= 91,
+	SDLK_BACKSLASH		= 92,
+	SDLK_RIGHTBRACKET	= 93,
+	SDLK_CARET		= 94,
+	SDLK_UNDERSCORE		= 95,
+	SDLK_BACKQUOTE		= 96,
+	SDLK_a			= 97,
+	SDLK_b			= 98,
+	SDLK_c			= 99,
+	SDLK_d			= 100,
+	SDLK_e			= 101,
+	SDLK_f			= 102,
+	SDLK_g			= 103,
+	SDLK_h			= 104,
+	SDLK_i			= 105,
+	SDLK_j			= 106,
+	SDLK_k			= 107,
+	SDLK_l			= 108,
+	SDLK_m			= 109,
+	SDLK_n			= 110,
+	SDLK_o			= 111,
+	SDLK_p			= 112,
+	SDLK_q			= 113,
+	SDLK_r			= 114,
+	SDLK_s			= 115,
+	SDLK_t			= 116,
+	SDLK_u			= 117,
+	SDLK_v			= 118,
+	SDLK_w			= 119,
+	SDLK_x			= 120,
+	SDLK_y			= 121,
+	SDLK_z			= 122,
+	SDLK_DELETE		= 127,
+	/* End of ASCII mapped keysyms */
+
+	/* International keyboard syms */
+	SDLK_WORLD_0		= 160,		/* 0xA0 */
+	SDLK_WORLD_1		= 161,
+	SDLK_WORLD_2		= 162,
+	SDLK_WORLD_3		= 163,
+	SDLK_WORLD_4		= 164,
+	SDLK_WORLD_5		= 165,
+	SDLK_WORLD_6		= 166,
+	SDLK_WORLD_7		= 167,
+	SDLK_WORLD_8		= 168,
+	SDLK_WORLD_9		= 169,
+	SDLK_WORLD_10		= 170,
+	SDLK_WORLD_11		= 171,
+	SDLK_WORLD_12		= 172,
+	SDLK_WORLD_13		= 173,
+	SDLK_WORLD_14		= 174,
+	SDLK_WORLD_15		= 175,
+	SDLK_WORLD_16		= 176,
+	SDLK_WORLD_17		= 177,
+	SDLK_WORLD_18		= 178,
+	SDLK_WORLD_19		= 179,
+	SDLK_WORLD_20		= 180,
+	SDLK_WORLD_21		= 181,
+	SDLK_WORLD_22		= 182,
+	SDLK_WORLD_23		= 183,
+	SDLK_WORLD_24		= 184,
+	SDLK_WORLD_25		= 185,
+	SDLK_WORLD_26		= 186,
+	SDLK_WORLD_27		= 187,
+	SDLK_WORLD_28		= 188,
+	SDLK_WORLD_29		= 189,
+	SDLK_WORLD_30		= 190,
+	SDLK_WORLD_31		= 191,
+	SDLK_WORLD_32		= 192,
+	SDLK_WORLD_33		= 193,
+	SDLK_WORLD_34		= 194,
+	SDLK_WORLD_35		= 195,
+	SDLK_WORLD_36		= 196,
+	SDLK_WORLD_37		= 197,
+	SDLK_WORLD_38		= 198,
+	SDLK_WORLD_39		= 199,
+	SDLK_WORLD_40		= 200,
+	SDLK_WORLD_41		= 201,
+	SDLK_WORLD_42		= 202,
+	SDLK_WORLD_43		= 203,
+	SDLK_WORLD_44		= 204,
+	SDLK_WORLD_45		= 205,
+	SDLK_WORLD_46		= 206,
+	SDLK_WORLD_47		= 207,
+	SDLK_WORLD_48		= 208,
+	SDLK_WORLD_49		= 209,
+	SDLK_WORLD_50		= 210,
+	SDLK_WORLD_51		= 211,
+	SDLK_WORLD_52		= 212,
+	SDLK_WORLD_53		= 213,
+	SDLK_WORLD_54		= 214,
+	SDLK_WORLD_55		= 215,
+	SDLK_WORLD_56		= 216,
+	SDLK_WORLD_57		= 217,
+	SDLK_WORLD_58		= 218,
+	SDLK_WORLD_59		= 219,
+	SDLK_WORLD_60		= 220,
+	SDLK_WORLD_61		= 221,
+	SDLK_WORLD_62		= 222,
+	SDLK_WORLD_63		= 223,
+	SDLK_WORLD_64		= 224,
+	SDLK_WORLD_65		= 225,
+	SDLK_WORLD_66		= 226,
+	SDLK_WORLD_67		= 227,
+	SDLK_WORLD_68		= 228,
+	SDLK_WORLD_69		= 229,
+	SDLK_WORLD_70		= 230,
+	SDLK_WORLD_71		= 231,
+	SDLK_WORLD_72		= 232,
+	SDLK_WORLD_73		= 233,
+	SDLK_WORLD_74		= 234,
+	SDLK_WORLD_75		= 235,
+	SDLK_WORLD_76		= 236,
+	SDLK_WORLD_77		= 237,
+	SDLK_WORLD_78		= 238,
+	SDLK_WORLD_79		= 239,
+	SDLK_WORLD_80		= 240,
+	SDLK_WORLD_81		= 241,
+	SDLK_WORLD_82		= 242,
+	SDLK_WORLD_83		= 243,
+	SDLK_WORLD_84		= 244,
+	SDLK_WORLD_85		= 245,
+	SDLK_WORLD_86		= 246,
+	SDLK_WORLD_87		= 247,
+	SDLK_WORLD_88		= 248,
+	SDLK_WORLD_89		= 249,
+	SDLK_WORLD_90		= 250,
+	SDLK_WORLD_91		= 251,
+	SDLK_WORLD_92		= 252,
+	SDLK_WORLD_93		= 253,
+	SDLK_WORLD_94		= 254,
+	SDLK_WORLD_95		= 255,		/* 0xFF */
+
+	/* Numeric keypad */
+	SDLK_KP0		= 256,
+	SDLK_KP1		= 257,
+	SDLK_KP2		= 258,
+	SDLK_KP3		= 259,
+	SDLK_KP4		= 260,
+	SDLK_KP5		= 261,
+	SDLK_KP6		= 262,
+	SDLK_KP7		= 263,
+	SDLK_KP8		= 264,
+	SDLK_KP9		= 265,
+	SDLK_KP_PERIOD		= 266,
+	SDLK_KP_DIVIDE		= 267,
+	SDLK_KP_MULTIPLY	= 268,
+	SDLK_KP_MINUS		= 269,
+	SDLK_KP_PLUS		= 270,
+	SDLK_KP_ENTER		= 271,
+	SDLK_KP_EQUALS		= 272,
+
+	/* Arrows + Home/End pad */
+	SDLK_UP			= 273,
+	SDLK_DOWN		= 274,
+	SDLK_RIGHT		= 275,
+	SDLK_LEFT		= 276,
+	SDLK_INSERT		= 277,
+	SDLK_HOME		= 278,
+	SDLK_END		= 279,
+	SDLK_PAGEUP		= 280,
+	SDLK_PAGEDOWN		= 281,
+
+	/* Function keys */
+	SDLK_F1			= 282,
+	SDLK_F2			= 283,
+	SDLK_F3			= 284,
+	SDLK_F4			= 285,
+	SDLK_F5			= 286,
+	SDLK_F6			= 287,
+	SDLK_F7			= 288,
+	SDLK_F8			= 289,
+	SDLK_F9			= 290,
+	SDLK_F10		= 291,
+	SDLK_F11		= 292,
+	SDLK_F12		= 293,
+	SDLK_F13		= 294,
+	SDLK_F14		= 295,
+	SDLK_F15		= 296,
+
+	/* Key state modifier keys */
+	SDLK_NUMLOCK		= 300,
+	SDLK_CAPSLOCK		= 301,
+	SDLK_SCROLLOCK		= 302,
+	SDLK_RSHIFT		= 303,
+	SDLK_LSHIFT		= 304,
+	SDLK_RCTRL		= 305,
+	SDLK_LCTRL		= 306,
+	SDLK_RALT		= 307,
+	SDLK_LALT		= 308,
+	SDLK_RMETA		= 309,
+	SDLK_LMETA		= 310,
+	SDLK_LSUPER		= 311,		/* Left "Windows" key */
+	SDLK_RSUPER		= 312,		/* Right "Windows" key */
+	SDLK_MODE		= 313,		/* "Alt Gr" key */
+	SDLK_COMPOSE		= 314,		/* Multi-key compose key */
+
+	/* Miscellaneous function keys */
+	SDLK_HELP		= 315,
+	SDLK_PRINT		= 316,
+	SDLK_SYSREQ		= 317,
+	SDLK_BREAK		= 318,
+	SDLK_MENU		= 319,
+	SDLK_POWER		= 320,		/* Power Macintosh power key */
+	SDLK_EURO		= 321,		/* Some european keyboards */
+	SDLK_UNDO		= 322,		/* Atari keyboard has Undo */
+
+	/* Add any other keys here */
+
+	SDLK_LAST
+} SDLKey;
+
+/* Enumeration of valid key mods (possibly OR'd together) */
+typedef enum {
+	KMOD_NONE  = 0x0000,
+	KMOD_LSHIFT= 0x0001,
+	KMOD_RSHIFT= 0x0002,
+	KMOD_LCTRL = 0x0040,
+	KMOD_RCTRL = 0x0080,
+	KMOD_LALT  = 0x0100,
+	KMOD_RALT  = 0x0200,
+	KMOD_LMETA = 0x0400,
+	KMOD_RMETA = 0x0800,
+	KMOD_NUM   = 0x1000,
+	KMOD_CAPS  = 0x2000,
+	KMOD_MODE  = 0x4000,
+	KMOD_RESERVED = 0x8000
+} SDLMod;
+
+#define KMOD_CTRL	(KMOD_LCTRL|KMOD_RCTRL)
+#define KMOD_SHIFT	(KMOD_LSHIFT|KMOD_RSHIFT)
+#define KMOD_ALT	(KMOD_LALT|KMOD_RALT)
+#define KMOD_META	(KMOD_LMETA|KMOD_RMETA)
+
+#endif /* _SDL_keysym_h */

src/dep/include/SDL/SDL_loadso.h

@@ -0,0 +1,74 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2006 Sam Lantinga
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+    Sam Lantinga
+    slouken@libsdl.org
+*/
+
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+/* System dependent library loading routines                           */
+
+/* Some things to keep in mind:                                        
+   - These functions only work on C function names.  Other languages may
+     have name mangling and intrinsic language support that varies from
+     compiler to compiler.
+   - Make sure you declare your function pointers with the same calling
+     convention as the actual library function.  Your code will crash
+     mysteriously if you do not do this.
+   - Avoid namespace collisions.  If you load a symbol from the library,
+     it is not defined whether or not it goes into the global symbol
+     namespace for the application.  If it does and it conflicts with
+     symbols in your code or other shared libraries, you will not get
+     the results you expect. :)
+*/
+
+
+#ifndef _SDL_loadso_h
+#define _SDL_loadso_h
+
+#include "SDL_stdinc.h"
+#include "SDL_error.h"
+
+#include "begin_code.h"
+/* Set up for C function definitions, even when using C++ */
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* This function dynamically loads a shared object and returns a pointer
+ * to the object handle (or NULL if there was an error).
+ * The 'sofile' parameter is a system dependent name of the object file.
+ */
+extern DECLSPEC void * SDLCALL SDL_LoadObject(const char *sofile);
+
+/* Given an object handle, this function looks up the address of the
+ * named function in the shared object and returns it.  This address
+ * is no longer valid after calling SDL_UnloadObject().
+ */
+extern DECLSPEC void * SDLCALL SDL_LoadFunction(void *handle, const char *name);
+
+/* Unload a shared object from memory */
+extern DECLSPEC void SDLCALL SDL_UnloadObject(void *handle);
+
+/* Ends C function definitions when using C++ */
+#ifdef __cplusplus
+}
+#endif
+#include "close_code.h"
+
+#endif /* _SDL_loadso_h */

src/dep/include/SDL/SDL_main.h

@@ -0,0 +1,98 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2006 Sam Lantinga
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+    Sam Lantinga
+    slouken@libsdl.org
+*/
+
+#ifndef _SDL_main_h
+#define _SDL_main_h
+
+#include "SDL_stdinc.h"
+
+/* Redefine main() on Win32 and MacOS so that it is called by winmain.c */
+
+#if defined(__WIN32__) || \
+    (defined(__MWERKS__) && !defined(__BEOS__)) || \
+    defined(__MACOS__) || defined(__MACOSX__) || \
+    defined(__SYMBIAN32__) || defined(QWS)
+
+#ifdef __cplusplus
+#define C_LINKAGE	"C"
+#else
+#define C_LINKAGE
+#endif /* __cplusplus */
+
+/* The application's main() function must be called with C linkage,
+   and should be declared like this:
+#ifdef __cplusplus
+extern "C"
+#endif
+	int main(int argc, char *argv[])
+	{
+	}
+ */
+#define main	SDL_main
+
+/* The prototype for the application's main() function */
+extern C_LINKAGE int SDL_main(int argc, char *argv[]);
+
+
+/* From the SDL library code -- needed for registering the app on Win32 */
+#ifdef __WIN32__
+
+#include "begin_code.h"
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* This should be called from your WinMain() function, if any */
+extern DECLSPEC void SDLCALL SDL_SetModuleHandle(void *hInst);
+/* This can also be called, but is no longer necessary */
+extern DECLSPEC int SDLCALL SDL_RegisterApp(char *name, Uint32 style, void *hInst);
+/* This can also be called, but is no longer necessary (SDL_Quit calls it) */
+extern DECLSPEC void SDLCALL SDL_UnregisterApp(void);
+#ifdef __cplusplus
+}
+#endif
+#include "close_code.h"
+#endif
+
+/* From the SDL library code -- needed for registering QuickDraw on MacOS */
+#if defined(__MACOS__)
+
+#include "begin_code.h"
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Forward declaration so we don't need to include QuickDraw.h */
+struct QDGlobals;
+
+/* This should be called from your main() function, if any */
+extern DECLSPEC void SDLCALL SDL_InitQuickDraw(struct QDGlobals *the_qd);
+
+#ifdef __cplusplus
+}
+#endif
+#include "close_code.h"
+#endif
+
+#endif /* Need to redefine main()? */
+
+#endif /* _SDL_main_h */

src/dep/include/SDL/SDL_mouse.h

@@ -0,0 +1,136 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2006 Sam Lantinga
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+    Sam Lantinga
+    slouken@libsdl.org
+*/
+
+/* Include file for SDL mouse event handling */
+
+#ifndef _SDL_mouse_h
+#define _SDL_mouse_h
+
+#include "SDL_stdinc.h"
+#include "SDL_error.h"
+#include "SDL_video.h"
+
+#include "begin_code.h"
+/* Set up for C function definitions, even when using C++ */
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct WMcursor WMcursor;	/* Implementation dependent */
+typedef struct SDL_Cursor {
+	SDL_Rect area;			/* The area of the mouse cursor */
+	Sint16 hot_x, hot_y;		/* The "tip" of the cursor */
+	Uint8 *data;			/* B/W cursor data */
+	Uint8 *mask;			/* B/W cursor mask */
+	Uint8 *save[2];			/* Place to save cursor area */
+	WMcursor *wm_cursor;		/* Window-manager cursor */
+} SDL_Cursor;
+
+/* Function prototypes */
+/*
+ * Retrieve the current state of the mouse.
+ * The current button state is returned as a button bitmask, which can
+ * be tested using the SDL_BUTTON(X) macros, and x and y are set to the
+ * current mouse cursor position.  You can pass NULL for either x or y.
+ */
+extern DECLSPEC Uint8 SDLCALL SDL_GetMouseState(int *x, int *y);
+
+/*
+ * Retrieve the current state of the mouse.
+ * The current button state is returned as a button bitmask, which can
+ * be tested using the SDL_BUTTON(X) macros, and x and y are set to the
+ * mouse deltas since the last call to SDL_GetRelativeMouseState().
+ */
+extern DECLSPEC Uint8 SDLCALL SDL_GetRelativeMouseState(int *x, int *y);
+
+/*
+ * Set the position of the mouse cursor (generates a mouse motion event)
+ */
+extern DECLSPEC void SDLCALL SDL_WarpMouse(Uint16 x, Uint16 y);
+
+/*
+ * Create a cursor using the specified data and mask (in MSB format).
+ * The cursor width must be a multiple of 8 bits.
+ *
+ * The cursor is created in black and white according to the following:
+ * data  mask    resulting pixel on screen
+ *  0     1       White
+ *  1     1       Black
+ *  0     0       Transparent
+ *  1     0       Inverted color if possible, black if not.
+ *
+ * Cursors created with this function must be freed with SDL_FreeCursor().
+ */
+extern DECLSPEC SDL_Cursor * SDLCALL SDL_CreateCursor
+		(Uint8 *data, Uint8 *mask, int w, int h, int hot_x, int hot_y);
+
+/*
+ * Set the currently active cursor to the specified one.
+ * If the cursor is currently visible, the change will be immediately 
+ * represented on the display.
+ */
+extern DECLSPEC void SDLCALL SDL_SetCursor(SDL_Cursor *cursor);
+
+/*
+ * Returns the currently active cursor.
+ */
+extern DECLSPEC SDL_Cursor * SDLCALL SDL_GetCursor(void);
+
+/*
+ * Deallocates a cursor created with SDL_CreateCursor().
+ */
+extern DECLSPEC void SDLCALL SDL_FreeCursor(SDL_Cursor *cursor);
+
+/*
+ * Toggle whether or not the cursor is shown on the screen.
+ * The cursor start off displayed, but can be turned off.
+ * SDL_ShowCursor() returns 1 if the cursor was being displayed
+ * before the call, or 0 if it was not.  You can query the current
+ * state by passing a 'toggle' value of -1.
+ */
+extern DECLSPEC int SDLCALL SDL_ShowCursor(int toggle);
+
+/* Used as a mask when testing buttons in buttonstate
+   Button 1:	Left mouse button
+   Button 2:	Middle mouse button
+   Button 3:	Right mouse button
+   Button 4:	Mouse wheel up	 (may also be a real button)
+   Button 5:	Mouse wheel down (may also be a real button)
+ */
+#define SDL_BUTTON(X)		(1 << ((X)-1))
+#define SDL_BUTTON_LEFT		1
+#define SDL_BUTTON_MIDDLE	2
+#define SDL_BUTTON_RIGHT	3
+#define SDL_BUTTON_WHEELUP	4
+#define SDL_BUTTON_WHEELDOWN	5
+#define SDL_BUTTON_LMASK	SDL_BUTTON(SDL_BUTTON_LEFT)
+#define SDL_BUTTON_MMASK	SDL_BUTTON(SDL_BUTTON_MIDDLE)
+#define SDL_BUTTON_RMASK	SDL_BUTTON(SDL_BUTTON_RIGHT)
+
+
+/* Ends C function definitions when using C++ */
+#ifdef __cplusplus
+}
+#endif
+#include "close_code.h"
+
+#endif /* _SDL_mouse_h */

src/dep/include/SDL/SDL_mutex.h

@@ -0,0 +1,162 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2006 Sam Lantinga
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+    Sam Lantinga
+    slouken@libsdl.org
+*/
+
+#ifndef _SDL_mutex_h
+#define _SDL_mutex_h
+
+/* Functions to provide thread synchronization primitives
+
+	These are independent of the other SDL routines.
+*/
+
+#include "SDL_stdinc.h"
+#include "SDL_error.h"
+
+#include "begin_code.h"
+/* Set up for C function definitions, even when using C++ */
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Synchronization functions which can time out return this value
+   if they time out.
+*/
+#define SDL_MUTEX_TIMEDOUT	1
+
+/* This is the timeout value which corresponds to never time out */
+#define SDL_MUTEX_MAXWAIT	(~(Uint32)0)
+
+
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+/* Mutex functions                                               */
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+
+/* The SDL mutex structure, defined in SDL_mutex.c */
+struct SDL_mutex;
+typedef struct SDL_mutex SDL_mutex;
+
+/* Create a mutex, initialized unlocked */
+extern DECLSPEC SDL_mutex * SDLCALL SDL_CreateMutex(void);
+
+/* Lock the mutex  (Returns 0, or -1 on error) */
+#define SDL_LockMutex(m)	SDL_mutexP(m)
+extern DECLSPEC int SDLCALL SDL_mutexP(SDL_mutex *mutex);
+
+/* Unlock the mutex  (Returns 0, or -1 on error)
+   It is an error to unlock a mutex that has not been locked by
+   the current thread, and doing so results in undefined behavior.
+ */
+#define SDL_UnlockMutex(m)	SDL_mutexV(m)
+extern DECLSPEC int SDLCALL SDL_mutexV(SDL_mutex *mutex);
+
+/* Destroy a mutex */
+extern DECLSPEC void SDLCALL SDL_DestroyMutex(SDL_mutex *mutex);
+
+
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+/* Semaphore functions                                           */
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+
+/* The SDL semaphore structure, defined in SDL_sem.c */
+struct SDL_semaphore;
+typedef struct SDL_semaphore SDL_sem;
+
+/* Create a semaphore, initialized with value, returns NULL on failure. */
+extern DECLSPEC SDL_sem * SDLCALL SDL_CreateSemaphore(Uint32 initial_value);
+
+/* Destroy a semaphore */
+extern DECLSPEC void SDLCALL SDL_DestroySemaphore(SDL_sem *sem);
+
+/* This function suspends the calling thread until the semaphore pointed 
+ * to by sem has a positive count. It then atomically decreases the semaphore
+ * count.
+ */
+extern DECLSPEC int SDLCALL SDL_SemWait(SDL_sem *sem);
+
+/* Non-blocking variant of SDL_SemWait(), returns 0 if the wait succeeds,
+   SDL_MUTEX_TIMEDOUT if the wait would block, and -1 on error.
+*/
+extern DECLSPEC int SDLCALL SDL_SemTryWait(SDL_sem *sem);
+
+/* Variant of SDL_SemWait() with a timeout in milliseconds, returns 0 if
+   the wait succeeds, SDL_MUTEX_TIMEDOUT if the wait does not succeed in
+   the allotted time, and -1 on error.
+   On some platforms this function is implemented by looping with a delay
+   of 1 ms, and so should be avoided if possible.
+*/
+extern DECLSPEC int SDLCALL SDL_SemWaitTimeout(SDL_sem *sem, Uint32 ms);
+
+/* Atomically increases the semaphore's count (not blocking), returns 0,
+   or -1 on error.
+ */
+extern DECLSPEC int SDLCALL SDL_SemPost(SDL_sem *sem);
+
+/* Returns the current count of the semaphore */
+extern DECLSPEC Uint32 SDLCALL SDL_SemValue(SDL_sem *sem);
+
+
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+/* Condition variable functions                                  */
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+
+/* The SDL condition variable structure, defined in SDL_cond.c */
+struct SDL_cond;
+typedef struct SDL_cond SDL_cond;
+
+/* Create a condition variable */
+extern DECLSPEC SDL_cond * SDLCALL SDL_CreateCond(void);
+
+/* Destroy a condition variable */
+extern DECLSPEC void SDLCALL SDL_DestroyCond(SDL_cond *cond);
+
+/* Restart one of the threads that are waiting on the condition variable,
+   returns 0 or -1 on error.
+ */
+extern DECLSPEC int SDLCALL SDL_CondSignal(SDL_cond *cond);
+
+/* Restart all threads that are waiting on the condition variable,
+   returns 0 or -1 on error.
+ */
+extern DECLSPEC int SDLCALL SDL_CondBroadcast(SDL_cond *cond);
+
+/* Wait on the condition variable, unlocking the provided mutex.
+   The mutex must be locked before entering this function!
+   The mutex is re-locked once the condition variable is signaled.
+   Returns 0 when it is signaled, or -1 on error.
+ */
+extern DECLSPEC int SDLCALL SDL_CondWait(SDL_cond *cond, SDL_mutex *mut);
+
+/* Waits for at most 'ms' milliseconds, and returns 0 if the condition
+   variable is signaled, SDL_MUTEX_TIMEDOUT if the condition is not
+   signaled in the allotted time, and -1 on error.
+   On some platforms this function is implemented by looping with a delay
+   of 1 ms, and so should be avoided if possible.
+*/
+extern DECLSPEC int SDLCALL SDL_CondWaitTimeout(SDL_cond *cond, SDL_mutex *mutex, Uint32 ms);
+
+/* Ends C function definitions when using C++ */
+#ifdef __cplusplus
+}
+#endif
+#include "close_code.h"
+
+#endif /* _SDL_mutex_h */

src/dep/include/SDL/SDL_name.h

@@ -0,0 +1,11 @@
+
+#ifndef _SDLname_h_
+#define _SDLname_h_
+
+#if defined(__STDC__) || defined(__cplusplus)
+#define NeedFunctionPrototypes 1
+#endif
+
+#define SDL_NAME(X)	SDL_##X
+
+#endif /* _SDLname_h_ */

src/dep/include/SDL/SDL_platform.h

@@ -0,0 +1,104 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2006 Sam Lantinga
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+    Sam Lantinga
+    slouken@libsdl.org
+*/
+
+/* Try to get a standard set of platform defines */
+
+#ifndef _SDL_platform_h
+#define _SDL_platform_h
+
+#if defined(_AIX)
+#undef __AIX__
+#define __AIX__		1
+#endif
+#if defined(AMIGA) || defined(__AMIGA) || defined(__amigados__)
+#undef __AMIGA__
+#define __AMIGA__	1
+#endif
+#if defined(__BEOS__)
+#undef __BEOS__
+#define __BEOS__	1
+#endif
+#if defined(bsdi) || defined(__bsdi) || defined(__bsdi__)
+#undef __BSDI__
+#define __BSDI__	1
+#endif
+#if defined(_arch_dreamcast)
+#undef __DREAMCAST__
+#define __DREAMCAST__	1
+#endif
+#if defined(__FreeBSD__) || defined(__DragonFly__)
+#undef __FREEBSD__
+#define __FREEBSD__	1
+#endif
+#if defined(hpux) || defined(__hpux) || defined(__hpux__)
+#undef __HPUX__
+#define __HPUX__	1
+#endif
+#if defined(sgi) || defined(__sgi) || defined(__sgi__) || defined(_SGI_SOURCE)
+#undef __IRIX__
+#define __IRIX__	1
+#endif
+#if defined(linux) || defined(__linux) || defined(__linux__)
+#undef __LINUX__
+#define __LINUX__	1
+#endif
+#if defined(__APPLE__)
+#undef __MACOSX__
+#define __MACOSX__	1
+#elif defined(macintosh)
+#undef __MACOS__
+#define __MACOS__	1
+#endif
+#if defined(__NetBSD__)
+#undef __NETBSD__
+#define __NETBSD__	1
+#endif
+#if defined(__OpenBSD__)
+#undef __OPENBSD__
+#define __OPENBSD__	1
+#endif
+#if defined(__OS2__)
+#undef __OS2__
+#define __OS2__		1
+#endif
+#if defined(osf) || defined(__osf) || defined(__osf__) || defined(_OSF_SOURCE)
+#undef __OSF__
+#define __OSF__		1
+#endif
+#if defined(__QNXNTO__)
+#undef __QNXNTO__
+#define __QNXNTO__	1
+#endif
+#if defined(riscos) || defined(__riscos) || defined(__riscos__)
+#undef __RISCOS__
+#define __RISCOS__	1
+#endif
+#if defined(__SVR4)
+#undef __SOLARIS__
+#define __SOLARIS__	1
+#endif
+#if defined(WIN32) || defined(_WIN32)
+#undef __WIN32__
+#define __WIN32__	1
+#endif
+
+#endif /* _SDL_platform_h */

src/dep/include/SDL/SDL_quit.h

@@ -0,0 +1,50 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2006 Sam Lantinga
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+    Sam Lantinga
+    slouken@libsdl.org
+*/
+
+/* Include file for SDL quit event handling */
+
+#ifndef _SDL_quit_h
+#define _SDL_quit_h
+
+#include "SDL_stdinc.h"
+#include "SDL_error.h"
+
+/* 
+  An SDL_QUITEVENT is generated when the user tries to close the application
+  window.  If it is ignored or filtered out, the window will remain open.
+  If it is not ignored or filtered, it is queued normally and the window
+  is allowed to close.  When the window is closed, screen updates will 
+  complete, but have no effect.
+
+  SDL_Init() installs signal handlers for SIGINT (keyboard interrupt)
+  and SIGTERM (system termination request), if handlers do not already
+  exist, that generate SDL_QUITEVENT events as well.  There is no way
+  to determine the cause of an SDL_QUITEVENT, but setting a signal
+  handler in your application will override the default generation of
+  quit events for that signal.
+*/
+
+/* There are no functions directly affecting the quit event */
+#define SDL_QuitRequested() \
+        (SDL_PumpEvents(), SDL_PeepEvents(NULL,0,SDL_PEEKEVENT,SDL_QUITMASK))
+
+#endif /* _SDL_quit_h */

src/dep/include/SDL/SDL_rwops.h

@@ -0,0 +1,139 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2006 Sam Lantinga
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+    Sam Lantinga
+    slouken@libsdl.org
+*/
+
+/* This file provides a general interface for SDL to read and write
+   data sources.  It can easily be extended to files, memory, etc.
+*/
+
+#ifndef _SDL_rwops_h
+#define _SDL_rwops_h
+
+#include "SDL_stdinc.h"
+#include "SDL_error.h"
+
+#include "begin_code.h"
+/* Set up for C function definitions, even when using C++ */
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* This is the read/write operation structure -- very basic */
+
+typedef struct SDL_RWops {
+	/* Seek to 'offset' relative to whence, one of stdio's whence values:
+		SEEK_SET, SEEK_CUR, SEEK_END
+	   Returns the final offset in the data source.
+	 */
+	int (SDLCALL *seek)(struct SDL_RWops *context, int offset, int whence);
+
+	/* Read up to 'num' objects each of size 'objsize' from the data
+	   source to the area pointed at by 'ptr'.
+	   Returns the number of objects read, or -1 if the read failed.
+	 */
+	int (SDLCALL *read)(struct SDL_RWops *context, void *ptr, int size, int maxnum);
+
+	/* Write exactly 'num' objects each of size 'objsize' from the area
+	   pointed at by 'ptr' to data source.
+	   Returns 'num', or -1 if the write failed.
+	 */
+	int (SDLCALL *write)(struct SDL_RWops *context, const void *ptr, int size, int num);
+
+	/* Close and free an allocated SDL_FSops structure */
+	int (SDLCALL *close)(struct SDL_RWops *context);
+
+	Uint32 type;
+	union {
+#ifdef __WIN32__
+	    struct {
+		int    append;
+		void*  h;
+	    } win32io;
+#endif
+#ifdef HAVE_STDIO_H 
+	    struct {
+		int autoclose;
+	 	FILE *fp;
+	    } stdio;
+#endif
+	    struct {
+		Uint8 *base;
+	 	Uint8 *here;
+		Uint8 *stop;
+	    } mem;
+	    struct {
+		void *data1;
+	    } unknown;
+	} hidden;
+
+} SDL_RWops;
+
+
+/* Functions to create SDL_RWops structures from various data sources */
+
+extern DECLSPEC SDL_RWops * SDLCALL SDL_RWFromFile(const char *file, const char *mode);
+
+#ifdef HAVE_STDIO_H
+extern DECLSPEC SDL_RWops * SDLCALL SDL_RWFromFP(FILE *fp, int autoclose);
+#endif
+
+extern DECLSPEC SDL_RWops * SDLCALL SDL_RWFromMem(void *mem, int size);
+extern DECLSPEC SDL_RWops * SDLCALL SDL_RWFromConstMem(const void *mem, int size);
+
+extern DECLSPEC SDL_RWops * SDLCALL SDL_AllocRW(void);
+extern DECLSPEC void SDLCALL SDL_FreeRW(SDL_RWops *area);
+
+#define RW_SEEK_SET	0	/* Seek from the beginning of data */
+#define RW_SEEK_CUR	1	/* Seek relative to current read point */
+#define RW_SEEK_END	2	/* Seek relative to the end of data */
+
+/* Macros to easily read and write from an SDL_RWops structure */
+#define SDL_RWseek(ctx, offset, whence)	(ctx)->seek(ctx, offset, whence)
+#define SDL_RWtell(ctx)			(ctx)->seek(ctx, 0, RW_SEEK_CUR)
+#define SDL_RWread(ctx, ptr, size, n)	(ctx)->read(ctx, ptr, size, n)
+#define SDL_RWwrite(ctx, ptr, size, n)	(ctx)->write(ctx, ptr, size, n)
+#define SDL_RWclose(ctx)		(ctx)->close(ctx)
+
+
+/* Read an item of the specified endianness and return in native format */
+extern DECLSPEC Uint16 SDLCALL SDL_ReadLE16(SDL_RWops *src);
+extern DECLSPEC Uint16 SDLCALL SDL_ReadBE16(SDL_RWops *src);
+extern DECLSPEC Uint32 SDLCALL SDL_ReadLE32(SDL_RWops *src);
+extern DECLSPEC Uint32 SDLCALL SDL_ReadBE32(SDL_RWops *src);
+extern DECLSPEC Uint64 SDLCALL SDL_ReadLE64(SDL_RWops *src);
+extern DECLSPEC Uint64 SDLCALL SDL_ReadBE64(SDL_RWops *src);
+
+/* Write an item of native format to the specified endianness */
+extern DECLSPEC int SDLCALL SDL_WriteLE16(SDL_RWops *dst, Uint16 value);
+extern DECLSPEC int SDLCALL SDL_WriteBE16(SDL_RWops *dst, Uint16 value);
+extern DECLSPEC int SDLCALL SDL_WriteLE32(SDL_RWops *dst, Uint32 value);
+extern DECLSPEC int SDLCALL SDL_WriteBE32(SDL_RWops *dst, Uint32 value);
+extern DECLSPEC int SDLCALL SDL_WriteLE64(SDL_RWops *dst, Uint64 value);
+extern DECLSPEC int SDLCALL SDL_WriteBE64(SDL_RWops *dst, Uint64 value);
+
+
+/* Ends C function definitions when using C++ */
+#ifdef __cplusplus
+}
+#endif
+#include "close_code.h"
+
+#endif /* _SDL_rwops_h */

src/dep/include/SDL/SDL_stdinc.h

@@ -0,0 +1,586 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2006 Sam Lantinga
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+    Sam Lantinga
+    slouken@libsdl.org
+*/
+
+/* This is a general header that includes C language support */
+
+#ifndef _SDL_stdinc_h
+#define _SDL_stdinc_h
+
+#include "SDL_config.h"
+
+
+#ifdef HAVE_SYS_TYPES_H
+#include <sys/types.h>
+#endif
+#ifdef HAVE_STDIO_H
+#include <stdio.h>
+#endif
+#if defined(STDC_HEADERS)
+# include <stdlib.h>
+# include <stddef.h>
+# include <stdarg.h>
+#else
+# if defined(HAVE_STDLIB_H)
+#  include <stdlib.h>
+# elif defined(HAVE_MALLOC_H)
+#  include <malloc.h>
+# endif
+# if defined(HAVE_STDDEF_H)
+#  include <stddef.h>
+# endif
+# if defined(HAVE_STDARG_H)
+#  include <stdarg.h>
+# endif
+#endif
+#ifdef HAVE_STRING_H
+# if !defined(STDC_HEADERS) && defined(HAVE_MEMORY_H)
+#  include <memory.h>
+# endif
+# include <string.h>
+#endif
+#ifdef HAVE_STRINGS_H
+# include <strings.h>
+#endif
+#if defined(HAVE_INTTYPES_H)
+# include <inttypes.h>
+#elif defined(HAVE_STDINT_H)
+# include <stdint.h>
+#endif
+#ifdef HAVE_CTYPE_H
+# include <ctype.h>
+#endif
+#ifdef HAVE_ICONV_H
+# include <iconv.h>
+#endif
+
+/* The number of elements in an array */
+#define SDL_arraysize(array)	(sizeof(array)/sizeof(array[0]))
+#define SDL_TABLESIZE(table)	SDL_arraysize(table)
+
+/* Basic data types */
+typedef enum SDL_bool {
+	SDL_FALSE = 0,
+	SDL_TRUE  = 1
+} SDL_bool;
+
+typedef int8_t		Sint8;
+typedef uint8_t		Uint8;
+typedef int16_t		Sint16;
+typedef uint16_t	Uint16;
+typedef int32_t		Sint32;
+typedef uint32_t	Uint32;
+
+#ifdef SDL_HAS_64BIT_TYPE
+typedef int64_t		Sint64;
+typedef uint64_t	Uint64;
+#else
+/* This is really just a hack to prevent the compiler from complaining */
+typedef struct {
+	Uint32 hi;
+	Uint32 lo;
+} Uint64, Sint64;
+#endif
+
+/* Make sure the types really have the right sizes */
+#define SDL_COMPILE_TIME_ASSERT(name, x)               \
+       typedef int SDL_dummy_ ## name[(x) * 2 - 1]
+
+SDL_COMPILE_TIME_ASSERT(uint8, sizeof(Uint8) == 1);
+SDL_COMPILE_TIME_ASSERT(sint8, sizeof(Sint8) == 1);
+SDL_COMPILE_TIME_ASSERT(uint16, sizeof(Uint16) == 2);
+SDL_COMPILE_TIME_ASSERT(sint16, sizeof(Sint16) == 2);
+SDL_COMPILE_TIME_ASSERT(uint32, sizeof(Uint32) == 4);
+SDL_COMPILE_TIME_ASSERT(sint32, sizeof(Sint32) == 4);
+SDL_COMPILE_TIME_ASSERT(uint64, sizeof(Uint64) == 8);
+SDL_COMPILE_TIME_ASSERT(sint64, sizeof(Sint64) == 8);
+
+/* Check to make sure enums are the size of ints, for structure packing.
+   For both Watcom C/C++ and Borland C/C++ the compiler option that makes
+   enums having the size of an int must be enabled.
+   This is "-b" for Borland C/C++ and "-ei" for Watcom C/C++ (v11).
+*/
+/* Enable enums always int in CodeWarrior (for MPW use "-enum int") */
+#ifdef __MWERKS__
+#pragma enumsalwaysint on
+#endif
+
+typedef enum {
+	DUMMY_ENUM_VALUE
+} SDL_DUMMY_ENUM;
+
+SDL_COMPILE_TIME_ASSERT(enum, sizeof(SDL_DUMMY_ENUM) == sizeof(int));
+
+
+#include "begin_code.h"
+/* Set up for C function definitions, even when using C++ */
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifdef HAVE_MALLOC
+#define SDL_malloc	malloc
+#else
+extern DECLSPEC void * SDLCALL SDL_malloc(size_t size);
+#endif
+
+#ifdef HAVE_CALLOC
+#define SDL_calloc	calloc
+#else
+extern DECLSPEC void * SDLCALL SDL_calloc(size_t nmemb, size_t size);
+#endif
+
+#ifdef HAVE_REALLOC
+#define SDL_realloc	realloc
+#else
+extern DECLSPEC void * SDLCALL SDL_realloc(void *mem, size_t size);
+#endif
+
+#ifdef HAVE_FREE
+#define SDL_free	free
+#else
+extern DECLSPEC void SDLCALL SDL_free(void *mem);
+#endif
+
+#if defined(HAVE_ALLOCA) && !defined(alloca)
+# if defined(HAVE_ALLOCA_H)
+#  include <alloca.h>
+# elif defined(__GNUC__)
+#  define alloca __builtin_alloca
+# elif defined(_MSC_VER)
+#  include <malloc.h>
+#  define alloca _alloca
+# elif defined(__WATCOMC__)
+#  include <malloc.h>
+# elif defined(__DMC__)
+#  include <stdlib.h>
+# elif defined(__AIX__)
+  #pragma alloca
+# elif defined(__MRC__)
+   void *alloca (unsigned);
+# else
+   char *alloca ();
+# endif
+#endif
+#ifdef HAVE_ALLOCA
+#define SDL_stack_alloc(type, count)    (type*)alloca(sizeof(type)*count)
+#define SDL_stack_free(data)
+#else
+#define SDL_stack_alloc(type, count)    (type*)SDL_malloc(sizeof(type)*count)
+#define SDL_stack_free(data)            SDL_free(data)
+#endif
+
+#ifdef HAVE_GETENV
+#define SDL_getenv	getenv
+#else
+extern DECLSPEC char * SDLCALL SDL_getenv(const char *name);
+#endif
+
+#ifdef HAVE_PUTENV
+#define SDL_putenv	putenv
+#else
+extern DECLSPEC int SDLCALL SDL_putenv(const char *variable);
+#endif
+
+#ifdef HAVE_QSORT
+#define SDL_qsort	qsort
+#else
+extern DECLSPEC void SDLCALL SDL_qsort(void *base, size_t nmemb, size_t size,
+           int (*compare)(const void *, const void *));
+#endif
+
+#ifdef HAVE_ABS
+#define SDL_abs		abs
+#else
+#define SDL_abs(X)	((X) < 0 ? -(X) : (X))
+#endif
+
+#define SDL_min(x, y)	(((x) < (y)) ? (x) : (y))
+#define SDL_max(x, y)	(((x) > (y)) ? (x) : (y))
+
+#ifdef HAVE_CTYPE_H
+#define SDL_isdigit(X)  isdigit(X)
+#define SDL_isspace(X)  isspace(X)
+#define SDL_toupper(X)  toupper(X)
+#define SDL_tolower(X)  tolower(X)
+#else
+#define SDL_isdigit(X)  (((X) >= '0') && ((X) <= '9'))
+#define SDL_isspace(X)  (((X) == ' ') || ((X) == '\t') || ((X) == '\r') || ((X) == '\n'))
+#define SDL_toupper(X)  (((X) >= 'a') && ((X) <= 'z') ? ('A'+((X)-'a')) : (X))
+#define SDL_tolower(X)  (((X) >= 'A') && ((X) <= 'Z') ? ('a'+((X)-'A')) : (X))
+#endif
+
+#ifdef HAVE_MEMSET
+#define SDL_memset      memset
+#else
+extern DECLSPEC void * SDLCALL SDL_memset(void *dst, int c, size_t len);
+#endif
+
+#if defined(__GNUC__) && defined(i386)
+#define SDL_memset4(dst, val, len)				\
+do {								\
+	int u0, u1, u2;						\
+	__asm__ __volatile__ (					\
+		"cld\n\t"					\
+		"rep ; stosl\n\t"				\
+		: "=&D" (u0), "=&a" (u1), "=&c" (u2)		\
+		: "0" (dst), "1" (val), "2" ((Uint32)(len))	\
+		: "memory" );					\
+} while(0)
+#endif
+#ifndef SDL_memset4
+#define SDL_memset4(dst, val, len)		\
+do {						\
+	unsigned _count = (len);		\
+	unsigned _n = (_count + 3) / 4;		\
+	Uint32 *_p = (Uint32 *)(dst);		\
+	Uint32 _val = (val);			\
+        switch (_count % 4) {			\
+        case 0: do {    *_p++ = _val;		\
+        case 3:         *_p++ = _val;		\
+        case 2:         *_p++ = _val;		\
+        case 1:         *_p++ = _val;		\
+		} while ( --_n );		\
+	}					\
+} while(0)
+#endif
+
+#if defined(__GNUC__) && defined(i386)
+#define SDL_memcpy(dst, src, len)					  \
+do {									  \
+	int u0, u1, u2;						  	  \
+	__asm__ __volatile__ (						  \
+		"cld\n\t"						  \
+		"rep ; movsl\n\t"					  \
+		"testb $2,%b4\n\t"					  \
+		"je 1f\n\t"						  \
+		"movsw\n"						  \
+		"1:\ttestb $1,%b4\n\t"					  \
+		"je 2f\n\t"						  \
+		"movsb\n"						  \
+		"2:"							  \
+		: "=&c" (u0), "=&D" (u1), "=&S" (u2)			  \
+		: "0" ((unsigned)(len)/4), "q" (len), "1" (dst),"2" (src) \
+		: "memory" );						  \
+} while(0)
+#endif
+#ifndef SDL_memcpy
+#ifdef HAVE_MEMCPY
+#define SDL_memcpy      memcpy
+#elif defined(HAVE_BCOPY)
+#define SDL_memcpy(d, s, n)	bcopy((s), (d), (n))
+#else
+extern DECLSPEC void * SDLCALL SDL_memcpy(void *dst, const void *src, size_t len);
+#endif
+#endif
+
+#if defined(__GNUC__) && defined(i386)
+#define SDL_memcpy4(dst, src, len)				\
+do {								\
+	int ecx, edi, esi;					\
+	__asm__ __volatile__ (					\
+		"cld\n\t"					\
+		"rep ; movsl"					\
+		: "=&c" (ecx), "=&D" (edi), "=&S" (esi)		\
+		: "0" ((unsigned)(len)), "1" (dst), "2" (src)	\
+		: "memory" );					\
+} while(0)
+#endif
+#ifndef SDL_memcpy4
+#define SDL_memcpy4(dst, src, len)	SDL_memcpy(dst, src, (len) << 2)
+#endif
+
+#if defined(__GNUC__) && defined(i386)
+#define SDL_revcpy(dst, src, len)			\
+do {							\
+	int u0, u1, u2;					\
+	char *dstp = (char *)(dst);			\
+	char *srcp = (char *)(src);			\
+	int n = (len);					\
+	if ( n >= 4 ) {					\
+	__asm__ __volatile__ (				\
+		"std\n\t"				\
+		"rep ; movsl\n\t"			\
+		: "=&c" (u0), "=&D" (u1), "=&S" (u2)	\
+		: "0" (n >> 2),				\
+		  "1" (dstp+(n-4)), "2" (srcp+(n-4))	\
+		: "memory" );				\
+	}						\
+	switch (n & 3) {				\
+		case 3: dstp[2] = srcp[2];		\
+		case 2: dstp[1] = srcp[1];		\
+		case 1: dstp[0] = srcp[0];		\
+			break;				\
+		default:				\
+			break;				\
+	}						\
+} while(0)
+#endif
+#ifndef SDL_revcpy
+extern DECLSPEC void * SDLCALL SDL_revcpy(void *dst, const void *src, size_t len);
+#endif
+
+#ifdef HAVE_MEMMOVE
+#define SDL_memmove     memmove
+#elif defined(HAVE_BCOPY)
+#define SDL_memmove(d, s, n)	bcopy((s), (d), (n))
+#else
+#define SDL_memmove(dst, src, len)			\
+do {							\
+	if ( dst < src ) {				\
+		SDL_memcpy(dst, src, len);		\
+	} else {					\
+		SDL_revcpy(dst, src, len);		\
+	}						\
+} while(0)
+#endif
+
+#ifdef HAVE_MEMCMP
+#define SDL_memcmp      memcmp
+#else
+extern DECLSPEC int SDLCALL SDL_memcmp(const void *s1, const void *s2, size_t len);
+#endif
+
+#ifdef HAVE_STRLEN
+#define SDL_strlen      strlen
+#else
+extern DECLSPEC size_t SDLCALL SDL_strlen(const char *string);
+#endif
+
+#ifdef HAVE_STRLCPY
+#define SDL_strlcpy     strlcpy
+#else
+extern DECLSPEC size_t SDLCALL SDL_strlcpy(char *dst, const char *src, size_t maxlen);
+#endif
+
+#ifdef HAVE_STRLCAT
+#define SDL_strlcat    strlcat
+#else
+extern DECLSPEC size_t SDLCALL SDL_strlcat(char *dst, const char *src, size_t maxlen);
+#endif
+
+#ifdef HAVE_STRDUP
+#define SDL_strdup     strdup
+#else
+extern DECLSPEC char * SDLCALL SDL_strdup(const char *string);
+#endif
+
+#ifdef HAVE__STRREV
+#define SDL_strrev      _strrev
+#else
+extern DECLSPEC char * SDLCALL SDL_strrev(char *string);
+#endif
+
+#ifdef HAVE__STRUPR
+#define SDL_strupr      _strupr
+#else
+extern DECLSPEC char * SDLCALL SDL_strupr(char *string);
+#endif
+
+#ifdef HAVE__STRLWR
+#define SDL_strlwr      _strlwr
+#else
+extern DECLSPEC char * SDLCALL SDL_strlwr(char *string);
+#endif
+
+#ifdef HAVE_STRCHR
+#define SDL_strchr      strchr
+#elif defined(HAVE_INDEX)
+#define SDL_strchr      index
+#else
+extern DECLSPEC char * SDLCALL SDL_strchr(const char *string, int c);
+#endif
+
+#ifdef HAVE_STRRCHR
+#define SDL_strrchr     strrchr
+#elif defined(HAVE_RINDEX)
+#define SDL_strrchr     rindex
+#else
+extern DECLSPEC char * SDLCALL SDL_strrchr(const char *string, int c);
+#endif
+
+#ifdef HAVE_STRSTR
+#define SDL_strstr      strstr
+#else
+extern DECLSPEC char * SDLCALL SDL_strstr(const char *haystack, const char *needle);
+#endif
+
+#ifdef HAVE_ITOA
+#define SDL_itoa        itoa
+#else
+#define SDL_itoa(value, string, radix)	SDL_ltoa((long)value, string, radix)
+#endif
+
+#ifdef HAVE__LTOA
+#define SDL_ltoa        _ltoa
+#else
+extern DECLSPEC char * SDLCALL SDL_ltoa(long value, char *string, int radix);
+#endif
+
+#ifdef HAVE__UITOA
+#define SDL_uitoa       _uitoa
+#else
+#define SDL_uitoa(value, string, radix)	SDL_ultoa((long)value, string, radix)
+#endif
+
+#ifdef HAVE__ULTOA
+#define SDL_ultoa       _ultoa
+#else
+extern DECLSPEC char * SDLCALL SDL_ultoa(unsigned long value, char *string, int radix);
+#endif
+
+#ifdef HAVE_STRTOL
+#define SDL_strtol      strtol
+#else
+extern DECLSPEC long SDLCALL SDL_strtol(const char *string, char **endp, int base);
+#endif
+
+#ifdef HAVE_STRTOUL
+#define SDL_strtoul      strtoul
+#else
+extern DECLSPEC unsigned long SDLCALL SDL_strtoul(const char *string, char **endp, int base);
+#endif
+
+#ifdef SDL_HAS_64BIT_TYPE
+
+#ifdef HAVE__I64TOA
+#define SDL_lltoa       _i64toa
+#else
+extern DECLSPEC char* SDLCALL SDL_lltoa(Sint64 value, char *string, int radix);
+#endif
+
+#ifdef HAVE__UI64TOA
+#define SDL_ulltoa      _ui64toa
+#else
+extern DECLSPEC char* SDLCALL SDL_ulltoa(Uint64 value, char *string, int radix);
+#endif
+
+#ifdef HAVE_STRTOLL
+#define SDL_strtoll     strtoll
+#else
+extern DECLSPEC Sint64 SDLCALL SDL_strtoll(const char *string, char **endp, int base);
+#endif
+
+#ifdef HAVE_STRTOULL
+#define SDL_strtoull     strtoull
+#else
+extern DECLSPEC Uint64 SDLCALL SDL_strtoull(const char *string, char **endp, int base);
+#endif
+
+#endif /* SDL_HAS_64BIT_TYPE */
+
+#ifdef HAVE_STRTOD
+#define SDL_strtod      strtod
+#else
+extern DECLSPEC double SDLCALL SDL_strtod(const char *string, char **endp);
+#endif
+
+#ifdef HAVE_ATOI
+#define SDL_atoi        atoi
+#else
+#define SDL_atoi(X)     SDL_strtol(X, NULL, 0)
+#endif
+
+#ifdef HAVE_ATOF
+#define SDL_atof        atof
+#else
+#define SDL_atof(X)     SDL_strtod(X, NULL)
+#endif
+
+#ifdef HAVE_STRCMP
+#define SDL_strcmp      strcmp
+#else
+extern DECLSPEC int SDLCALL SDL_strcmp(const char *str1, const char *str2);
+#endif
+
+#ifdef HAVE_STRNCMP
+#define SDL_strncmp     strncmp
+#else
+extern DECLSPEC int SDLCALL SDL_strncmp(const char *str1, const char *str2, size_t maxlen);
+#endif
+
+#ifdef HAVE_STRCASECMP
+#define SDL_strcasecmp  strcasecmp
+#elif defined(HAVE__STRICMP)
+#define SDL_strcasecmp  _stricmp
+#else
+extern DECLSPEC int SDLCALL SDL_strcasecmp(const char *str1, const char *str2);
+#endif
+
+#ifdef HAVE_STRNCASECMP
+#define SDL_strncasecmp strncasecmp
+#elif defined(HAVE__STRNICMP)
+#define SDL_strncasecmp _strnicmp
+#else
+extern DECLSPEC int SDLCALL SDL_strncasecmp(const char *str1, const char *str2, size_t maxlen);
+#endif
+
+#ifdef HAVE_SSCANF
+#define SDL_sscanf      sscanf
+#else
+extern DECLSPEC int SDLCALL SDL_sscanf(const char *text, const char *fmt, ...);
+#endif
+
+#ifdef HAVE_SNPRINTF
+#define SDL_snprintf    snprintf
+#else
+extern DECLSPEC int SDLCALL SDL_snprintf(char *text, size_t maxlen, const char *fmt, ...);
+#endif
+
+#ifdef HAVE_VSNPRINTF
+#define SDL_vsnprintf   vsnprintf
+#else
+extern DECLSPEC int SDLCALL SDL_vsnprintf(char *text, size_t maxlen, const char *fmt, va_list ap);
+#endif
+
+/* The SDL implementation of iconv() returns these error codes */
+#define SDL_ICONV_ERROR		(size_t)-1
+#define SDL_ICONV_E2BIG		(size_t)-2
+#define SDL_ICONV_EILSEQ	(size_t)-3
+#define SDL_ICONV_EINVAL	(size_t)-4
+
+#ifdef HAVE_ICONV
+#define SDL_iconv_t     iconv_t
+#define SDL_iconv_open  iconv_open
+#define SDL_iconv_close iconv_close
+extern DECLSPEC size_t SDLCALL SDL_iconv(SDL_iconv_t cd, char **inbuf, size_t *inbytesleft, char **outbuf, size_t *outbytesleft);
+#else
+typedef struct _SDL_iconv_t *SDL_iconv_t;
+extern DECLSPEC SDL_iconv_t SDLCALL SDL_iconv_open(const char *tocode, const char *fromcode);
+extern DECLSPEC int SDLCALL SDL_iconv_close(SDL_iconv_t cd);
+extern DECLSPEC size_t SDLCALL SDL_iconv(SDL_iconv_t cd, char **inbuf, size_t *inbytesleft, char **outbuf, size_t *outbytesleft);
+#endif
+/* This function converts a string between encodings in one pass, returning a
+   string that must be freed with SDL_free() or NULL on error.
+*/
+extern DECLSPEC char * SDLCALL SDL_iconv_string(const char *tocode, const char *fromcode, char *inbuf, size_t inbytesleft);
+#define SDL_iconv_utf8_ascii(S)		SDL_iconv_string("ASCII", "UTF-8", S, SDL_strlen(S)+1)
+#define SDL_iconv_utf8_latin1(S)	SDL_iconv_string("LATIN1", "UTF-8", S, SDL_strlen(S)+1)
+#define SDL_iconv_utf8_ucs2(S)		(Uint16 *)SDL_iconv_string("UCS-2", "UTF-8", S, SDL_strlen(S)+1)
+#define SDL_iconv_utf8_ucs4(S)		(Uint32 *)SDL_iconv_string("UCS-4", "UTF-8", S, SDL_strlen(S)+1)
+
+/* Ends C function definitions when using C++ */
+#ifdef __cplusplus
+}
+#endif
+#include "close_code.h"
+
+#endif /* _SDL_stdinc_h */

src/dep/include/SDL/SDL_syswm.h

@@ -0,0 +1,210 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2006 Sam Lantinga
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+    Sam Lantinga
+    slouken@libsdl.org
+*/
+
+/* Include file for SDL custom system window manager hooks */
+
+#ifndef _SDL_syswm_h
+#define _SDL_syswm_h
+
+#include "SDL_stdinc.h"
+#include "SDL_error.h"
+#include "SDL_version.h"
+
+#include "begin_code.h"
+/* Set up for C function definitions, even when using C++ */
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Your application has access to a special type of event 'SDL_SYSWMEVENT',
+   which contains window-manager specific information and arrives whenever
+   an unhandled window event occurs.  This event is ignored by default, but
+   you can enable it with SDL_EventState()
+*/
+#ifdef SDL_PROTOTYPES_ONLY
+struct SDL_SysWMinfo;
+typedef struct SDL_SysWMinfo SDL_SysWMinfo;
+#else
+
+/* This is the structure for custom window manager events */
+#if defined(SDL_VIDEO_DRIVER_X11)
+#if defined(__APPLE__) && defined(__MACH__)
+/* conflicts with Quickdraw.h */
+#define Cursor X11Cursor
+#endif
+
+#include <X11/Xlib.h>
+#include <X11/Xatom.h>
+
+#if defined(__APPLE__) && defined(__MACH__)
+/* matches the re-define above */
+#undef Cursor
+#endif
+
+/* These are the various supported subsystems under UNIX */
+typedef enum {
+	SDL_SYSWM_X11
+} SDL_SYSWM_TYPE;
+
+/* The UNIX custom event structure */
+struct SDL_SysWMmsg {
+	SDL_version version;
+	SDL_SYSWM_TYPE subsystem;
+	union {
+	    XEvent xevent;
+	} event;
+};
+
+/* The UNIX custom window manager information structure.
+   When this structure is returned, it holds information about which
+   low level system it is using, and will be one of SDL_SYSWM_TYPE.
+ */
+typedef struct SDL_SysWMinfo {
+	SDL_version version;
+	SDL_SYSWM_TYPE subsystem;
+	union {
+	    struct {
+	    	Display *display;	/* The X11 display */
+	    	Window window;		/* The X11 display window */
+		/* These locking functions should be called around
+                   any X11 functions using the display variable.
+                   They lock the event thread, so should not be
+		   called around event functions or from event filters.
+		 */
+		void (*lock_func)(void);
+		void (*unlock_func)(void);
+
+		/* Introduced in SDL 1.0.2 */
+	    	Window fswindow;	/* The X11 fullscreen window */
+	    	Window wmwindow;	/* The X11 managed input window */
+	    } x11;
+	} info;
+} SDL_SysWMinfo;
+
+#elif defined(SDL_VIDEO_DRIVER_NANOX)
+#include <microwin/nano-X.h>
+
+/* The generic custom event structure */
+struct SDL_SysWMmsg {
+	SDL_version version;
+	int data;
+};
+
+/* The windows custom window manager information structure */
+typedef struct SDL_SysWMinfo {
+	SDL_version version ;
+	GR_WINDOW_ID window ;	/* The display window */
+} SDL_SysWMinfo;
+
+#elif defined(SDL_VIDEO_DRIVER_WINDIB) || defined(SDL_VIDEO_DRIVER_DDRAW) || defined(SDL_VIDEO_DRIVER_GAPI)
+#define WIN32_LEAN_AND_MEAN
+#include <windows.h>
+
+/* The windows custom event structure */
+struct SDL_SysWMmsg {
+	SDL_version version;
+	HWND hwnd;			/* The window for the message */
+	UINT msg;			/* The type of message */
+	WPARAM wParam;			/* WORD message parameter */
+	LPARAM lParam;			/* LONG message parameter */
+};
+
+/* The windows custom window manager information structure */
+typedef struct SDL_SysWMinfo {
+	SDL_version version;
+	HWND window;			/* The Win32 display window */
+	HGLRC hglrc;			/* The OpenGL context, if any */
+} SDL_SysWMinfo;
+
+#elif defined(SDL_VIDEO_DRIVER_RISCOS)
+
+/* RISC OS custom event structure */
+struct SDL_SysWMmsg {
+	SDL_version version;
+	int eventCode;		/* The window for the message */
+	int pollBlock[64];
+};
+
+/* The RISC OS custom window manager information structure */
+typedef struct SDL_SysWMinfo {
+	SDL_version version;
+	int wimpVersion;    /* Wimp version running under */
+	int taskHandle;     /* The RISC OS task handle */
+	int window;		/* The RISC OS display window */
+} SDL_SysWMinfo;
+
+#elif defined(SDL_VIDEO_DRIVER_PHOTON)
+#include <sys/neutrino.h>
+#include <Ph.h>
+
+/* The QNX custom event structure */
+struct SDL_SysWMmsg {
+	SDL_version version;
+	int data;
+};
+
+/* The QNX custom window manager information structure */
+typedef struct SDL_SysWMinfo {
+	SDL_version version;
+	int data;
+} SDL_SysWMinfo;
+
+#else
+
+/* The generic custom event structure */
+struct SDL_SysWMmsg {
+	SDL_version version;
+	int data;
+};
+
+/* The generic custom window manager information structure */
+typedef struct SDL_SysWMinfo {
+	SDL_version version;
+	int data;
+} SDL_SysWMinfo;
+
+#endif /* video driver type */
+
+#endif /* SDL_PROTOTYPES_ONLY */
+
+/* Function prototypes */
+/*
+ * This function gives you custom hooks into the window manager information.
+ * It fills the structure pointed to by 'info' with custom information and
+ * returns 1 if the function is implemented.  If it's not implemented, or
+ * the version member of the 'info' structure is invalid, it returns 0. 
+ *
+ * You typically use this function like this:
+ * SDL_SysWMInfo info;
+ * SDL_VERSION(&info.version);
+ * if ( SDL_GetWMInfo(&info) ) { ... }
+ */
+extern DECLSPEC int SDLCALL SDL_GetWMInfo(SDL_SysWMinfo *info);
+
+
+/* Ends C function definitions when using C++ */
+#ifdef __cplusplus
+}
+#endif
+#include "close_code.h"
+
+#endif /* _SDL_syswm_h */

src/dep/include/SDL/SDL_thread.h

@@ -0,0 +1,119 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2006 Sam Lantinga
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+    Sam Lantinga
+    slouken@libsdl.org
+*/
+
+#ifndef _SDL_thread_h
+#define _SDL_thread_h
+
+/* Header for the SDL thread management routines 
+
+	These are independent of the other SDL routines.
+*/
+
+#include "SDL_stdinc.h"
+#include "SDL_error.h"
+
+/* Thread synchronization primitives */
+#include "SDL_mutex.h"
+
+#include "begin_code.h"
+/* Set up for C function definitions, even when using C++ */
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* The SDL thread structure, defined in SDL_thread.c */
+struct SDL_Thread;
+typedef struct SDL_Thread SDL_Thread;
+
+/* Create a thread */
+#if (defined(__WIN32__) && !defined(HAVE_LIBC)) || defined(__OS2__)
+/*
+   We compile SDL into a DLL on OS/2. This means, that it's the DLL which
+   creates a new thread for the calling process with the SDL_CreateThread()
+   API. There is a problem with this, that only the RTL of the SDL.DLL will
+   be initialized for those threads, and not the RTL of the calling application!
+   To solve this, we make a little hack here.
+   We'll always use the caller's _beginthread() and _endthread() APIs to
+   start a new thread. This way, if it's the SDL.DLL which uses this API,
+   then the RTL of SDL.DLL will be used to create the new thread, and if it's
+   the application, then the RTL of the application will be used.
+   So, in short:
+   Always use the _beginthread() and _endthread() of the calling runtime library!
+*/
+#define SDL_PASSED_BEGINTHREAD_ENDTHREAD
+#ifndef _WIN32_WCE
+#include <process.h> /* This has _beginthread() and _endthread() defined! */
+#endif
+
+#ifdef __OS2__
+typedef int (*pfnSDL_CurrentBeginThread)(void (*func)(void *), void *, unsigned, void *arg); 
+typedef void (*pfnSDL_CurrentEndThread)(void);
+#elif __GNUC__
+typedef unsigned long (__cdecl *pfnSDL_CurrentBeginThread) (void *, unsigned,
+        unsigned (__stdcall *func)(void *), void *arg, 
+        unsigned, unsigned *threadID);
+typedef void (__cdecl *pfnSDL_CurrentEndThread)(unsigned code);
+#else
+typedef uintptr_t (__cdecl *pfnSDL_CurrentBeginThread) (void *, unsigned,
+        unsigned (__stdcall *func)(void *), void *arg, 
+        unsigned, unsigned *threadID);
+typedef void (__cdecl *pfnSDL_CurrentEndThread)(unsigned code);
+#endif
+
+extern DECLSPEC SDL_Thread * SDLCALL SDL_CreateThread(int (SDLCALL *fn)(void *), void *data, pfnSDL_CurrentBeginThread pfnBeginThread, pfnSDL_CurrentEndThread pfnEndThread);
+
+#ifdef __OS2__
+#define SDL_CreateThread(fn, data) SDL_CreateThread(fn, data, _beginthread, _endthread)
+#elif defined(_WIN32_WCE)
+#define SDL_CreateThread(fn, data) SDL_CreateThread(fn, data, NULL, NULL)
+#else
+#define SDL_CreateThread(fn, data) SDL_CreateThread(fn, data, _beginthreadex, _endthreadex)
+#endif
+#else
+extern DECLSPEC SDL_Thread * SDLCALL SDL_CreateThread(int (SDLCALL *fn)(void *), void *data);
+#endif
+
+/* Get the 32-bit thread identifier for the current thread */
+extern DECLSPEC Uint32 SDLCALL SDL_ThreadID(void);
+
+/* Get the 32-bit thread identifier for the specified thread,
+   equivalent to SDL_ThreadID() if the specified thread is NULL.
+ */
+extern DECLSPEC Uint32 SDLCALL SDL_GetThreadID(SDL_Thread *thread);
+
+/* Wait for a thread to finish.
+   The return code for the thread function is placed in the area
+   pointed to by 'status', if 'status' is not NULL.
+ */
+extern DECLSPEC void SDLCALL SDL_WaitThread(SDL_Thread *thread, int *status);
+
+/* Forcefully kill a thread without worrying about its state */
+extern DECLSPEC void SDLCALL SDL_KillThread(SDL_Thread *thread);
+
+
+/* Ends C function definitions when using C++ */
+#ifdef __cplusplus
+}
+#endif
+#include "close_code.h"
+
+#endif /* _SDL_thread_h */

src/dep/include/SDL/SDL_timer.h

@@ -0,0 +1,115 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2006 Sam Lantinga
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+    Sam Lantinga
+    slouken@libsdl.org
+*/
+
+#ifndef _SDL_timer_h
+#define _SDL_timer_h
+
+/* Header for the SDL time management routines */
+
+#include "SDL_stdinc.h"
+#include "SDL_error.h"
+
+#include "begin_code.h"
+/* Set up for C function definitions, even when using C++ */
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* This is the OS scheduler timeslice, in milliseconds */
+#define SDL_TIMESLICE		10
+
+/* This is the maximum resolution of the SDL timer on all platforms */
+#define TIMER_RESOLUTION	10	/* Experimentally determined */
+
+/* Get the number of milliseconds since the SDL library initialization.
+ * Note that this value wraps if the program runs for more than ~49 days.
+ */ 
+extern DECLSPEC Uint32 SDLCALL SDL_GetTicks(void);
+
+/* Wait a specified number of milliseconds before returning */
+extern DECLSPEC void SDLCALL SDL_Delay(Uint32 ms);
+
+/* Function prototype for the timer callback function */
+typedef Uint32 (SDLCALL *SDL_TimerCallback)(Uint32 interval);
+
+/* Set a callback to run after the specified number of milliseconds has
+ * elapsed. The callback function is passed the current timer interval
+ * and returns the next timer interval.  If the returned value is the 
+ * same as the one passed in, the periodic alarm continues, otherwise a
+ * new alarm is scheduled.  If the callback returns 0, the periodic alarm
+ * is cancelled.
+ *
+ * To cancel a currently running timer, call SDL_SetTimer(0, NULL);
+ *
+ * The timer callback function may run in a different thread than your
+ * main code, and so shouldn't call any functions from within itself.
+ *
+ * The maximum resolution of this timer is 10 ms, which means that if
+ * you request a 16 ms timer, your callback will run approximately 20 ms
+ * later on an unloaded system.  If you wanted to set a flag signaling
+ * a frame update at 30 frames per second (every 33 ms), you might set a 
+ * timer for 30 ms:
+ *   SDL_SetTimer((33/10)*10, flag_update);
+ *
+ * If you use this function, you need to pass SDL_INIT_TIMER to SDL_Init().
+ *
+ * Under UNIX, you should not use raise or use SIGALRM and this function
+ * in the same program, as it is implemented using setitimer().  You also
+ * should not use this function in multi-threaded applications as signals
+ * to multi-threaded apps have undefined behavior in some implementations.
+ *
+ * This function returns 0 if successful, or -1 if there was an error.
+ */
+extern DECLSPEC int SDLCALL SDL_SetTimer(Uint32 interval, SDL_TimerCallback callback);
+
+/* New timer API, supports multiple timers
+ * Written by Stephane Peter <megastep@lokigames.com>
+ */
+
+/* Function prototype for the new timer callback function.
+ * The callback function is passed the current timer interval and returns
+ * the next timer interval.  If the returned value is the same as the one
+ * passed in, the periodic alarm continues, otherwise a new alarm is
+ * scheduled.  If the callback returns 0, the periodic alarm is cancelled.
+ */
+typedef Uint32 (SDLCALL *SDL_NewTimerCallback)(Uint32 interval, void *param);
+
+/* Definition of the timer ID type */
+typedef struct _SDL_TimerID *SDL_TimerID;
+
+/* Add a new timer to the pool of timers already running.
+   Returns a timer ID, or NULL when an error occurs.
+ */
+extern DECLSPEC SDL_TimerID SDLCALL SDL_AddTimer(Uint32 interval, SDL_NewTimerCallback callback, void *param);
+
+/* Remove one of the multiple timers knowing its ID.
+ * Returns a boolean value indicating success.
+ */
+extern DECLSPEC SDL_bool SDLCALL SDL_RemoveTimer(SDL_TimerID t);
+
+/* Ends C function definitions when using C++ */
+#ifdef __cplusplus
+}
+#endif
+#include "close_code.h"
+
+#endif /* _SDL_timer_h */

src/dep/include/SDL/SDL_types.h

@@ -0,0 +1,24 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2006 Sam Lantinga
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+    Sam Lantinga
+    slouken@libsdl.org
+*/
+
+/* DEPRECATED */
+#include "SDL_stdinc.h"

src/dep/include/SDL/SDL_version.h

@@ -0,0 +1,85 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2006 Sam Lantinga
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+    Sam Lantinga
+    slouken@libsdl.org
+*/
+
+/* This header defines the current SDL version */
+
+#ifndef _SDL_version_h
+#define _SDL_version_h
+
+#include "SDL_stdinc.h"
+
+#include "begin_code.h"
+/* Set up for C function definitions, even when using C++ */
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Printable format: "%d.%d.%d", MAJOR, MINOR, PATCHLEVEL
+*/
+#define SDL_MAJOR_VERSION	1
+#define SDL_MINOR_VERSION	2
+#define SDL_PATCHLEVEL		11
+
+typedef struct SDL_version {
+	Uint8 major;
+	Uint8 minor;
+	Uint8 patch;
+} SDL_version;
+
+/* This macro can be used to fill a version structure with the compile-time
+ * version of the SDL library.
+ */
+#define SDL_VERSION(X)							\
+{									\
+	(X)->major = SDL_MAJOR_VERSION;					\
+	(X)->minor = SDL_MINOR_VERSION;					\
+	(X)->patch = SDL_PATCHLEVEL;					\
+}
+
+/* This macro turns the version numbers into a numeric value:
+   (1,2,3) -> (1203)
+   This assumes that there will never be more than 100 patchlevels
+*/
+#define SDL_VERSIONNUM(X, Y, Z)						\
+	((X)*1000 + (Y)*100 + (Z))
+
+/* This is the version number macro for the current SDL version */
+#define SDL_COMPILEDVERSION \
+	SDL_VERSIONNUM(SDL_MAJOR_VERSION, SDL_MINOR_VERSION, SDL_PATCHLEVEL)
+
+/* This macro will evaluate to true if compiled with SDL at least X.Y.Z */
+#define SDL_VERSION_ATLEAST(X, Y, Z) \
+	(SDL_COMPILEDVERSION >= SDL_VERSIONNUM(X, Y, Z))
+
+/* This function gets the version of the dynamically linked SDL library.
+   it should NOT be used to fill a version structure, instead you should
+   use the SDL_Version() macro.
+ */
+extern DECLSPEC const SDL_version * SDLCALL SDL_Linked_Version(void);
+
+/* Ends C function definitions when using C++ */
+#ifdef __cplusplus
+}
+#endif
+#include "close_code.h"
+
+#endif /* _SDL_version_h */

src/dep/include/SDL/SDL_video.h

@@ -0,0 +1,889 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2006 Sam Lantinga
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+    Sam Lantinga
+    slouken@libsdl.org
+*/
+
+/* Header file for access to the SDL raw framebuffer window */
+
+#ifndef _SDL_video_h
+#define _SDL_video_h
+
+#include "SDL_stdinc.h"
+#include "SDL_error.h"
+#include "SDL_rwops.h"
+
+#include "begin_code.h"
+/* Set up for C function definitions, even when using C++ */
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Transparency definitions: These define alpha as the opacity of a surface */
+#define SDL_ALPHA_OPAQUE 255
+#define SDL_ALPHA_TRANSPARENT 0
+
+/* Useful data types */
+typedef struct SDL_Rect {
+	Sint16 x, y;
+	Uint16 w, h;
+} SDL_Rect;
+
+typedef struct SDL_Color {
+	Uint8 r;
+	Uint8 g;
+	Uint8 b;
+	Uint8 unused;
+} SDL_Color;
+#define SDL_Colour SDL_Color
+
+typedef struct SDL_Palette {
+	int       ncolors;
+	SDL_Color *colors;
+} SDL_Palette;
+
+/* Everything in the pixel format structure is read-only */
+typedef struct SDL_PixelFormat {
+	SDL_Palette *palette;
+	Uint8  BitsPerPixel;
+	Uint8  BytesPerPixel;
+	Uint8  Rloss;
+	Uint8  Gloss;
+	Uint8  Bloss;
+	Uint8  Aloss;
+	Uint8  Rshift;
+	Uint8  Gshift;
+	Uint8  Bshift;
+	Uint8  Ashift;
+	Uint32 Rmask;
+	Uint32 Gmask;
+	Uint32 Bmask;
+	Uint32 Amask;
+
+	/* RGB color key information */
+	Uint32 colorkey;
+	/* Alpha value information (per-surface alpha) */
+	Uint8  alpha;
+} SDL_PixelFormat;
+
+/* This structure should be treated as read-only, except for 'pixels',
+   which, if not NULL, contains the raw pixel data for the surface.
+*/
+typedef struct SDL_Surface {
+	Uint32 flags;				/* Read-only */
+	SDL_PixelFormat *format;		/* Read-only */
+	int w, h;				/* Read-only */
+	Uint16 pitch;				/* Read-only */
+	void *pixels;				/* Read-write */
+	int offset;				/* Private */
+
+	/* Hardware-specific surface info */
+	struct private_hwdata *hwdata;
+
+	/* clipping information */
+	SDL_Rect clip_rect;			/* Read-only */
+	Uint32 unused1;				/* for binary compatibility */
+
+	/* Allow recursive locks */
+	Uint32 locked;				/* Private */
+
+	/* info for fast blit mapping to other surfaces */
+	struct SDL_BlitMap *map;		/* Private */
+
+	/* format version, bumped at every change to invalidate blit maps */
+	unsigned int format_version;		/* Private */
+
+	/* Reference count -- used when freeing surface */
+	int refcount;				/* Read-mostly */
+} SDL_Surface;
+
+/* These are the currently supported flags for the SDL_surface */
+/* Available for SDL_CreateRGBSurface() or SDL_SetVideoMode() */
+#define SDL_SWSURFACE	0x00000000	/* Surface is in system memory */
+#define SDL_HWSURFACE	0x00000001	/* Surface is in video memory */
+#define SDL_ASYNCBLIT	0x00000004	/* Use asynchronous blits if possible */
+/* Available for SDL_SetVideoMode() */
+#define SDL_ANYFORMAT	0x10000000	/* Allow any video depth/pixel-format */
+#define SDL_HWPALETTE	0x20000000	/* Surface has exclusive palette */
+#define SDL_DOUBLEBUF	0x40000000	/* Set up double-buffered video mode */
+#define SDL_FULLSCREEN	0x80000000	/* Surface is a full screen display */
+#define SDL_OPENGL      0x00000002      /* Create an OpenGL rendering context */
+#define SDL_OPENGLBLIT	0x0000000A	/* Create an OpenGL rendering context and use it for blitting */
+#define SDL_RESIZABLE	0x00000010	/* This video mode may be resized */
+#define SDL_NOFRAME	0x00000020	/* No window caption or edge frame */
+/* Used internally (read-only) */
+#define SDL_HWACCEL	0x00000100	/* Blit uses hardware acceleration */
+#define SDL_SRCCOLORKEY	0x00001000	/* Blit uses a source color key */
+#define SDL_RLEACCELOK	0x00002000	/* Private flag */
+#define SDL_RLEACCEL	0x00004000	/* Surface is RLE encoded */
+#define SDL_SRCALPHA	0x00010000	/* Blit uses source alpha blending */
+#define SDL_PREALLOC	0x01000000	/* Surface uses preallocated memory */
+
+/* Evaluates to true if the surface needs to be locked before access */
+#define SDL_MUSTLOCK(surface)	\
+  (surface->offset ||		\
+  ((surface->flags & (SDL_HWSURFACE|SDL_ASYNCBLIT|SDL_RLEACCEL)) != 0))
+
+/* typedef for private surface blitting functions */
+typedef int (*SDL_blit)(struct SDL_Surface *src, SDL_Rect *srcrect,
+			struct SDL_Surface *dst, SDL_Rect *dstrect);
+
+
+/* Useful for determining the video hardware capabilities */
+typedef struct SDL_VideoInfo {
+	Uint32 hw_available :1;	/* Flag: Can you create hardware surfaces? */
+	Uint32 wm_available :1;	/* Flag: Can you talk to a window manager? */
+	Uint32 UnusedBits1  :6;
+	Uint32 UnusedBits2  :1;
+	Uint32 blit_hw      :1;	/* Flag: Accelerated blits HW --> HW */
+	Uint32 blit_hw_CC   :1;	/* Flag: Accelerated blits with Colorkey */
+	Uint32 blit_hw_A    :1;	/* Flag: Accelerated blits with Alpha */
+	Uint32 blit_sw      :1;	/* Flag: Accelerated blits SW --> HW */
+	Uint32 blit_sw_CC   :1;	/* Flag: Accelerated blits with Colorkey */
+	Uint32 blit_sw_A    :1;	/* Flag: Accelerated blits with Alpha */
+	Uint32 blit_fill    :1;	/* Flag: Accelerated color fill */
+	Uint32 UnusedBits3  :16;
+	Uint32 video_mem;	/* The total amount of video memory (in K) */
+	SDL_PixelFormat *vfmt;	/* Value: The format of the video surface */
+	int    current_w;	/* Value: The current video mode width */
+	int    current_h;	/* Value: The current video mode height */
+} SDL_VideoInfo;
+
+
+/* The most common video overlay formats.
+   For an explanation of these pixel formats, see:
+	http://www.webartz.com/fourcc/indexyuv.htm
+
+   For information on the relationship between color spaces, see:
+   http://www.neuro.sfc.keio.ac.jp/~aly/polygon/info/color-space-faq.html
+ */
+#define SDL_YV12_OVERLAY  0x32315659	/* Planar mode: Y + V + U  (3 planes) */
+#define SDL_IYUV_OVERLAY  0x56555949	/* Planar mode: Y + U + V  (3 planes) */
+#define SDL_YUY2_OVERLAY  0x32595559	/* Packed mode: Y0+U0+Y1+V0 (1 plane) */
+#define SDL_UYVY_OVERLAY  0x59565955	/* Packed mode: U0+Y0+V0+Y1 (1 plane) */
+#define SDL_YVYU_OVERLAY  0x55595659	/* Packed mode: Y0+V0+Y1+U0 (1 plane) */
+
+/* The YUV hardware video overlay */
+typedef struct SDL_Overlay {
+	Uint32 format;				/* Read-only */
+	int w, h;				/* Read-only */
+	int planes;				/* Read-only */
+	Uint16 *pitches;			/* Read-only */
+	Uint8 **pixels;				/* Read-write */
+
+	/* Hardware-specific surface info */
+	struct private_yuvhwfuncs *hwfuncs;
+	struct private_yuvhwdata *hwdata;
+
+	/* Special flags */
+	Uint32 hw_overlay :1;	/* Flag: This overlay hardware accelerated? */
+	Uint32 UnusedBits :31;
+} SDL_Overlay;
+
+
+/* Public enumeration for setting the OpenGL window attributes. */
+typedef enum {
+    SDL_GL_RED_SIZE,
+    SDL_GL_GREEN_SIZE,
+    SDL_GL_BLUE_SIZE,
+    SDL_GL_ALPHA_SIZE,
+    SDL_GL_BUFFER_SIZE,
+    SDL_GL_DOUBLEBUFFER,
+    SDL_GL_DEPTH_SIZE,
+    SDL_GL_STENCIL_SIZE,
+    SDL_GL_ACCUM_RED_SIZE,
+    SDL_GL_ACCUM_GREEN_SIZE,
+    SDL_GL_ACCUM_BLUE_SIZE,
+    SDL_GL_ACCUM_ALPHA_SIZE,
+    SDL_GL_STEREO,
+    SDL_GL_MULTISAMPLEBUFFERS,
+    SDL_GL_MULTISAMPLESAMPLES,
+    SDL_GL_ACCELERATED_VISUAL,
+    SDL_GL_SWAP_CONTROL
+} SDL_GLattr;
+
+/* flags for SDL_SetPalette() */
+#define SDL_LOGPAL 0x01
+#define SDL_PHYSPAL 0x02
+
+/* Function prototypes */
+
+/* These functions are used internally, and should not be used unless you
+ * have a specific need to specify the video driver you want to use.
+ * You should normally use SDL_Init() or SDL_InitSubSystem().
+ *
+ * SDL_VideoInit() initializes the video subsystem -- sets up a connection
+ * to the window manager, etc, and determines the current video mode and
+ * pixel format, but does not initialize a window or graphics mode.
+ * Note that event handling is activated by this routine.
+ *
+ * If you use both sound and video in your application, you need to call
+ * SDL_Init() before opening the sound device, otherwise under Win32 DirectX,
+ * you won't be able to set full-screen display modes.
+ */
+extern DECLSPEC int SDLCALL SDL_VideoInit(const char *driver_name, Uint32 flags);
+extern DECLSPEC void SDLCALL SDL_VideoQuit(void);
+
+/* This function fills the given character buffer with the name of the
+ * video driver, and returns a pointer to it if the video driver has
+ * been initialized.  It returns NULL if no driver has been initialized.
+ */
+extern DECLSPEC char * SDLCALL SDL_VideoDriverName(char *namebuf, int maxlen);
+
+/*
+ * This function returns a pointer to the current display surface.
+ * If SDL is doing format conversion on the display surface, this
+ * function returns the publicly visible surface, not the real video
+ * surface.
+ */
+extern DECLSPEC SDL_Surface * SDLCALL SDL_GetVideoSurface(void);
+
+/*
+ * This function returns a read-only pointer to information about the
+ * video hardware.  If this is called before SDL_SetVideoMode(), the 'vfmt'
+ * member of the returned structure will contain the pixel format of the
+ * "best" video mode.
+ */
+extern DECLSPEC const SDL_VideoInfo * SDLCALL SDL_GetVideoInfo(void);
+
+/* 
+ * Check to see if a particular video mode is supported.
+ * It returns 0 if the requested mode is not supported under any bit depth,
+ * or returns the bits-per-pixel of the closest available mode with the
+ * given width and height.  If this bits-per-pixel is different from the
+ * one used when setting the video mode, SDL_SetVideoMode() will succeed,
+ * but will emulate the requested bits-per-pixel with a shadow surface.
+ *
+ * The arguments to SDL_VideoModeOK() are the same ones you would pass to
+ * SDL_SetVideoMode()
+ */
+extern DECLSPEC int SDLCALL SDL_VideoModeOK(int width, int height, int bpp, Uint32 flags);
+
+/*
+ * Return a pointer to an array of available screen dimensions for the
+ * given format and video flags, sorted largest to smallest.  Returns 
+ * NULL if there are no dimensions available for a particular format, 
+ * or (SDL_Rect **)-1 if any dimension is okay for the given format.
+ *
+ * If 'format' is NULL, the mode list will be for the format given 
+ * by SDL_GetVideoInfo()->vfmt
+ */
+extern DECLSPEC SDL_Rect ** SDLCALL SDL_ListModes(SDL_PixelFormat *format, Uint32 flags);
+
+/*
+ * Set up a video mode with the specified width, height and bits-per-pixel.
+ *
+ * If 'bpp' is 0, it is treated as the current display bits per pixel.
+ *
+ * If SDL_ANYFORMAT is set in 'flags', the SDL library will try to set the
+ * requested bits-per-pixel, but will return whatever video pixel format is
+ * available.  The default is to emulate the requested pixel format if it
+ * is not natively available.
+ *
+ * If SDL_HWSURFACE is set in 'flags', the video surface will be placed in
+ * video memory, if possible, and you may have to call SDL_LockSurface()
+ * in order to access the raw framebuffer.  Otherwise, the video surface
+ * will be created in system memory.
+ *
+ * If SDL_ASYNCBLIT is set in 'flags', SDL will try to perform rectangle
+ * updates asynchronously, but you must always lock before accessing pixels.
+ * SDL will wait for updates to complete before returning from the lock.
+ *
+ * If SDL_HWPALETTE is set in 'flags', the SDL library will guarantee
+ * that the colors set by SDL_SetColors() will be the colors you get.
+ * Otherwise, in 8-bit mode, SDL_SetColors() may not be able to set all
+ * of the colors exactly the way they are requested, and you should look
+ * at the video surface structure to determine the actual palette.
+ * If SDL cannot guarantee that the colors you request can be set, 
+ * i.e. if the colormap is shared, then the video surface may be created
+ * under emulation in system memory, overriding the SDL_HWSURFACE flag.
+ *
+ * If SDL_FULLSCREEN is set in 'flags', the SDL library will try to set
+ * a fullscreen video mode.  The default is to create a windowed mode
+ * if the current graphics system has a window manager.
+ * If the SDL library is able to set a fullscreen video mode, this flag 
+ * will be set in the surface that is returned.
+ *
+ * If SDL_DOUBLEBUF is set in 'flags', the SDL library will try to set up
+ * two surfaces in video memory and swap between them when you call 
+ * SDL_Flip().  This is usually slower than the normal single-buffering
+ * scheme, but prevents "tearing" artifacts caused by modifying video 
+ * memory while the monitor is refreshing.  It should only be used by 
+ * applications that redraw the entire screen on every update.
+ *
+ * If SDL_RESIZABLE is set in 'flags', the SDL library will allow the
+ * window manager, if any, to resize the window at runtime.  When this
+ * occurs, SDL will send a SDL_VIDEORESIZE event to you application,
+ * and you must respond to the event by re-calling SDL_SetVideoMode()
+ * with the requested size (or another size that suits the application).
+ *
+ * If SDL_NOFRAME is set in 'flags', the SDL library will create a window
+ * without any title bar or frame decoration.  Fullscreen video modes have
+ * this flag set automatically.
+ *
+ * This function returns the video framebuffer surface, or NULL if it fails.
+ *
+ * If you rely on functionality provided by certain video flags, check the
+ * flags of the returned surface to make sure that functionality is available.
+ * SDL will fall back to reduced functionality if the exact flags you wanted
+ * are not available.
+ */
+extern DECLSPEC SDL_Surface * SDLCALL SDL_SetVideoMode
+			(int width, int height, int bpp, Uint32 flags);
+
+/*
+ * Makes sure the given list of rectangles is updated on the given screen.
+ * If 'x', 'y', 'w' and 'h' are all 0, SDL_UpdateRect will update the entire
+ * screen.
+ * These functions should not be called while 'screen' is locked.
+ */
+extern DECLSPEC void SDLCALL SDL_UpdateRects
+		(SDL_Surface *screen, int numrects, SDL_Rect *rects);
+extern DECLSPEC void SDLCALL SDL_UpdateRect
+		(SDL_Surface *screen, Sint32 x, Sint32 y, Uint32 w, Uint32 h);
+
+/*
+ * On hardware that supports double-buffering, this function sets up a flip
+ * and returns.  The hardware will wait for vertical retrace, and then swap
+ * video buffers before the next video surface blit or lock will return.
+ * On hardware that doesn not support double-buffering, this is equivalent
+ * to calling SDL_UpdateRect(screen, 0, 0, 0, 0);
+ * The SDL_DOUBLEBUF flag must have been passed to SDL_SetVideoMode() when
+ * setting the video mode for this function to perform hardware flipping.
+ * This function returns 0 if successful, or -1 if there was an error.
+ */
+extern DECLSPEC int SDLCALL SDL_Flip(SDL_Surface *screen);
+
+/*
+ * Set the gamma correction for each of the color channels.
+ * The gamma values range (approximately) between 0.1 and 10.0
+ * 
+ * If this function isn't supported directly by the hardware, it will
+ * be emulated using gamma ramps, if available.  If successful, this
+ * function returns 0, otherwise it returns -1.
+ */
+extern DECLSPEC int SDLCALL SDL_SetGamma(float red, float green, float blue);
+
+/*
+ * Set the gamma translation table for the red, green, and blue channels
+ * of the video hardware.  Each table is an array of 256 16-bit quantities,
+ * representing a mapping between the input and output for that channel.
+ * The input is the index into the array, and the output is the 16-bit
+ * gamma value at that index, scaled to the output color precision.
+ * 
+ * You may pass NULL for any of the channels to leave it unchanged.
+ * If the call succeeds, it will return 0.  If the display driver or
+ * hardware does not support gamma translation, or otherwise fails,
+ * this function will return -1.
+ */
+extern DECLSPEC int SDLCALL SDL_SetGammaRamp(const Uint16 *red, const Uint16 *green, const Uint16 *blue);
+
+/*
+ * Retrieve the current values of the gamma translation tables.
+ * 
+ * You must pass in valid pointers to arrays of 256 16-bit quantities.
+ * Any of the pointers may be NULL to ignore that channel.
+ * If the call succeeds, it will return 0.  If the display driver or
+ * hardware does not support gamma translation, or otherwise fails,
+ * this function will return -1.
+ */
+extern DECLSPEC int SDLCALL SDL_GetGammaRamp(Uint16 *red, Uint16 *green, Uint16 *blue);
+
+/*
+ * Sets a portion of the colormap for the given 8-bit surface.  If 'surface'
+ * is not a palettized surface, this function does nothing, returning 0.
+ * If all of the colors were set as passed to SDL_SetColors(), it will
+ * return 1.  If not all the color entries were set exactly as given,
+ * it will return 0, and you should look at the surface palette to
+ * determine the actual color palette.
+ *
+ * When 'surface' is the surface associated with the current display, the
+ * display colormap will be updated with the requested colors.  If 
+ * SDL_HWPALETTE was set in SDL_SetVideoMode() flags, SDL_SetColors()
+ * will always return 1, and the palette is guaranteed to be set the way
+ * you desire, even if the window colormap has to be warped or run under
+ * emulation.
+ */
+extern DECLSPEC int SDLCALL SDL_SetColors(SDL_Surface *surface, 
+			SDL_Color *colors, int firstcolor, int ncolors);
+
+/*
+ * Sets a portion of the colormap for a given 8-bit surface.
+ * 'flags' is one or both of:
+ * SDL_LOGPAL  -- set logical palette, which controls how blits are mapped
+ *                to/from the surface,
+ * SDL_PHYSPAL -- set physical palette, which controls how pixels look on
+ *                the screen
+ * Only screens have physical palettes. Separate change of physical/logical
+ * palettes is only possible if the screen has SDL_HWPALETTE set.
+ *
+ * The return value is 1 if all colours could be set as requested, and 0
+ * otherwise.
+ *
+ * SDL_SetColors() is equivalent to calling this function with
+ *     flags = (SDL_LOGPAL|SDL_PHYSPAL).
+ */
+extern DECLSPEC int SDLCALL SDL_SetPalette(SDL_Surface *surface, int flags,
+				   SDL_Color *colors, int firstcolor,
+				   int ncolors);
+
+/*
+ * Maps an RGB triple to an opaque pixel value for a given pixel format
+ */
+extern DECLSPEC Uint32 SDLCALL SDL_MapRGB
+			(SDL_PixelFormat *format, Uint8 r, Uint8 g, Uint8 b);
+
+/*
+ * Maps an RGBA quadruple to a pixel value for a given pixel format
+ */
+extern DECLSPEC Uint32 SDLCALL SDL_MapRGBA(SDL_PixelFormat *format,
+				   Uint8 r, Uint8 g, Uint8 b, Uint8 a);
+
+/*
+ * Maps a pixel value into the RGB components for a given pixel format
+ */
+extern DECLSPEC void SDLCALL SDL_GetRGB(Uint32 pixel, SDL_PixelFormat *fmt,
+				Uint8 *r, Uint8 *g, Uint8 *b);
+
+/*
+ * Maps a pixel value into the RGBA components for a given pixel format
+ */
+extern DECLSPEC void SDLCALL SDL_GetRGBA(Uint32 pixel, SDL_PixelFormat *fmt,
+				 Uint8 *r, Uint8 *g, Uint8 *b, Uint8 *a);
+
+/*
+ * Allocate and free an RGB surface (must be called after SDL_SetVideoMode)
+ * If the depth is 4 or 8 bits, an empty palette is allocated for the surface.
+ * If the depth is greater than 8 bits, the pixel format is set using the
+ * flags '[RGB]mask'.
+ * If the function runs out of memory, it will return NULL.
+ *
+ * The 'flags' tell what kind of surface to create.
+ * SDL_SWSURFACE means that the surface should be created in system memory.
+ * SDL_HWSURFACE means that the surface should be created in video memory,
+ * with the same format as the display surface.  This is useful for surfaces
+ * that will not change much, to take advantage of hardware acceleration
+ * when being blitted to the display surface.
+ * SDL_ASYNCBLIT means that SDL will try to perform asynchronous blits with
+ * this surface, but you must always lock it before accessing the pixels.
+ * SDL will wait for current blits to finish before returning from the lock.
+ * SDL_SRCCOLORKEY indicates that the surface will be used for colorkey blits.
+ * If the hardware supports acceleration of colorkey blits between
+ * two surfaces in video memory, SDL will try to place the surface in
+ * video memory. If this isn't possible or if there is no hardware
+ * acceleration available, the surface will be placed in system memory.
+ * SDL_SRCALPHA means that the surface will be used for alpha blits and 
+ * if the hardware supports hardware acceleration of alpha blits between
+ * two surfaces in video memory, to place the surface in video memory
+ * if possible, otherwise it will be placed in system memory.
+ * If the surface is created in video memory, blits will be _much_ faster,
+ * but the surface format must be identical to the video surface format,
+ * and the only way to access the pixels member of the surface is to use
+ * the SDL_LockSurface() and SDL_UnlockSurface() calls.
+ * If the requested surface actually resides in video memory, SDL_HWSURFACE
+ * will be set in the flags member of the returned surface.  If for some
+ * reason the surface could not be placed in video memory, it will not have
+ * the SDL_HWSURFACE flag set, and will be created in system memory instead.
+ */
+#define SDL_AllocSurface    SDL_CreateRGBSurface
+extern DECLSPEC SDL_Surface * SDLCALL SDL_CreateRGBSurface
+			(Uint32 flags, int width, int height, int depth, 
+			Uint32 Rmask, Uint32 Gmask, Uint32 Bmask, Uint32 Amask);
+extern DECLSPEC SDL_Surface * SDLCALL SDL_CreateRGBSurfaceFrom(void *pixels,
+			int width, int height, int depth, int pitch,
+			Uint32 Rmask, Uint32 Gmask, Uint32 Bmask, Uint32 Amask);
+extern DECLSPEC void SDLCALL SDL_FreeSurface(SDL_Surface *surface);
+
+/*
+ * SDL_LockSurface() sets up a surface for directly accessing the pixels.
+ * Between calls to SDL_LockSurface()/SDL_UnlockSurface(), you can write
+ * to and read from 'surface->pixels', using the pixel format stored in 
+ * 'surface->format'.  Once you are done accessing the surface, you should 
+ * use SDL_UnlockSurface() to release it.
+ *
+ * Not all surfaces require locking.  If SDL_MUSTLOCK(surface) evaluates
+ * to 0, then you can read and write to the surface at any time, and the
+ * pixel format of the surface will not change.  In particular, if the
+ * SDL_HWSURFACE flag is not given when calling SDL_SetVideoMode(), you
+ * will not need to lock the display surface before accessing it.
+ * 
+ * No operating system or library calls should be made between lock/unlock
+ * pairs, as critical system locks may be held during this time.
+ *
+ * SDL_LockSurface() returns 0, or -1 if the surface couldn't be locked.
+ */
+extern DECLSPEC int SDLCALL SDL_LockSurface(SDL_Surface *surface);
+extern DECLSPEC void SDLCALL SDL_UnlockSurface(SDL_Surface *surface);
+
+/*
+ * Load a surface from a seekable SDL data source (memory or file.)
+ * If 'freesrc' is non-zero, the source will be closed after being read.
+ * Returns the new surface, or NULL if there was an error.
+ * The new surface should be freed with SDL_FreeSurface().
+ */
+extern DECLSPEC SDL_Surface * SDLCALL SDL_LoadBMP_RW(SDL_RWops *src, int freesrc);
+
+/* Convenience macro -- load a surface from a file */
+#define SDL_LoadBMP(file)	SDL_LoadBMP_RW(SDL_RWFromFile(file, "rb"), 1)
+
+/*
+ * Save a surface to a seekable SDL data source (memory or file.)
+ * If 'freedst' is non-zero, the source will be closed after being written.
+ * Returns 0 if successful or -1 if there was an error.
+ */
+extern DECLSPEC int SDLCALL SDL_SaveBMP_RW
+		(SDL_Surface *surface, SDL_RWops *dst, int freedst);
+
+/* Convenience macro -- save a surface to a file */
+#define SDL_SaveBMP(surface, file) \
+		SDL_SaveBMP_RW(surface, SDL_RWFromFile(file, "wb"), 1)
+
+/*
+ * Sets the color key (transparent pixel) in a blittable surface.
+ * If 'flag' is SDL_SRCCOLORKEY (optionally OR'd with SDL_RLEACCEL), 
+ * 'key' will be the transparent pixel in the source image of a blit.
+ * SDL_RLEACCEL requests RLE acceleration for the surface if present,
+ * and removes RLE acceleration if absent.
+ * If 'flag' is 0, this function clears any current color key.
+ * This function returns 0, or -1 if there was an error.
+ */
+extern DECLSPEC int SDLCALL SDL_SetColorKey
+			(SDL_Surface *surface, Uint32 flag, Uint32 key);
+
+/*
+ * This function sets the alpha value for the entire surface, as opposed to
+ * using the alpha component of each pixel. This value measures the range
+ * of transparency of the surface, 0 being completely transparent to 255
+ * being completely opaque. An 'alpha' value of 255 causes blits to be
+ * opaque, the source pixels copied to the destination (the default). Note
+ * that per-surface alpha can be combined with colorkey transparency.
+ *
+ * If 'flag' is 0, alpha blending is disabled for the surface.
+ * If 'flag' is SDL_SRCALPHA, alpha blending is enabled for the surface.
+ * OR:ing the flag with SDL_RLEACCEL requests RLE acceleration for the
+ * surface; if SDL_RLEACCEL is not specified, the RLE accel will be removed.
+ *
+ * The 'alpha' parameter is ignored for surfaces that have an alpha channel.
+ */
+extern DECLSPEC int SDLCALL SDL_SetAlpha(SDL_Surface *surface, Uint32 flag, Uint8 alpha);
+
+/*
+ * Sets the clipping rectangle for the destination surface in a blit.
+ *
+ * If the clip rectangle is NULL, clipping will be disabled.
+ * If the clip rectangle doesn't intersect the surface, the function will
+ * return SDL_FALSE and blits will be completely clipped.  Otherwise the
+ * function returns SDL_TRUE and blits to the surface will be clipped to
+ * the intersection of the surface area and the clipping rectangle.
+ *
+ * Note that blits are automatically clipped to the edges of the source
+ * and destination surfaces.
+ */
+extern DECLSPEC SDL_bool SDLCALL SDL_SetClipRect(SDL_Surface *surface, const SDL_Rect *rect);
+
+/*
+ * Gets the clipping rectangle for the destination surface in a blit.
+ * 'rect' must be a pointer to a valid rectangle which will be filled
+ * with the correct values.
+ */
+extern DECLSPEC void SDLCALL SDL_GetClipRect(SDL_Surface *surface, SDL_Rect *rect);
+
+/*
+ * Creates a new surface of the specified format, and then copies and maps 
+ * the given surface to it so the blit of the converted surface will be as 
+ * fast as possible.  If this function fails, it returns NULL.
+ *
+ * The 'flags' parameter is passed to SDL_CreateRGBSurface() and has those 
+ * semantics.  You can also pass SDL_RLEACCEL in the flags parameter and
+ * SDL will try to RLE accelerate colorkey and alpha blits in the resulting
+ * surface.
+ *
+ * This function is used internally by SDL_DisplayFormat().
+ */
+extern DECLSPEC SDL_Surface * SDLCALL SDL_ConvertSurface
+			(SDL_Surface *src, SDL_PixelFormat *fmt, Uint32 flags);
+
+/*
+ * This performs a fast blit from the source surface to the destination
+ * surface.  It assumes that the source and destination rectangles are
+ * the same size.  If either 'srcrect' or 'dstrect' are NULL, the entire
+ * surface (src or dst) is copied.  The final blit rectangles are saved
+ * in 'srcrect' and 'dstrect' after all clipping is performed.
+ * If the blit is successful, it returns 0, otherwise it returns -1.
+ *
+ * The blit function should not be called on a locked surface.
+ *
+ * The blit semantics for surfaces with and without alpha and colorkey
+ * are defined as follows:
+ *
+ * RGBA->RGB:
+ *     SDL_SRCALPHA set:
+ * 	alpha-blend (using alpha-channel).
+ * 	SDL_SRCCOLORKEY ignored.
+ *     SDL_SRCALPHA not set:
+ * 	copy RGB.
+ * 	if SDL_SRCCOLORKEY set, only copy the pixels matching the
+ * 	RGB values of the source colour key, ignoring alpha in the
+ * 	comparison.
+ * 
+ * RGB->RGBA:
+ *     SDL_SRCALPHA set:
+ * 	alpha-blend (using the source per-surface alpha value);
+ * 	set destination alpha to opaque.
+ *     SDL_SRCALPHA not set:
+ * 	copy RGB, set destination alpha to source per-surface alpha value.
+ *     both:
+ * 	if SDL_SRCCOLORKEY set, only copy the pixels matching the
+ * 	source colour key.
+ * 
+ * RGBA->RGBA:
+ *     SDL_SRCALPHA set:
+ * 	alpha-blend (using the source alpha channel) the RGB values;
+ * 	leave destination alpha untouched. [Note: is this correct?]
+ * 	SDL_SRCCOLORKEY ignored.
+ *     SDL_SRCALPHA not set:
+ * 	copy all of RGBA to the destination.
+ * 	if SDL_SRCCOLORKEY set, only copy the pixels matching the
+ * 	RGB values of the source colour key, ignoring alpha in the
+ * 	comparison.
+ * 
+ * RGB->RGB: 
+ *     SDL_SRCALPHA set:
+ * 	alpha-blend (using the source per-surface alpha value).
+ *     SDL_SRCALPHA not set:
+ * 	copy RGB.
+ *     both:
+ * 	if SDL_SRCCOLORKEY set, only copy the pixels matching the
+ * 	source colour key.
+ *
+ * If either of the surfaces were in video memory, and the blit returns -2,
+ * the video memory was lost, so it should be reloaded with artwork and 
+ * re-blitted:
+	while ( SDL_BlitSurface(image, imgrect, screen, dstrect) == -2 ) {
+		while ( SDL_LockSurface(image) < 0 )
+			Sleep(10);
+		-- Write image pixels to image->pixels --
+		SDL_UnlockSurface(image);
+	}
+ * This happens under DirectX 5.0 when the system switches away from your
+ * fullscreen application.  The lock will also fail until you have access
+ * to the video memory again.
+ */
+/* You should call SDL_BlitSurface() unless you know exactly how SDL
+   blitting works internally and how to use the other blit functions.
+*/
+#define SDL_BlitSurface SDL_UpperBlit
+
+/* This is the public blit function, SDL_BlitSurface(), and it performs
+   rectangle validation and clipping before passing it to SDL_LowerBlit()
+*/
+extern DECLSPEC int SDLCALL SDL_UpperBlit
+			(SDL_Surface *src, SDL_Rect *srcrect,
+			 SDL_Surface *dst, SDL_Rect *dstrect);
+/* This is a semi-private blit function and it performs low-level surface
+   blitting only.
+*/
+extern DECLSPEC int SDLCALL SDL_LowerBlit
+			(SDL_Surface *src, SDL_Rect *srcrect,
+			 SDL_Surface *dst, SDL_Rect *dstrect);
+
+/*
+ * This function performs a fast fill of the given rectangle with 'color'
+ * The given rectangle is clipped to the destination surface clip area
+ * and the final fill rectangle is saved in the passed in pointer.
+ * If 'dstrect' is NULL, the whole surface will be filled with 'color'
+ * The color should be a pixel of the format used by the surface, and 
+ * can be generated by the SDL_MapRGB() function.
+ * This function returns 0 on success, or -1 on error.
+ */
+extern DECLSPEC int SDLCALL SDL_FillRect
+		(SDL_Surface *dst, SDL_Rect *dstrect, Uint32 color);
+
+/* 
+ * This function takes a surface and copies it to a new surface of the
+ * pixel format and colors of the video framebuffer, suitable for fast
+ * blitting onto the display surface.  It calls SDL_ConvertSurface()
+ *
+ * If you want to take advantage of hardware colorkey or alpha blit
+ * acceleration, you should set the colorkey and alpha value before
+ * calling this function.
+ *
+ * If the conversion fails or runs out of memory, it returns NULL
+ */
+extern DECLSPEC SDL_Surface * SDLCALL SDL_DisplayFormat(SDL_Surface *surface);
+
+/* 
+ * This function takes a surface and copies it to a new surface of the
+ * pixel format and colors of the video framebuffer (if possible),
+ * suitable for fast alpha blitting onto the display surface.
+ * The new surface will always have an alpha channel.
+ *
+ * If you want to take advantage of hardware colorkey or alpha blit
+ * acceleration, you should set the colorkey and alpha value before
+ * calling this function.
+ *
+ * If the conversion fails or runs out of memory, it returns NULL
+ */
+extern DECLSPEC SDL_Surface * SDLCALL SDL_DisplayFormatAlpha(SDL_Surface *surface);
+
+
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+/* YUV video surface overlay functions                                       */
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+
+/* This function creates a video output overlay
+   Calling the returned surface an overlay is something of a misnomer because
+   the contents of the display surface underneath the area where the overlay
+   is shown is undefined - it may be overwritten with the converted YUV data.
+*/
+extern DECLSPEC SDL_Overlay * SDLCALL SDL_CreateYUVOverlay(int width, int height,
+				Uint32 format, SDL_Surface *display);
+
+/* Lock an overlay for direct access, and unlock it when you are done */
+extern DECLSPEC int SDLCALL SDL_LockYUVOverlay(SDL_Overlay *overlay);
+extern DECLSPEC void SDLCALL SDL_UnlockYUVOverlay(SDL_Overlay *overlay);
+
+/* Blit a video overlay to the display surface.
+   The contents of the video surface underneath the blit destination are
+   not defined.  
+   The width and height of the destination rectangle may be different from
+   that of the overlay, but currently only 2x scaling is supported.
+*/
+extern DECLSPEC int SDLCALL SDL_DisplayYUVOverlay(SDL_Overlay *overlay, SDL_Rect *dstrect);
+
+/* Free a video overlay */
+extern DECLSPEC void SDLCALL SDL_FreeYUVOverlay(SDL_Overlay *overlay);
+
+
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+/* OpenGL support functions.                                                 */
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+
+/*
+ * Dynamically load an OpenGL library, or the default one if path is NULL
+ *
+ * If you do this, you need to retrieve all of the GL functions used in
+ * your program from the dynamic library using SDL_GL_GetProcAddress().
+ */
+extern DECLSPEC int SDLCALL SDL_GL_LoadLibrary(const char *path);
+
+/*
+ * Get the address of a GL function
+ */
+extern DECLSPEC void * SDLCALL SDL_GL_GetProcAddress(const char* proc);
+
+/*
+ * Set an attribute of the OpenGL subsystem before intialization.
+ */
+extern DECLSPEC int SDLCALL SDL_GL_SetAttribute(SDL_GLattr attr, int value);
+
+/*
+ * Get an attribute of the OpenGL subsystem from the windowing
+ * interface, such as glX. This is of course different from getting
+ * the values from SDL's internal OpenGL subsystem, which only
+ * stores the values you request before initialization.
+ *
+ * Developers should track the values they pass into SDL_GL_SetAttribute
+ * themselves if they want to retrieve these values.
+ */
+extern DECLSPEC int SDLCALL SDL_GL_GetAttribute(SDL_GLattr attr, int* value);
+
+/*
+ * Swap the OpenGL buffers, if double-buffering is supported.
+ */
+extern DECLSPEC void SDLCALL SDL_GL_SwapBuffers(void);
+
+/*
+ * Internal functions that should not be called unless you have read
+ * and understood the source code for these functions.
+ */
+extern DECLSPEC void SDLCALL SDL_GL_UpdateRects(int numrects, SDL_Rect* rects);
+extern DECLSPEC void SDLCALL SDL_GL_Lock(void);
+extern DECLSPEC void SDLCALL SDL_GL_Unlock(void);
+
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+/* These functions allow interaction with the window manager, if any.        */
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+
+/*
+ * Sets/Gets the title and icon text of the display window (UTF-8 encoded)
+ */
+extern DECLSPEC void SDLCALL SDL_WM_SetCaption(const char *title, const char *icon);
+extern DECLSPEC void SDLCALL SDL_WM_GetCaption(char **title, char **icon);
+
+/*
+ * Sets the icon for the display window.
+ * This function must be called before the first call to SDL_SetVideoMode().
+ * It takes an icon surface, and a mask in MSB format.
+ * If 'mask' is NULL, the entire icon surface will be used as the icon.
+ */
+extern DECLSPEC void SDLCALL SDL_WM_SetIcon(SDL_Surface *icon, Uint8 *mask);
+
+/*
+ * This function iconifies the window, and returns 1 if it succeeded.
+ * If the function succeeds, it generates an SDL_APPACTIVE loss event.
+ * This function is a noop and returns 0 in non-windowed environments.
+ */
+extern DECLSPEC int SDLCALL SDL_WM_IconifyWindow(void);
+
+/*
+ * Toggle fullscreen mode without changing the contents of the screen.
+ * If the display surface does not require locking before accessing
+ * the pixel information, then the memory pointers will not change.
+ *
+ * If this function was able to toggle fullscreen mode (change from 
+ * running in a window to fullscreen, or vice-versa), it will return 1.
+ * If it is not implemented, or fails, it returns 0.
+ *
+ * The next call to SDL_SetVideoMode() will set the mode fullscreen
+ * attribute based on the flags parameter - if SDL_FULLSCREEN is not
+ * set, then the display will be windowed by default where supported.
+ *
+ * This is currently only implemented in the X11 video driver.
+ */
+extern DECLSPEC int SDLCALL SDL_WM_ToggleFullScreen(SDL_Surface *surface);
+
+/*
+ * This function allows you to set and query the input grab state of
+ * the application.  It returns the new input grab state.
+ */
+typedef enum {
+	SDL_GRAB_QUERY = -1,
+	SDL_GRAB_OFF = 0,
+	SDL_GRAB_ON = 1,
+	SDL_GRAB_FULLSCREEN	/* Used internally */
+} SDL_GrabMode;
+/*
+ * Grabbing means that the mouse is confined to the application window,
+ * and nearly all keyboard input is passed directly to the application,
+ * and not interpreted by a window manager, if any.
+ */
+extern DECLSPEC SDL_GrabMode SDLCALL SDL_WM_GrabInput(SDL_GrabMode mode);
+
+/* Not in public API at the moment - do not use! */
+extern DECLSPEC int SDLCALL SDL_SoftStretch(SDL_Surface *src, SDL_Rect *srcrect,
+                                    SDL_Surface *dst, SDL_Rect *dstrect);
+                    
+/* Ends C function definitions when using C++ */
+#ifdef __cplusplus
+}
+#endif
+#include "close_code.h"
+
+#endif /* _SDL_video_h */

src/dep/include/SDL/begin_code.h

@@ -0,0 +1,150 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2004 Sam Lantinga
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Library General Public
+    License as published by the Free Software Foundation; either
+    version 2 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Library General Public License for more details.
+
+    You should have received a copy of the GNU Library General Public
+    License along with this library; if not, write to the Free
+    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+    Sam Lantinga
+    slouken@libsdl.org
+*/
+
+/* This file sets things up for C dynamic library function definitions,
+   static inlined functions, and structures aligned at 4-byte alignment.
+   If you don't like ugly C preprocessor code, don't look at this file. :)
+*/
+
+/* This shouldn't be nested -- included it around code only. */
+#ifdef _begin_code_h
+#error Nested inclusion of begin_code.h
+#endif
+#define _begin_code_h
+
+/* Some compilers use a special export keyword */
+#ifndef DECLSPEC
+# if defined(__BEOS__)
+#  if defined(__GNUC__)
+#   define DECLSPEC	__declspec(dllexport)
+#  else
+#   define DECLSPEC	__declspec(export)
+#  endif
+# elif defined(__WIN32__)
+#  ifdef __BORLANDC__
+#   ifdef BUILD_SDL
+#    define DECLSPEC 
+#   else
+#    define DECLSPEC	__declspec(dllimport)
+#   endif
+#  else
+#   define DECLSPEC	__declspec(dllexport)
+#  endif
+# elif defined(__OS2__)
+#  ifdef __WATCOMC__
+#   ifdef BUILD_SDL
+#    define DECLSPEC	__declspec(dllexport)
+#   else
+#    define DECLSPEC
+#   endif
+#  else
+#   define DECLSPEC
+#  endif
+# else
+#  if defined(__GNUC__) && __GNUC__ >= 4
+#   define DECLSPEC	__attribute__ ((visibility("default")))
+#  else
+#   define DECLSPEC
+#  endif
+# endif
+#endif
+
+/* By default SDL uses the C calling convention */
+#ifndef SDLCALL
+#if defined(__WIN32__) && !defined(__GNUC__)
+#define SDLCALL __cdecl
+#else
+#ifdef __OS2__
+/* But on OS/2, we use the _System calling convention */
+/* to be compatible with every compiler */
+#define SDLCALL _System
+#else
+#define SDLCALL
+#endif
+#endif
+#endif /* SDLCALL */
+
+/* Removed DECLSPEC on Symbian OS because SDL cannot be a DLL in EPOC */
+#ifdef __SYMBIAN32__ 
+#undef DECLSPEC
+#define DECLSPEC
+#endif /* __SYMBIAN32__ */
+
+/* Force structure packing at 4 byte alignment.
+   This is necessary if the header is included in code which has structure
+   packing set to an alternate value, say for loading structures from disk.
+   The packing is reset to the previous value in close_code.h
+ */
+#if defined(_MSC_VER) || defined(__MWERKS__) || defined(__BORLANDC__)
+#ifdef _MSC_VER
+#pragma warning(disable: 4103)
+#endif
+#ifdef __BORLANDC__
+#pragma nopackwarning
+#endif
+#pragma pack(push,4)
+#elif (defined(__MWERKS__) && defined(__MACOS__))
+#pragma options align=mac68k4byte
+#pragma enumsalwaysint on
+#endif /* Compiler needs structure packing set */
+
+/* Set up compiler-specific options for inlining functions */
+#ifndef SDL_INLINE_OKAY
+#ifdef __GNUC__
+#define SDL_INLINE_OKAY
+#else
+/* Add any special compiler-specific cases here */
+#if defined(_MSC_VER) || defined(__BORLANDC__) || \
+    defined(__DMC__) || defined(__SC__) || \
+    defined(__WATCOMC__) || defined(__LCC__) || \
+    defined(__DECC)
+#ifndef __inline__
+#define __inline__	__inline
+#endif
+#define SDL_INLINE_OKAY
+#else
+#if !defined(__MRC__) && !defined(_SGI_SOURCE)
+#define __inline__ inline
+#define SDL_INLINE_OKAY
+#endif /* Not a funky compiler */
+#endif /* Visual C++ */
+#endif /* GNU C */
+#endif /* SDL_INLINE_OKAY */
+
+/* If inlining isn't supported, remove "__inline__", turning static
+   inlined functions into static functions (resulting in code bloat
+   in all files which include the offending header files)
+*/
+#ifndef SDL_INLINE_OKAY
+#define __inline__
+#endif
+
+/* Apparently this is needed by several Windows compilers */
+#if !defined(__MACH__)
+#ifndef NULL
+#ifdef __cplusplus
+#define NULL 0
+#else
+#define NULL ((void *)0)
+#endif
+#endif /* NULL */
+#endif /* ! Mac OS X - breaks precompiled headers */

src/dep/include/SDL/close_code.h

@@ -0,0 +1,41 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2004 Sam Lantinga
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Library General Public
+    License as published by the Free Software Foundation; either
+    version 2 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Library General Public License for more details.
+
+    You should have received a copy of the GNU Library General Public
+    License along with this library; if not, write to the Free
+    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+    Sam Lantinga
+    slouken@libsdl.org
+*/
+
+/* This file reverses the effects of begin_code.h and should be included
+   after you finish any function and structure declarations in your headers
+*/
+
+#undef _begin_code_h
+
+/* Reset structure packing at previous byte alignment */
+#if defined(_MSC_VER) || defined(__MWERKS__) || defined(__WATCOMC__)  || defined(__BORLANDC__)
+#ifdef __BORLANDC__
+#pragma nopackwarning
+#endif
+#if (defined(__MWERKS__) && defined(__MACOS__))
+#pragma options align=reset
+#pragma enumsalwaysint reset
+#else
+#pragma pack(pop)
+#endif
+#endif /* Compiler needs structure packing set */
+

src/dep/src/SDL/SDL.c

@@ -0,0 +1,348 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2006 Sam Lantinga
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+    Sam Lantinga
+    slouken@libsdl.org
+*/
+#include "SDL_config.h"
+
+/* Initialization code for SDL */
+
+#include "SDL.h"
+#include "SDL_fatal.h"
+#if !SDL_VIDEO_DISABLED
+#include "video/SDL_leaks.h"
+#endif
+
+#if SDL_THREAD_PTH
+#include <pth.h>
+#endif
+
+/* Initialization/Cleanup routines */
+#if !SDL_JOYSTICK_DISABLED
+extern int  SDL_JoystickInit(void);
+extern void SDL_JoystickQuit(void);
+#endif
+#if !SDL_CDROM_DISABLED
+extern int  SDL_CDROMInit(void);
+extern void SDL_CDROMQuit(void);
+#endif
+#if !SDL_TIMERS_DISABLED
+extern void SDL_StartTicks(void);
+extern int  SDL_TimerInit(void);
+extern void SDL_TimerQuit(void);
+#endif
+
+/* The current SDL version */
+static SDL_version version = 
+	{ SDL_MAJOR_VERSION, SDL_MINOR_VERSION, SDL_PATCHLEVEL };
+
+/* The initialized subsystems */
+static Uint32 SDL_initialized = 0;
+static Uint32 ticks_started = 0;
+
+#ifdef CHECK_LEAKS
+int surfaces_allocated = 0;
+#endif
+
+int SDL_InitSubSystem(Uint32 flags)
+{
+#if !SDL_VIDEO_DISABLED
+	/* Initialize the video/event subsystem */
+	if ( (flags & SDL_INIT_VIDEO) && !(SDL_initialized & SDL_INIT_VIDEO) ) {
+		if ( SDL_VideoInit(SDL_getenv("SDL_VIDEODRIVER"),
+		                   (flags&SDL_INIT_EVENTTHREAD)) < 0 ) {
+			return(-1);
+		}
+		SDL_initialized |= SDL_INIT_VIDEO;
+	}
+#else
+	if ( flags & SDL_INIT_VIDEO ) {
+		SDL_SetError("SDL not built with video support");
+		return(-1);
+	}
+#endif
+
+#if !SDL_AUDIO_DISABLED
+	/* Initialize the audio subsystem */
+	if ( (flags & SDL_INIT_AUDIO) && !(SDL_initialized & SDL_INIT_AUDIO) ) {
+		if ( SDL_AudioInit(SDL_getenv("SDL_AUDIODRIVER")) < 0 ) {
+			return(-1);
+		}
+		SDL_initialized |= SDL_INIT_AUDIO;
+	}
+#else
+	if ( flags & SDL_INIT_AUDIO ) {
+		SDL_SetError("SDL not built with audio support");
+		return(-1);
+	}
+#endif
+
+#if !SDL_TIMERS_DISABLED
+	/* Initialize the timer subsystem */
+	if ( ! ticks_started ) {
+		SDL_StartTicks();
+		ticks_started = 1;
+	}
+	if ( (flags & SDL_INIT_TIMER) && !(SDL_initialized & SDL_INIT_TIMER) ) {
+		if ( SDL_TimerInit() < 0 ) {
+			return(-1);
+		}
+		SDL_initialized |= SDL_INIT_TIMER;
+	}
+#else
+	if ( flags & SDL_INIT_TIMER ) {
+		SDL_SetError("SDL not built with timer support");
+		return(-1);
+	}
+#endif
+
+#if !SDL_JOYSTICK_DISABLED
+	/* Initialize the joystick subsystem */
+	if ( (flags & SDL_INIT_JOYSTICK) &&
+	     !(SDL_initialized & SDL_INIT_JOYSTICK) ) {
+		if ( SDL_JoystickInit() < 0 ) {
+			return(-1);
+		}
+		SDL_initialized |= SDL_INIT_JOYSTICK;
+	}
+#else
+	if ( flags & SDL_INIT_JOYSTICK ) {
+		SDL_SetError("SDL not built with joystick support");
+		return(-1);
+	}
+#endif
+
+#if !SDL_CDROM_DISABLED
+	/* Initialize the CD-ROM subsystem */
+	if ( (flags & SDL_INIT_CDROM) && !(SDL_initialized & SDL_INIT_CDROM) ) {
+		if ( SDL_CDROMInit() < 0 ) {
+			return(-1);
+		}
+		SDL_initialized |= SDL_INIT_CDROM;
+	}
+#else
+	if ( flags & SDL_INIT_CDROM ) {
+		SDL_SetError("SDL not built with cdrom support");
+		return(-1);
+	}
+#endif
+	return(0);
+}
+
+int SDL_Init(Uint32 flags)
+{
+#if !SDL_THREADS_DISABLED && SDL_THREAD_PTH
+	if (!pth_init()) {
+		return -1;
+	}
+#endif
+
+	/* Clear the error message */
+	SDL_ClearError();
+
+	/* Initialize the desired subsystems */
+	if ( SDL_InitSubSystem(flags) < 0 ) {
+		return(-1);
+	}
+
+	/* Everything is initialized */
+	if ( !(flags & SDL_INIT_NOPARACHUTE) ) {
+		SDL_InstallParachute();
+	}
+	return(0);
+}
+
+void SDL_QuitSubSystem(Uint32 flags)
+{
+	/* Shut down requested initialized subsystems */
+#if !SDL_CDROM_DISABLED
+	if ( (flags & SDL_initialized & SDL_INIT_CDROM) ) {
+		SDL_CDROMQuit();
+		SDL_initialized &= ~SDL_INIT_CDROM;
+	}
+#endif
+#if !SDL_JOYSTICK_DISABLED
+	if ( (flags & SDL_initialized & SDL_INIT_JOYSTICK) ) {
+		SDL_JoystickQuit();
+		SDL_initialized &= ~SDL_INIT_JOYSTICK;
+	}
+#endif
+#if !SDL_TIMERS_DISABLED
+	if ( (flags & SDL_initialized & SDL_INIT_TIMER) ) {
+		SDL_TimerQuit();
+		SDL_initialized &= ~SDL_INIT_TIMER;
+	}
+#endif
+#if !SDL_AUDIO_DISABLED
+	if ( (flags & SDL_initialized & SDL_INIT_AUDIO) ) {
+		SDL_AudioQuit();
+		SDL_initialized &= ~SDL_INIT_AUDIO;
+	}
+#endif
+#if !SDL_VIDEO_DISABLED
+	if ( (flags & SDL_initialized & SDL_INIT_VIDEO) ) {
+		SDL_VideoQuit();
+		SDL_initialized &= ~SDL_INIT_VIDEO;
+	}
+#endif
+}
+
+Uint32 SDL_WasInit(Uint32 flags)
+{
+	if ( ! flags ) {
+		flags = SDL_INIT_EVERYTHING;
+	}
+	return (SDL_initialized&flags);
+}
+
+void SDL_Quit(void)
+{
+	/* Quit all subsystems */
+#ifdef DEBUG_BUILD
+  printf("[SDL_Quit] : Enter! Calling QuitSubSystem()\n"); fflush(stdout);
+#endif
+	SDL_QuitSubSystem(SDL_INIT_EVERYTHING);
+
+#ifdef CHECK_LEAKS
+#ifdef DEBUG_BUILD
+  printf("[SDL_Quit] : CHECK_LEAKS\n"); fflush(stdout);
+#endif
+
+	/* Print the number of surfaces not freed */
+	if ( surfaces_allocated != 0 ) {
+		fprintf(stderr, "SDL Warning: %d SDL surfaces extant\n", 
+							surfaces_allocated);
+	}
+#endif
+#ifdef DEBUG_BUILD
+  printf("[SDL_Quit] : SDL_UninstallParachute()\n"); fflush(stdout);
+#endif
+
+	/* Uninstall any parachute signal handlers */
+	SDL_UninstallParachute();
+
+#if !SDL_THREADS_DISABLED && SDL_THREAD_PTH
+	pth_kill();
+#endif
+#ifdef DEBUG_BUILD
+  printf("[SDL_Quit] : Returning!\n"); fflush(stdout);
+#endif
+
+}
+
+/* Return the library version number */
+const SDL_version * SDL_Linked_Version(void)
+{
+	return(&version);
+}
+
+#if defined(__OS2__)
+/* Building for OS/2 */
+#ifdef __WATCOMC__
+
+#define INCL_DOSERRORS
+#define INCL_DOSEXCEPTIONS
+#include <os2.h>
+
+/* Exception handler to prevent the Audio thread hanging, making a zombie process! */
+ULONG _System SDL_Main_ExceptionHandler(PEXCEPTIONREPORTRECORD pERepRec,
+                                        PEXCEPTIONREGISTRATIONRECORD pERegRec,
+                                        PCONTEXTRECORD pCtxRec,
+                                        PVOID p)
+{
+  if (pERepRec->fHandlerFlags & EH_EXIT_UNWIND)
+    return XCPT_CONTINUE_SEARCH;
+  if (pERepRec->fHandlerFlags & EH_UNWINDING)
+    return XCPT_CONTINUE_SEARCH;
+  if (pERepRec->fHandlerFlags & EH_NESTED_CALL)
+    return XCPT_CONTINUE_SEARCH;
+
+  /* Do cleanup at every fatal exception! */
+  if (((pERepRec->ExceptionNum & XCPT_SEVERITY_CODE) == XCPT_FATAL_EXCEPTION) &&
+      (pERepRec->ExceptionNum != XCPT_BREAKPOINT) &&
+      (pERepRec->ExceptionNum != XCPT_SINGLE_STEP)
+     )
+  {
+    if (SDL_initialized & SDL_INIT_AUDIO)
+    {
+      /* This removes the zombie audio thread in case of emergency. */
+#ifdef DEBUG_BUILD
+      printf("[SDL_Main_ExceptionHandler] : Calling SDL_CloseAudio()!\n");
+#endif
+      SDL_CloseAudio();
+    }
+  }
+  return (XCPT_CONTINUE_SEARCH);
+}
+
+
+EXCEPTIONREGISTRATIONRECORD SDL_Main_xcpthand = {0, SDL_Main_ExceptionHandler};
+
+/* The main DLL entry for DLL Initialization and Uninitialization: */
+unsigned _System LibMain(unsigned hmod, unsigned termination)
+{
+  if (termination)
+  {
+#ifdef DEBUG_BUILD
+/*    printf("[SDL DLL Unintialization] : Removing exception handler\n"); */
+#endif
+    DosUnsetExceptionHandler(&SDL_Main_xcpthand);
+    return 1;
+  } else
+  {
+#ifdef DEBUG_BUILD
+    /* Make stdout and stderr unbuffered! */
+    setbuf(stdout, NULL);
+    setbuf(stderr, NULL);
+#endif
+    /* Fire up exception handler */
+#ifdef DEBUG_BUILD
+/*    printf("[SDL DLL Initialization] : Setting exception handler\n"); */
+#endif
+    /* Set exception handler */
+    DosSetExceptionHandler(&SDL_Main_xcpthand);
+
+    return 1;
+  }
+}
+#endif /* __WATCOMC__ */
+
+#elif defined(__WIN32__)
+
+#if !defined(HAVE_LIBC) || (defined(__WATCOMC__) && defined(BUILD_DLL))
+/* Need to include DllMain() on Watcom C for some reason.. */
+#define WIN32_LEAN_AND_MEAN
+#include <windows.h>
+
+BOOL APIENTRY _DllMainCRTStartup( HANDLE hModule, 
+                       DWORD  ul_reason_for_call, 
+                       LPVOID lpReserved )
+{
+	switch (ul_reason_for_call) {
+		case DLL_PROCESS_ATTACH:
+		case DLL_THREAD_ATTACH:
+		case DLL_THREAD_DETACH:
+		case DLL_PROCESS_DETACH:
+			break;
+	}
+	return TRUE;
+}
+#endif /* building DLL with Watcom C */
+
+#endif /* OS/2 elif __WIN32__ */

src/dep/src/SDL/SDL_error.c

@@ -0,0 +1,238 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2006 Sam Lantinga
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+    Sam Lantinga
+    slouken@libsdl.org
+*/
+#include "SDL_config.h"
+
+/* Simple error handling in SDL */
+
+#include "SDL_error.h"
+#include "SDL_error_c.h"
+
+/* Routine to get the thread-specific error variable */
+#if SDL_THREADS_DISABLED
+/* The  SDL_arraysize(The ),default (non-thread-safe) global error variable */
+static SDL_error SDL_global_error;
+#define SDL_GetErrBuf()	(&SDL_global_error)
+#else
+extern SDL_error *SDL_GetErrBuf(void);
+#endif /* SDL_THREADS_DISABLED */
+
+#define SDL_ERRBUFIZE	1024
+
+/* Private functions */
+
+static const char *SDL_LookupString(const char *key)
+{
+	/* FIXME: Add code to lookup key in language string hash-table */
+	return key;
+}
+
+/* Public functions */
+
+void SDL_SetError (const char *fmt, ...)
+{
+	va_list ap;
+	SDL_error *error;
+
+	/* Copy in the key, mark error as valid */
+	error = SDL_GetErrBuf();
+	error->error = 1;
+	SDL_strlcpy((char *)error->key, fmt, sizeof(error->key));
+
+	va_start(ap, fmt);
+	error->argc = 0;
+	while ( *fmt ) {
+		if ( *fmt++ == '%' ) {
+			while ( *fmt == '.' || (*fmt >= '0' && *fmt <= '9') ) {
+				++fmt;
+			}
+			switch (*fmt++) {
+			    case 0:  /* Malformed format string.. */
+				--fmt;
+				break;
+			    case 'c':
+			    case 'i':
+			    case 'd':
+			    case 'u':
+			    case 'o':
+			    case 'x':
+			    case 'X':
+				error->args[error->argc++].value_i =
+							va_arg(ap, int);
+				break;
+			    case 'f':
+				error->args[error->argc++].value_f =
+							va_arg(ap, double);
+				break;
+			    case 'p':
+				error->args[error->argc++].value_ptr =
+							va_arg(ap, void *);
+				break;
+			    case 's':
+				{
+				  int i = error->argc;
+				  const char *str = va_arg(ap, const char *);
+				  if (str == NULL)
+				      str = "(null)";
+				  SDL_strlcpy((char *)error->args[i].buf, str, ERR_MAX_STRLEN);
+				  error->argc++;
+				}
+				break;
+			    default:
+				break;
+			}
+			if ( error->argc >= ERR_MAX_ARGS ) {
+				break;
+			}
+		}
+	}
+	va_end(ap);
+
+	/* If we are in debug mode, print out an error message */
+#ifdef DEBUG_ERROR
+	fprintf(stderr, "SDL_SetError: %s\n", SDL_GetError());
+#endif
+}
+
+/* This function has a bit more overhead than most error functions
+   so that it supports internationalization and thread-safe errors.
+*/
+char *SDL_GetErrorMsg(char *errstr, unsigned int maxlen)
+{
+	SDL_error *error;
+
+	/* Clear the error string */
+	*errstr = '\0'; --maxlen;
+
+	/* Get the thread-safe error, and print it out */
+	error = SDL_GetErrBuf();
+	if ( error->error ) {
+		const char *fmt;
+		char *msg = errstr;
+		int len;
+		int argi;
+
+		fmt = SDL_LookupString(error->key);
+		argi = 0;
+		while ( *fmt && (maxlen > 0) ) {
+			if ( *fmt == '%' ) {
+				char tmp[32], *spot = tmp;
+				*spot++ = *fmt++;
+				while ( (*fmt == '.' || (*fmt >= '0' && *fmt <= '9')) && spot < (tmp+SDL_arraysize(tmp)-2) ) {
+					*spot++ = *fmt++;
+				}
+				*spot++ = *fmt++;
+				*spot++ = '\0';
+				switch (spot[-2]) {
+				    case '%':
+					*msg++ = '%';
+					maxlen -= 1;
+					break;
+				    case 'c':
+				    case 'i':
+			            case 'd':
+			            case 'u':
+			            case 'o':
+				    case 'x':
+				    case 'X':
+					len = SDL_snprintf(msg, maxlen, tmp, error->args[argi++].value_i);
+					msg += len;
+					maxlen -= len;
+					break;
+				    case 'f':
+					len = SDL_snprintf(msg, maxlen, tmp, error->args[argi++].value_f);
+					msg += len;
+					maxlen -= len;
+					break;
+				    case 'p':
+					len = SDL_snprintf(msg, maxlen, tmp, error->args[argi++].value_ptr);
+					msg += len;
+					maxlen -= len;
+					break;
+				    case 's':
+					len = SDL_snprintf(msg, maxlen, tmp, SDL_LookupString(error->args[argi++].buf));
+					msg += len;
+					maxlen -= len;
+					break;
+				}
+			} else {
+				*msg++ = *fmt++;
+				maxlen -= 1;
+			}
+		}
+		*msg = 0;	/* NULL terminate the string */
+	}
+	return(errstr);
+}
+
+/* Available for backwards compatibility */
+char *SDL_GetError (void)
+{
+	static char errmsg[SDL_ERRBUFIZE];
+
+	return((char *)SDL_GetErrorMsg(errmsg, SDL_ERRBUFIZE));
+}
+
+void SDL_ClearError(void)
+{
+	SDL_error *error;
+
+	error = SDL_GetErrBuf();
+	error->error = 0;
+}
+
+/* Very common errors go here */
+void SDL_Error(SDL_errorcode code)
+{
+	switch (code) {
+		case SDL_ENOMEM:
+			SDL_SetError("Out of memory");
+			break;
+		case SDL_EFREAD:
+			SDL_SetError("Error reading from datastream");
+			break;
+		case SDL_EFWRITE:
+			SDL_SetError("Error writing to datastream");
+			break;
+		case SDL_EFSEEK:
+			SDL_SetError("Error seeking in datastream");
+			break;
+		default:
+			SDL_SetError("Unknown SDL error");
+			break;
+	}
+}
+
+#ifdef TEST_ERROR
+int main(int argc, char *argv[])
+{
+	char buffer[BUFSIZ+1];
+
+	SDL_SetError("Hi there!");
+	printf("Error 1: %s\n", SDL_GetError());
+	SDL_ClearError();
+	SDL_memset(buffer, '1', BUFSIZ);
+	buffer[BUFSIZ] = 0;
+	SDL_SetError("This is the error: %s (%f)", buffer, 1.0);
+	printf("Error 2: %s\n", SDL_GetError());
+	exit(0);
+}
+#endif

src/dep/src/SDL/SDL_error_c.h

@@ -0,0 +1,58 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2006 Sam Lantinga
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+    Sam Lantinga
+    slouken@libsdl.org
+*/
+#include "SDL_config.h"
+
+/* This file defines a structure that carries language-independent
+   error messages
+*/
+
+#ifndef _SDL_error_c_h
+#define _SDL_error_c_h
+
+#define ERR_MAX_STRLEN	128
+#define ERR_MAX_ARGS	5
+
+typedef struct SDL_error {
+	/* This is a numeric value corresponding to the current error */
+	int error;
+
+	/* This is a key used to index into a language hashtable containing
+	   internationalized versions of the SDL error messages.  If the key
+	   is not in the hashtable, or no hashtable is available, the key is
+	   used directly as an error message format string.
+	*/
+	char key[ERR_MAX_STRLEN];
+
+	/* These are the arguments for the error functions */
+	int argc;
+	union {
+		void *value_ptr;
+#if 0	/* What is a character anyway?  (UNICODE issues) */
+		unsigned char value_c;
+#endif
+		int value_i;
+		double value_f;
+		char buf[ERR_MAX_STRLEN];
+	} args[ERR_MAX_ARGS];
+} SDL_error;
+
+#endif /* _SDL_error_c_h */

src/dep/src/SDL/SDL_fatal.c

@@ -0,0 +1,134 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2006 Sam Lantinga
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+    Sam Lantinga
+    slouken@libsdl.org
+*/
+#include "SDL_config.h"
+
+/* General fatal signal handling code for SDL */
+
+#ifdef HAVE_SIGNAL_H
+
+#include <signal.h>
+
+#include "SDL.h"
+#include "SDL_fatal.h"
+
+/* This installs some signal handlers for the more common fatal signals,
+   so that if the programmer is lazy, the app doesn't die so horribly if
+   the program crashes.
+*/
+
+static void SDL_Parachute(int sig)
+{
+	signal(sig, SIG_DFL);
+	SDL_Quit();
+	raise(sig);
+}
+
+static int SDL_fatal_signals[] = {
+	SIGSEGV,
+#ifdef SIGBUS
+	SIGBUS,
+#endif
+#ifdef SIGFPE
+	SIGFPE,
+#endif
+#ifdef SIGQUIT
+	SIGQUIT,
+#endif
+	0
+};
+
+void SDL_InstallParachute(void)
+{
+	/* Set a handler for any fatal signal not already handled */
+	int i;
+#ifdef HAVE_SIGACTION
+	struct sigaction action;
+
+	for ( i=0; SDL_fatal_signals[i]; ++i ) {
+		sigaction(SDL_fatal_signals[i], NULL, &action);
+		if ( action.sa_handler == SIG_DFL ) {
+			action.sa_handler = SDL_Parachute;
+			sigaction(SDL_fatal_signals[i], &action, NULL);
+		}
+	}
+#ifdef SIGALRM
+	/* Set SIGALRM to be ignored -- necessary on Solaris */
+	sigaction(SIGALRM, NULL, &action);
+	if ( action.sa_handler == SIG_DFL ) {
+		action.sa_handler = SIG_IGN;
+		sigaction(SIGALRM, &action, NULL);
+	}
+#endif
+#else
+	void (*ohandler)(int);
+
+	for ( i=0; SDL_fatal_signals[i]; ++i ) {
+		ohandler = signal(SDL_fatal_signals[i], SDL_Parachute);
+		if ( ohandler != SIG_DFL ) {
+			signal(SDL_fatal_signals[i], ohandler);
+		}
+	}
+#endif /* HAVE_SIGACTION */
+	return;
+}
+
+void SDL_UninstallParachute(void)
+{
+	/* Remove a handler for any fatal signal handled */
+	int i;
+#ifdef HAVE_SIGACTION
+	struct sigaction action;
+
+	for ( i=0; SDL_fatal_signals[i]; ++i ) {
+		sigaction(SDL_fatal_signals[i], NULL, &action);
+		if ( action.sa_handler == SDL_Parachute ) {
+			action.sa_handler = SIG_DFL;
+			sigaction(SDL_fatal_signals[i], &action, NULL);
+		}
+	}
+#else
+	void (*ohandler)(int);
+
+	for ( i=0; SDL_fatal_signals[i]; ++i ) {
+		ohandler = signal(SDL_fatal_signals[i], SIG_DFL);
+		if ( ohandler != SDL_Parachute ) {
+			signal(SDL_fatal_signals[i], ohandler);
+		}
+	}
+#endif /* HAVE_SIGACTION */
+}
+
+#else
+
+/* No signals on this platform, nothing to do.. */
+
+void SDL_InstallParachute(void)
+{
+	return;
+}
+
+void SDL_UninstallParachute(void)
+{
+	return;
+}
+
+#endif /* HAVE_SIGNAL_H */

src/dep/src/SDL/SDL_fatal.h

@@ -0,0 +1,28 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2006 Sam Lantinga
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+    Sam Lantinga
+    slouken@libsdl.org
+*/
+#include "SDL_config.h"
+
+/* General fatal signal handling code for SDL */
+
+extern void SDL_InstallParachute(void);
+extern void SDL_UninstallParachute(void);
+

src/dep/src/SDL/audio/SDL_audio.c

@@ -0,0 +1,761 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2006 Sam Lantinga
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+    Sam Lantinga
+    slouken@libsdl.org
+*/
+#include "SDL_config.h"
+
+/* Allow access to a raw mixing buffer */
+
+#include "SDL.h"
+#include "SDL_audio_c.h"
+#include "SDL_audiomem.h"
+#include "SDL_sysaudio.h"
+
+#ifdef __OS2__
+/* We'll need the DosSetPriority() API! */
+#define INCL_DOSPROCESS
+#include <os2.h>
+#endif
+
+/* Available audio drivers */
+static AudioBootStrap *bootstrap[] = {
+#if SDL_AUDIO_DRIVER_BSD
+	&BSD_AUDIO_bootstrap,
+#endif
+#if SDL_AUDIO_DRIVER_OSS
+	&DSP_bootstrap,
+	&DMA_bootstrap,
+#endif
+#if SDL_AUDIO_DRIVER_ALSA
+	&ALSA_bootstrap,
+#endif
+#if SDL_AUDIO_DRIVER_QNXNTO
+	&QNXNTOAUDIO_bootstrap,
+#endif
+#if SDL_AUDIO_DRIVER_SUNAUDIO
+	&SUNAUDIO_bootstrap,
+#endif
+#if SDL_AUDIO_DRIVER_DMEDIA
+	&DMEDIA_bootstrap,
+#endif
+#if SDL_AUDIO_DRIVER_ARTS
+	&ARTS_bootstrap,
+#endif
+#if SDL_AUDIO_DRIVER_ESD
+	&ESD_bootstrap,
+#endif
+#if SDL_AUDIO_DRIVER_NAS
+	&NAS_bootstrap,
+#endif
+#if SDL_AUDIO_DRIVER_DSOUND
+	&DSOUND_bootstrap,
+#endif
+#if SDL_AUDIO_DRIVER_WAVEOUT
+	&WAVEOUT_bootstrap,
+#endif
+#if SDL_AUDIO_DRIVER_PAUD
+	&Paud_bootstrap,
+#endif
+#if SDL_AUDIO_DRIVER_BAUDIO
+	&BAUDIO_bootstrap,
+#endif
+#if SDL_AUDIO_DRIVER_COREAUDIO
+	&COREAUDIO_bootstrap,
+#endif
+#if SDL_AUDIO_DRIVER_SNDMGR
+	&SNDMGR_bootstrap,
+#endif
+#if SDL_AUDIO_DRIVER_AHI
+	&AHI_bootstrap,
+#endif
+#if SDL_AUDIO_DRIVER_MINT
+	&MINTAUDIO_GSXB_bootstrap,
+	&MINTAUDIO_MCSN_bootstrap,
+	&MINTAUDIO_STFA_bootstrap,
+	&MINTAUDIO_XBIOS_bootstrap,
+	&MINTAUDIO_DMA8_bootstrap,
+#endif
+#if SDL_AUDIO_DRIVER_DISK
+	&DISKAUD_bootstrap,
+#endif
+#if SDL_AUDIO_DRIVER_DUMMY
+	&DUMMYAUD_bootstrap,
+#endif
+#if SDL_AUDIO_DRIVER_DC
+	&DCAUD_bootstrap,
+#endif
+#if SDL_AUDIO_DRIVER_MMEAUDIO
+	&MMEAUDIO_bootstrap,
+#endif
+#if SDL_AUDIO_DRIVER_DART
+	&DART_bootstrap,
+#endif
+	NULL
+};
+SDL_AudioDevice *current_audio = NULL;
+
+/* Various local functions */
+int SDL_AudioInit(const char *driver_name);
+void SDL_AudioQuit(void);
+
+#if SDL_AUDIO_DRIVER_AHI
+static int audio_configured = 0;
+#endif
+
+/* The general mixing thread function */
+int SDLCALL SDL_RunAudio(void *audiop)
+{
+	SDL_AudioDevice *audio = (SDL_AudioDevice *)audiop;
+	Uint8 *stream;
+	int    stream_len;
+	void  *udata;
+	void (SDLCALL *fill)(void *userdata,Uint8 *stream, int len);
+	int    silence;
+#if SDL_AUDIO_DRIVER_AHI
+	int started = 0;
+
+/* AmigaOS NEEDS that the audio driver is opened in the thread that uses it! */
+
+	D(bug("Task audio started audio struct:<%lx>...\n",audiop));
+
+	D(bug("Before Openaudio..."));
+	if(audio->OpenAudio(audio, &audio->spec)==-1)
+	{
+		D(bug("Open audio failed...\n"));
+		return(-1);
+	}
+	D(bug("OpenAudio...OK\n"));
+#endif
+
+	/* Perform any thread setup */
+	if ( audio->ThreadInit ) {
+		audio->ThreadInit(audio);
+	}
+	audio->threadid = SDL_ThreadID();
+
+	/* Set up the mixing function */
+	fill  = audio->spec.callback;
+	udata = audio->spec.userdata;
+
+#if SDL_AUDIO_DRIVER_AHI
+	audio_configured = 1;
+
+	D(bug("Audio configured... Checking for conversion\n"));
+	SDL_mutexP(audio->mixer_lock);
+	D(bug("Semaphore obtained...\n"));
+#endif
+
+	if ( audio->convert.needed ) {
+		if ( audio->convert.src_format == AUDIO_U8 ) {
+			silence = 0x80;
+		} else {
+			silence = 0;
+		}
+		stream_len = audio->convert.len;
+	} else {
+		silence = audio->spec.silence;
+		stream_len = audio->spec.size;
+	}
+
+#if SDL_AUDIO_DRIVER_AHI
+	SDL_mutexV(audio->mixer_lock);
+	D(bug("Entering audio loop...\n"));
+#endif
+
+#ifdef __OS2__
+        /* Increase the priority of this thread to make sure that
+           the audio will be continuous all the time! */
+#ifdef USE_DOSSETPRIORITY
+        if (SDL_getenv("SDL_USE_TIMECRITICAL_AUDIO"))
+        {
+#ifdef DEBUG_BUILD
+          printf("[SDL_RunAudio] : Setting priority to TimeCritical+0! (TID%d)\n", SDL_ThreadID());
+#endif
+          DosSetPriority(PRTYS_THREAD, PRTYC_TIMECRITICAL, 0, 0);
+        }
+        else
+        {
+#ifdef DEBUG_BUILD
+          printf("[SDL_RunAudio] : Setting priority to ForegroundServer+0! (TID%d)\n", SDL_ThreadID());
+#endif
+          DosSetPriority(PRTYS_THREAD, PRTYC_FOREGROUNDSERVER, 0, 0);
+        }
+#endif
+#endif
+
+	/* Loop, filling the audio buffers */
+	while ( audio->enabled ) {
+
+		/* Fill the current buffer with sound */
+		if ( audio->convert.needed ) {
+			if ( audio->convert.buf ) {
+				stream = audio->convert.buf;
+			} else {
+				continue;
+			}
+		} else {
+			stream = audio->GetAudioBuf(audio);
+			if ( stream == NULL ) {
+				stream = audio->fake_stream;
+			}
+		}
+		SDL_memset(stream, silence, stream_len);
+
+		if ( ! audio->paused ) {
+			SDL_mutexP(audio->mixer_lock);
+			(*fill)(udata, stream, stream_len);
+			SDL_mutexV(audio->mixer_lock);
+		}
+
+		/* Convert the audio if necessary */
+		if ( audio->convert.needed ) {
+			SDL_ConvertAudio(&audio->convert);
+			stream = audio->GetAudioBuf(audio);
+			if ( stream == NULL ) {
+				stream = audio->fake_stream;
+			}
+			SDL_memcpy(stream, audio->convert.buf,
+			               audio->convert.len_cvt);
+		}
+
+		/* Ready current buffer for play and change current buffer */
+		if ( stream != audio->fake_stream ) {
+			audio->PlayAudio(audio);
+		}
+
+		/* Wait for an audio buffer to become available */
+		if ( stream == audio->fake_stream ) {
+			SDL_Delay((audio->spec.samples*1000)/audio->spec.freq);
+		} else {
+			audio->WaitAudio(audio);
+		}
+	}
+
+	/* Wait for the audio to drain.. */
+	if ( audio->WaitDone ) {
+		audio->WaitDone(audio);
+	}
+
+#if SDL_AUDIO_DRIVER_AHI
+	D(bug("WaitAudio...Done\n"));
+
+	audio->CloseAudio(audio);
+
+	D(bug("CloseAudio..Done, subtask exiting...\n"));
+	audio_configured = 0;
+#endif
+#ifdef __OS2__
+#ifdef DEBUG_BUILD
+        printf("[SDL_RunAudio] : Task exiting. (TID%d)\n", SDL_ThreadID());
+#endif
+#endif
+	return(0);
+}
+
+static void SDL_LockAudio_Default(SDL_AudioDevice *audio)
+{
+	if ( audio->thread && (SDL_ThreadID() == audio->threadid) ) {
+		return;
+	}
+	SDL_mutexP(audio->mixer_lock);
+}
+
+static void SDL_UnlockAudio_Default(SDL_AudioDevice *audio)
+{
+	if ( audio->thread && (SDL_ThreadID() == audio->threadid) ) {
+		return;
+	}
+	SDL_mutexV(audio->mixer_lock);
+}
+
+static Uint16 SDL_ParseAudioFormat(const char *string)
+{
+	Uint16 format = 0;
+
+	switch (*string) {
+	    case 'U':
+		++string;
+		format |= 0x0000;
+		break;
+	    case 'S':
+		++string;
+		format |= 0x8000;
+		break;
+	    default:
+		return 0;
+	}
+	switch (SDL_atoi(string)) {
+	    case 8:
+		string += 1;
+		format |= 8;
+		break;
+	    case 16:
+		string += 2;
+		format |= 16;
+		if ( SDL_strcmp(string, "LSB") == 0
+#if SDL_BYTEORDER == SDL_LIL_ENDIAN
+		     || SDL_strcmp(string, "SYS") == 0
+#endif
+		    ) {
+			format |= 0x0000;
+		}
+		if ( SDL_strcmp(string, "MSB") == 0
+#if SDL_BYTEORDER == SDL_BIG_ENDIAN
+		     || SDL_strcmp(string, "SYS") == 0
+#endif
+		    ) {
+			format |= 0x1000;
+		}
+		break;
+	    default:
+		return 0;
+	}
+	return format;
+}
+
+int SDL_AudioInit(const char *driver_name)
+{
+	SDL_AudioDevice *audio;
+	int i = 0, idx;
+
+	/* Check to make sure we don't overwrite 'current_audio' */
+	if ( current_audio != NULL ) {
+		SDL_AudioQuit();
+	}
+
+	/* Select the proper audio driver */
+	audio = NULL;
+	idx = 0;
+#if SDL_AUDIO_DRIVER_ESD
+	if ( (driver_name == NULL) && (SDL_getenv("ESPEAKER") != NULL) ) {
+		/* Ahem, we know that if ESPEAKER is set, user probably wants
+		   to use ESD, but don't start it if it's not already running.
+		   This probably isn't the place to do this, but... Shh! :)
+		 */
+		for ( i=0; bootstrap[i]; ++i ) {
+			if ( SDL_strcmp(bootstrap[i]->name, "esd") == 0 ) {
+#ifdef HAVE_PUTENV
+				const char *esd_no_spawn;
+
+				/* Don't start ESD if it's not running */
+				esd_no_spawn = getenv("ESD_NO_SPAWN");
+				if ( esd_no_spawn == NULL ) {
+					putenv("ESD_NO_SPAWN=1");
+				}
+#endif
+				if ( bootstrap[i]->available() ) {
+					audio = bootstrap[i]->create(0);
+					break;
+				}
+#ifdef HAVE_UNSETENV
+				if ( esd_no_spawn == NULL ) {
+					unsetenv("ESD_NO_SPAWN");
+				}
+#endif
+			}
+		}
+	}
+#endif /* SDL_AUDIO_DRIVER_ESD */
+	if ( audio == NULL ) {
+		if ( driver_name != NULL ) {
+#if 0	/* This will be replaced with a better driver selection API */
+			if ( SDL_strrchr(driver_name, ':') != NULL ) {
+				idx = atoi(SDL_strrchr(driver_name, ':')+1);
+			}
+#endif
+			for ( i=0; bootstrap[i]; ++i ) {
+				if (SDL_strncmp(bootstrap[i]->name, driver_name,
+				            SDL_strlen(bootstrap[i]->name)) == 0) {
+					if ( bootstrap[i]->available() ) {
+						audio=bootstrap[i]->create(idx);
+						break;
+					}
+				}
+			}
+		} else {
+			for ( i=0; bootstrap[i]; ++i ) {
+				if ( bootstrap[i]->available() ) {
+					audio = bootstrap[i]->create(idx);
+					if ( audio != NULL ) {
+						break;
+					}
+				}
+			}
+		}
+		if ( audio == NULL ) {
+			SDL_SetError("No available audio device");
+#if 0 /* Don't fail SDL_Init() if audio isn't available.
+         SDL_OpenAudio() will handle it at that point.  *sigh*
+       */
+			return(-1);
+#endif
+		}
+	}
+	current_audio = audio;
+	if ( current_audio ) {
+		current_audio->name = bootstrap[i]->name;
+		if ( !current_audio->LockAudio && !current_audio->UnlockAudio ) {
+			current_audio->LockAudio = SDL_LockAudio_Default;
+			current_audio->UnlockAudio = SDL_UnlockAudio_Default;
+		}
+	}
+	return(0);
+}
+
+char *SDL_AudioDriverName(char *namebuf, int maxlen)
+{
+	if ( current_audio != NULL ) {
+		SDL_strlcpy(namebuf, current_audio->name, maxlen);
+		return(namebuf);
+	}
+	return(NULL);
+}
+
+int SDL_OpenAudio(SDL_AudioSpec *desired, SDL_AudioSpec *obtained)
+{
+	SDL_AudioDevice *audio;
+	const char *env;
+
+	/* Start up the audio driver, if necessary */
+	if ( ! current_audio ) {
+		if ( (SDL_InitSubSystem(SDL_INIT_AUDIO) < 0) ||
+		     (current_audio == NULL) ) {
+			return(-1);
+		}
+	}
+	audio = current_audio;
+
+	if (audio->opened) {
+		SDL_SetError("Audio device is already opened");
+		return(-1);
+	}
+
+	/* Verify some parameters */
+	if ( desired->freq == 0 ) {
+		env = SDL_getenv("SDL_AUDIO_FREQUENCY");
+		if ( env ) {
+			desired->freq = SDL_atoi(env);
+		}
+	}
+	if ( desired->freq == 0 ) {
+		/* Pick some default audio frequency */
+		desired->freq = 22050;
+	}
+	if ( desired->format == 0 ) {
+		env = SDL_getenv("SDL_AUDIO_FORMAT");
+		if ( env ) {
+			desired->format = SDL_ParseAudioFormat(env);
+		}
+	}
+	if ( desired->format == 0 ) {
+		/* Pick some default audio format */
+		desired->format = AUDIO_S16;
+	}
+	if ( desired->channels == 0 ) {
+		env = SDL_getenv("SDL_AUDIO_CHANNELS");
+		if ( env ) {
+			desired->channels = SDL_atoi(env);
+		}
+	}
+	if ( desired->channels == 0 ) {
+		/* Pick a default number of channels */
+		desired->channels = 2;
+	}
+	switch ( desired->channels ) {
+	    case 1:	/* Mono */
+	    case 2:	/* Stereo */
+	    case 4:	/* surround */
+	    case 6:	/* surround with center and lfe */
+		break;
+	    default:
+		SDL_SetError("1 (mono) and 2 (stereo) channels supported");
+		return(-1);
+	}
+	if ( desired->samples == 0 ) {
+		env = SDL_getenv("SDL_AUDIO_SAMPLES");
+		if ( env ) {
+			desired->samples = SDL_atoi(env);
+		}
+	}
+	if ( desired->samples == 0 ) {
+		/* Pick a default of ~46 ms at desired frequency */
+		int samples = (desired->freq / 1000) * 46;
+		int power2 = 1;
+		while ( power2 < samples ) {
+			power2 *= 2;
+		}
+		desired->samples = power2;
+	}
+	if ( desired->callback == NULL ) {
+		SDL_SetError("SDL_OpenAudio() passed a NULL callback");
+		return(-1);
+	}
+
+#if defined(__MACOS__) || (defined(__RISCOS__) && SDL_THREADS_DISABLED)
+	/* FIXME: Need to implement PPC interrupt asm for SDL_LockAudio() */
+#else
+#if defined(__MINT__) && SDL_THREADS_DISABLED
+	/* Uses interrupt driven audio, without thread */
+#else
+	/* Create a semaphore for locking the sound buffers */
+	audio->mixer_lock = SDL_CreateMutex();
+	if ( audio->mixer_lock == NULL ) {
+		SDL_SetError("Couldn't create mixer lock");
+		SDL_CloseAudio();
+		return(-1);
+	}
+#endif /* __MINT__ */
+#endif /* __MACOS__ */
+
+	/* Calculate the silence and size of the audio specification */
+	SDL_CalculateAudioSpec(desired);
+
+	/* Open the audio subsystem */
+	SDL_memcpy(&audio->spec, desired, sizeof(audio->spec));
+	audio->convert.needed = 0;
+	audio->enabled = 1;
+	audio->paused  = 1;
+
+#if !SDL_AUDIO_DRIVER_AHI
+
+/* AmigaOS opens audio inside the main loop */
+	audio->opened = audio->OpenAudio(audio, &audio->spec)+1;
+
+	if ( ! audio->opened ) {
+		SDL_CloseAudio();
+		return(-1);
+	}
+#else
+	D(bug("Locking semaphore..."));
+	SDL_mutexP(audio->mixer_lock);
+
+
+	audio->thread = SDL_CreateThread(SDL_RunAudio, audio);
+	D(bug("Created thread...\n"));
+
+	if ( audio->thread == NULL ) {
+		SDL_mutexV(audio->mixer_lock);
+		SDL_CloseAudio();
+		SDL_SetError("Couldn't create audio thread");
+		return(-1);
+	}
+
+	while(!audio_configured)
+		SDL_Delay(100);
+#endif
+
+	/* If the audio driver changes the buffer size, accept it */
+	if ( audio->spec.samples != desired->samples ) {
+		desired->samples = audio->spec.samples;
+		SDL_CalculateAudioSpec(desired);
+	}
+
+	/* Allocate a fake audio memory buffer */
+	audio->fake_stream = SDL_AllocAudioMem(audio->spec.size);
+	if ( audio->fake_stream == NULL ) {
+		SDL_CloseAudio();
+		SDL_OutOfMemory();
+		return(-1);
+	}
+
+	/* See if we need to do any conversion */
+	if ( obtained != NULL ) {
+		SDL_memcpy(obtained, &audio->spec, sizeof(audio->spec));
+	} else if ( desired->freq != audio->spec.freq ||
+                    desired->format != audio->spec.format ||
+	            desired->channels != audio->spec.channels ) {
+		/* Build an audio conversion block */
+		if ( SDL_BuildAudioCVT(&audio->convert,
+			desired->format, desired->channels,
+					desired->freq,
+			audio->spec.format, audio->spec.channels,
+					audio->spec.freq) < 0 ) {
+			SDL_CloseAudio();
+			return(-1);
+		}
+		if ( audio->convert.needed ) {
+			audio->convert.len = desired->size;
+			audio->convert.buf =(Uint8 *)SDL_AllocAudioMem(
+			   audio->convert.len*audio->convert.len_mult);
+			if ( audio->convert.buf == NULL ) {
+				SDL_CloseAudio();
+				SDL_OutOfMemory();
+				return(-1);
+			}
+		}
+	}
+
+#if !SDL_AUDIO_DRIVER_AHI
+	/* Start the audio thread if necessary */
+	switch (audio->opened) {
+		case  1:
+			/* Start the audio thread */
+#if (defined(__WIN32__) && !defined(_WIN32_WCE)) && !defined(HAVE_LIBC)
+#undef SDL_CreateThread
+			audio->thread = SDL_CreateThread(SDL_RunAudio, audio, NULL, NULL);
+#else
+			audio->thread = SDL_CreateThread(SDL_RunAudio, audio);
+#endif
+			if ( audio->thread == NULL ) {
+				SDL_CloseAudio();
+				SDL_SetError("Couldn't create audio thread");
+				return(-1);
+			}
+			break;
+
+		default:
+			/* The audio is now playing */
+			break;
+	}
+#else
+	SDL_mutexV(audio->mixer_lock);
+	D(bug("SDL_OpenAudio USCITA...\n"));
+
+#endif
+
+	return(0);
+}
+
+SDL_audiostatus SDL_GetAudioStatus(void)
+{
+	SDL_AudioDevice *audio = current_audio;
+	SDL_audiostatus status;
+
+	status = SDL_AUDIO_STOPPED;
+	if ( audio && audio->enabled ) {
+		if ( audio->paused ) {
+			status = SDL_AUDIO_PAUSED;
+		} else {
+			status = SDL_AUDIO_PLAYING;
+		}
+	}
+	return(status);
+}
+
+void SDL_PauseAudio (int pause_on)
+{
+	SDL_AudioDevice *audio = current_audio;
+
+	if ( audio ) {
+		audio->paused = pause_on;
+	}
+}
+
+void SDL_LockAudio (void)
+{
+	SDL_AudioDevice *audio = current_audio;
+
+	/* Obtain a lock on the mixing buffers */
+	if ( audio && audio->LockAudio ) {
+		audio->LockAudio(audio);
+	}
+}
+
+void SDL_UnlockAudio (void)
+{
+	SDL_AudioDevice *audio = current_audio;
+
+	/* Release lock on the mixing buffers */
+	if ( audio && audio->UnlockAudio ) {
+		audio->UnlockAudio(audio);
+	}
+}
+
+void SDL_CloseAudio (void)
+{
+	SDL_QuitSubSystem(SDL_INIT_AUDIO);
+}
+
+void SDL_AudioQuit(void)
+{
+	SDL_AudioDevice *audio = current_audio;
+
+	if ( audio ) {
+		audio->enabled = 0;
+		if ( audio->thread != NULL ) {
+			SDL_WaitThread(audio->thread, NULL);
+		}
+		if ( audio->mixer_lock != NULL ) {
+			SDL_DestroyMutex(audio->mixer_lock);
+		}
+		if ( audio->fake_stream != NULL ) {
+			SDL_FreeAudioMem(audio->fake_stream);
+		}
+		if ( audio->convert.needed ) {
+			SDL_FreeAudioMem(audio->convert.buf);
+
+		}
+#if !SDL_AUDIO_DRIVER_AHI
+		if ( audio->opened ) {
+			audio->CloseAudio(audio);
+			audio->opened = 0;
+		}
+#endif
+		/* Free the driver data */
+		audio->free(audio);
+		current_audio = NULL;
+	}
+}
+
+#define NUM_FORMATS	6
+static int format_idx;
+static int format_idx_sub;
+static Uint16 format_list[NUM_FORMATS][NUM_FORMATS] = {
+ { AUDIO_U8, AUDIO_S8, AUDIO_S16LSB, AUDIO_S16MSB, AUDIO_U16LSB, AUDIO_U16MSB },
+ { AUDIO_S8, AUDIO_U8, AUDIO_S16LSB, AUDIO_S16MSB, AUDIO_U16LSB, AUDIO_U16MSB },
+ { AUDIO_S16LSB, AUDIO_S16MSB, AUDIO_U16LSB, AUDIO_U16MSB, AUDIO_U8, AUDIO_S8 },
+ { AUDIO_S16MSB, AUDIO_S16LSB, AUDIO_U16MSB, AUDIO_U16LSB, AUDIO_U8, AUDIO_S8 },
+ { AUDIO_U16LSB, AUDIO_U16MSB, AUDIO_S16LSB, AUDIO_S16MSB, AUDIO_U8, AUDIO_S8 },
+ { AUDIO_U16MSB, AUDIO_U16LSB, AUDIO_S16MSB, AUDIO_S16LSB, AUDIO_U8, AUDIO_S8 },
+};
+
+Uint16 SDL_FirstAudioFormat(Uint16 format)
+{
+	for ( format_idx=0; format_idx < NUM_FORMATS; ++format_idx ) {
+		if ( format_list[format_idx][0] == format ) {
+			break;
+		}
+	}
+	format_idx_sub = 0;
+	return(SDL_NextAudioFormat());
+}
+
+Uint16 SDL_NextAudioFormat(void)
+{
+	if ( (format_idx == NUM_FORMATS) || (format_idx_sub == NUM_FORMATS) ) {
+		return(0);
+	}
+	return(format_list[format_idx][format_idx_sub++]);
+}
+
+void SDL_CalculateAudioSpec(SDL_AudioSpec *spec)
+{
+	switch (spec->format) {
+		case AUDIO_U8:
+			spec->silence = 0x80;
+			break;
+		default:
+			spec->silence = 0x00;
+			break;
+	}
+	spec->size = (spec->format&0xFF)/8;
+	spec->size *= spec->channels;
+	spec->size *= spec->samples;
+}

src/dep/src/SDL/audio/SDL_audio_c.h

@@ -0,0 +1,34 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2006 Sam Lantinga
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+    Sam Lantinga
+    slouken@libsdl.org
+*/
+#include "SDL_config.h"
+
+/* Functions and variables exported from SDL_audio.c for SDL_sysaudio.c */
+
+/* Functions to get a list of "close" audio formats */
+extern Uint16 SDL_FirstAudioFormat(Uint16 format);
+extern Uint16 SDL_NextAudioFormat(void);
+
+/* Function to calculate the size and silence for a SDL_AudioSpec */
+extern void SDL_CalculateAudioSpec(SDL_AudioSpec *spec);
+
+/* The actual mixing thread function */
+extern int SDLCALL SDL_RunAudio(void *audiop);

src/dep/src/SDL/audio/SDL_audiodev.c

@@ -0,0 +1,179 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2006 Sam Lantinga
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+    Sam Lantinga
+    slouken@libsdl.org
+*/
+#include "SDL_config.h"
+
+/* Get the name of the audio device we use for output */
+
+#if SDL_AUDIO_DRIVER_BSD || SDL_AUDIO_DRIVER_OSS || SDL_AUDIO_DRIVER_SUNAUDIO
+
+#include <fcntl.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+
+#include "SDL_stdinc.h"
+#include "SDL_audiodev_c.h"
+
+#ifndef _PATH_DEV_DSP
+#if defined(__NETBSD__) || defined(__OPENBSD__)
+#define _PATH_DEV_DSP  "/dev/audio"
+#else
+#define _PATH_DEV_DSP  "/dev/dsp"
+#endif
+#endif
+#ifndef _PATH_DEV_DSP24
+#define _PATH_DEV_DSP24	"/dev/sound/dsp"
+#endif
+#ifndef _PATH_DEV_AUDIO
+#define _PATH_DEV_AUDIO	"/dev/audio"
+#endif
+
+
+int SDL_OpenAudioPath(char *path, int maxlen, int flags, int classic)
+{
+	const char *audiodev;
+	int audio_fd;
+	char audiopath[1024];
+
+	/* Figure out what our audio device is */
+	if ( ((audiodev=SDL_getenv("SDL_PATH_DSP")) == NULL) &&
+	     ((audiodev=SDL_getenv("AUDIODEV")) == NULL) ) {
+		if ( classic ) {
+			audiodev = _PATH_DEV_AUDIO;
+		} else {
+			struct stat sb;
+
+			/* Added support for /dev/sound/\* in Linux 2.4 */
+			if ( ((stat("/dev/sound", &sb) == 0) && S_ISDIR(sb.st_mode)) &&
+				 ((stat(_PATH_DEV_DSP24, &sb) == 0) && S_ISCHR(sb.st_mode)) ) {
+				audiodev = _PATH_DEV_DSP24;
+			} else {
+				audiodev = _PATH_DEV_DSP;
+			}
+		}
+	}
+	audio_fd = open(audiodev, flags, 0);
+
+	/* If the first open fails, look for other devices */
+	if ( (audio_fd < 0) && (SDL_strlen(audiodev) < (sizeof(audiopath)-3)) ) {
+		int exists, instance;
+		struct stat sb;
+
+		instance = 1;
+		do { /* Don't use errno ENOENT - it may not be thread-safe */
+			SDL_snprintf(audiopath, SDL_arraysize(audiopath),
+			             "%s%d", audiodev, instance++);
+			exists = 0;
+			if ( stat(audiopath, &sb) == 0 ) {
+				exists = 1;
+				audio_fd = open(audiopath, flags, 0); 
+			}
+		} while ( exists && (audio_fd < 0) );
+		audiodev = audiopath;
+	}
+	if ( path != NULL ) {
+		SDL_strlcpy(path, audiodev, maxlen);
+		path[maxlen-1] = '\0';
+	}
+	return(audio_fd);
+}
+
+#elif SDL_AUDIO_DRIVER_PAUD
+
+/* Get the name of the audio device we use for output */
+
+#include <sys/types.h>
+#include <sys/stat.h>
+
+#include "SDL_stdinc.h"
+#include "SDL_audiodev_c.h"
+
+#ifndef _PATH_DEV_DSP
+#define _PATH_DEV_DSP	"/dev/%caud%c/%c"
+#endif
+
+char devsettings[][3] =
+{
+    { 'p', '0', '1' }, { 'p', '0', '2' }, { 'p', '0', '3' }, { 'p', '0', '4' },
+    { 'p', '1', '1' }, { 'p', '1', '2' }, { 'p', '1', '3' }, { 'p', '1', '4' },
+    { 'p', '2', '1' }, { 'p', '2', '2' }, { 'p', '2', '3' }, { 'p', '2', '4' },
+    { 'p', '3', '1' }, { 'p', '3', '2' }, { 'p', '3', '3' }, { 'p', '3', '4' },
+    { 'b', '0', '1' }, { 'b', '0', '2' }, { 'b', '0', '3' }, { 'b', '0', '4' },
+    { 'b', '1', '1' }, { 'b', '1', '2' }, { 'b', '1', '3' }, { 'b', '1', '4' },
+    { 'b', '2', '1' }, { 'b', '2', '2' }, { 'b', '2', '3' }, { 'b', '2', '4' },
+    { 'b', '3', '1' }, { 'b', '3', '2' }, { 'b', '3', '3' }, { 'b', '3', '4' },
+    { '\0', '\0', '\0' }
+};
+
+static int OpenUserDefinedDevice(char *path, int maxlen, int flags)
+{
+	const char *audiodev;
+	int  audio_fd;
+
+	/* Figure out what our audio device is */
+	if ((audiodev=SDL_getenv("SDL_PATH_DSP")) == NULL) {
+	    audiodev=SDL_getenv("AUDIODEV");
+	}
+	if ( audiodev == NULL ) {
+	    return -1;
+	}
+	audio_fd = open(audiodev, flags, 0);
+	if ( path != NULL ) {
+		SDL_strlcpy(path, audiodev, maxlen);
+		path[maxlen-1] = '\0';
+	}
+	return audio_fd;
+}
+
+int SDL_OpenAudioPath(char *path, int maxlen, int flags, int classic)
+{
+    struct stat sb;
+    int         audio_fd;
+    char        audiopath[1024];
+    int         cycle;
+
+    audio_fd = OpenUserDefinedDevice(path,maxlen,flags);
+    if ( audio_fd != -1 ) {
+        return audio_fd;
+    }
+
+    cycle    = 0;
+    while( devsettings[cycle][0] != '\0' ) {
+        SDL_snprintf( audiopath, SDL_arraysize(audiopath),
+                 _PATH_DEV_DSP,
+                 devsettings[cycle][0],
+                 devsettings[cycle][1],
+                 devsettings[cycle][2]);
+
+	if ( stat(audiopath, &sb) == 0 ) {
+	    audio_fd = open(audiopath, flags, 0);
+	    if ( audio_fd > 0 ) {
+		if ( path != NULL ) {
+		    SDL_strlcpy( path, audiopath, maxlen );
+		}
+	        return audio_fd;
+	    }
+	}
+    }
+    return -1;
+}
+
+#endif /* Audio driver selection */

src/dep/src/SDL/audio/SDL_audiodev_c.h

@@ -0,0 +1,26 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2006 Sam Lantinga
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+    Sam Lantinga
+    slouken@libsdl.org
+*/
+#include "SDL_config.h"
+
+/* Open the audio device, storing the pathname in 'path'  */
+extern int SDL_OpenAudioPath(char *path, int maxlen, int flags, int classic);
+

src/dep/src/SDL/audio/SDL_audiomem.h

@@ -0,0 +1,25 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2006 Sam Lantinga
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+    Sam Lantinga
+    slouken@libsdl.org
+*/
+#include "SDL_config.h"
+
+#define SDL_AllocAudioMem	SDL_malloc
+#define SDL_FreeAudioMem	SDL_free

src/dep/src/SDL/audio/SDL_mixer.c

@@ -0,0 +1,258 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2006 Sam Lantinga
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+    Sam Lantinga
+    slouken@libsdl.org
+*/
+#include "SDL_config.h"
+
+/* This provides the default mixing callback for the SDL audio routines */
+
+#include "SDL_cpuinfo.h"
+#include "SDL_timer.h"
+#include "SDL_audio.h"
+#include "SDL_sysaudio.h"
+#include "SDL_mixer_MMX.h"
+#include "SDL_mixer_MMX_VC.h"
+#include "SDL_mixer_m68k.h"
+
+/* This table is used to add two sound values together and pin
+ * the value to avoid overflow.  (used with permission from ARDI)
+ * Changed to use 0xFE instead of 0xFF for better sound quality.
+ */
+static const Uint8 mix8[] =
+{
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x03,
+  0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E,
+  0x0F, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19,
+  0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x1F, 0x20, 0x21, 0x22, 0x23, 0x24,
+  0x25, 0x26, 0x27, 0x28, 0x29, 0x2A, 0x2B, 0x2C, 0x2D, 0x2E, 0x2F,
+  0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3A,
+  0x3B, 0x3C, 0x3D, 0x3E, 0x3F, 0x40, 0x41, 0x42, 0x43, 0x44, 0x45,
+  0x46, 0x47, 0x48, 0x49, 0x4A, 0x4B, 0x4C, 0x4D, 0x4E, 0x4F, 0x50,
+  0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5A, 0x5B,
+  0x5C, 0x5D, 0x5E, 0x5F, 0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66,
+  0x67, 0x68, 0x69, 0x6A, 0x6B, 0x6C, 0x6D, 0x6E, 0x6F, 0x70, 0x71,
+  0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7A, 0x7B, 0x7C,
+  0x7D, 0x7E, 0x7F, 0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,
+  0x88, 0x89, 0x8A, 0x8B, 0x8C, 0x8D, 0x8E, 0x8F, 0x90, 0x91, 0x92,
+  0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99, 0x9A, 0x9B, 0x9C, 0x9D,
+  0x9E, 0x9F, 0xA0, 0xA1, 0xA2, 0xA3, 0xA4, 0xA5, 0xA6, 0xA7, 0xA8,
+  0xA9, 0xAA, 0xAB, 0xAC, 0xAD, 0xAE, 0xAF, 0xB0, 0xB1, 0xB2, 0xB3,
+  0xB4, 0xB5, 0xB6, 0xB7, 0xB8, 0xB9, 0xBA, 0xBB, 0xBC, 0xBD, 0xBE,
+  0xBF, 0xC0, 0xC1, 0xC2, 0xC3, 0xC4, 0xC5, 0xC6, 0xC7, 0xC8, 0xC9,
+  0xCA, 0xCB, 0xCC, 0xCD, 0xCE, 0xCF, 0xD0, 0xD1, 0xD2, 0xD3, 0xD4,
+  0xD5, 0xD6, 0xD7, 0xD8, 0xD9, 0xDA, 0xDB, 0xDC, 0xDD, 0xDE, 0xDF,
+  0xE0, 0xE1, 0xE2, 0xE3, 0xE4, 0xE5, 0xE6, 0xE7, 0xE8, 0xE9, 0xEA,
+  0xEB, 0xEC, 0xED, 0xEE, 0xEF, 0xF0, 0xF1, 0xF2, 0xF3, 0xF4, 0xF5,
+  0xF6, 0xF7, 0xF8, 0xF9, 0xFA, 0xFB, 0xFC, 0xFD, 0xFE, 0xFE, 0xFE,
+  0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE,
+  0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE,
+  0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE,
+  0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE,
+  0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE,
+  0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE,
+  0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE,
+  0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE,
+  0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE,
+  0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE,
+  0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE,
+  0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE
+};
+
+/* The volume ranges from 0 - 128 */
+#define ADJUST_VOLUME(s, v)	(s = (s*v)/SDL_MIX_MAXVOLUME)
+#define ADJUST_VOLUME_U8(s, v)	(s = (((s-128)*v)/SDL_MIX_MAXVOLUME)+128)
+
+void SDL_MixAudio (Uint8 *dst, const Uint8 *src, Uint32 len, int volume)
+{
+	Uint16 format;
+
+	if ( volume == 0 ) {
+		return;
+	}
+	/* Mix the user-level audio format */
+	if ( current_audio ) {
+		if ( current_audio->convert.needed ) {
+			format = current_audio->convert.src_format;
+		} else {
+			format = current_audio->spec.format;
+		}
+	} else {
+  		/* HACK HACK HACK */
+		format = AUDIO_S16;
+	}
+	switch (format) {
+
+		case AUDIO_U8: {
+#if defined(__GNUC__) && defined(__M68000__) && defined(SDL_ASSEMBLY_ROUTINES)
+			SDL_MixAudio_m68k_U8((char*)dst,(char*)src,(unsigned long)len,(long)volume,(char *)mix8);
+#else
+			Uint8 src_sample;
+
+			while ( len-- ) {
+				src_sample = *src;
+				ADJUST_VOLUME_U8(src_sample, volume);
+				*dst = mix8[*dst+src_sample];
+				++dst;
+				++src;
+			}
+#endif
+		}
+		break;
+
+		case AUDIO_S8: {
+#if defined(__GNUC__) && defined(__i386__) && defined(SDL_ASSEMBLY_ROUTINES)
+			if (SDL_HasMMX())
+			{
+				SDL_MixAudio_MMX_S8((char*)dst,(char*)src,(unsigned int)len,(int)volume);
+			}
+			else
+#elif ((defined(_MSC_VER) && defined(_M_IX86)) || defined(__WATCOMC__)) && defined(SDL_ASSEMBLY_ROUTINES)
+			if (SDL_HasMMX())
+			{
+				SDL_MixAudio_MMX_S8_VC((char*)dst,(char*)src,(unsigned int)len,(int)volume);
+			}
+			else
+#endif
+#if defined(__GNUC__) && defined(__M68000__) && defined(SDL_ASSEMBLY_ROUTINES)
+			SDL_MixAudio_m68k_S8((char*)dst,(char*)src,(unsigned long)len,(long)volume);
+#else
+			{
+			Sint8 *dst8, *src8;
+			Sint8 src_sample;
+			int dst_sample;
+			const int max_audioval = ((1<<(8-1))-1);
+			const int min_audioval = -(1<<(8-1));
+
+			src8 = (Sint8 *)src;
+			dst8 = (Sint8 *)dst;
+			while ( len-- ) {
+				src_sample = *src8;
+				ADJUST_VOLUME(src_sample, volume);
+				dst_sample = *dst8 + src_sample;
+				if ( dst_sample > max_audioval ) {
+					*dst8 = max_audioval;
+				} else
+				if ( dst_sample < min_audioval ) {
+					*dst8 = min_audioval;
+				} else {
+					*dst8 = dst_sample;
+				}
+				++dst8;
+				++src8;
+			}
+			}
+#endif
+		}
+		break;
+
+		case AUDIO_S16LSB: {
+#if defined(__GNUC__) && defined(__i386__) && defined(SDL_ASSEMBLY_ROUTINES)
+			if (SDL_HasMMX())
+			{
+				SDL_MixAudio_MMX_S16((char*)dst,(char*)src,(unsigned int)len,(int)volume);
+			}
+                        else
+#elif ((defined(_MSC_VER) && defined(_M_IX86)) || defined(__WATCOMC__)) && defined(SDL_ASSEMBLY_ROUTINES)
+			if (SDL_HasMMX())
+			{
+				SDL_MixAudio_MMX_S16_VC((char*)dst,(char*)src,(unsigned int)len,(int)volume);
+			}
+			else
+#endif
+#if defined(__GNUC__) && defined(__M68000__) && defined(SDL_ASSEMBLY_ROUTINES)
+			SDL_MixAudio_m68k_S16LSB((short*)dst,(short*)src,(unsigned long)len,(long)volume);
+#else
+			{
+			Sint16 src1, src2;
+			int dst_sample;
+			const int max_audioval = ((1<<(16-1))-1);
+			const int min_audioval = -(1<<(16-1));
+
+			len /= 2;
+			while ( len-- ) {
+				src1 = ((src[1])<<8|src[0]);
+				ADJUST_VOLUME(src1, volume);
+				src2 = ((dst[1])<<8|dst[0]);
+				src += 2;
+				dst_sample = src1+src2;
+				if ( dst_sample > max_audioval ) {
+					dst_sample = max_audioval;
+				} else
+				if ( dst_sample < min_audioval ) {
+					dst_sample = min_audioval;
+				}
+				dst[0] = dst_sample&0xFF;
+				dst_sample >>= 8;
+				dst[1] = dst_sample&0xFF;
+				dst += 2;
+			}
+			}
+#endif
+		}
+		break;
+
+		case AUDIO_S16MSB: {
+#if defined(__GNUC__) && defined(__M68000__) && defined(SDL_ASSEMBLY_ROUTINES)
+			SDL_MixAudio_m68k_S16MSB((short*)dst,(short*)src,(unsigned long)len,(long)volume);
+#else
+			Sint16 src1, src2;
+			int dst_sample;
+			const int max_audioval = ((1<<(16-1))-1);
+			const int min_audioval = -(1<<(16-1));
+
+			len /= 2;
+			while ( len-- ) {
+				src1 = ((src[0])<<8|src[1]);
+				ADJUST_VOLUME(src1, volume);
+				src2 = ((dst[0])<<8|dst[1]);
+				src += 2;
+				dst_sample = src1+src2;
+				if ( dst_sample > max_audioval ) {
+					dst_sample = max_audioval;
+				} else
+				if ( dst_sample < min_audioval ) {
+					dst_sample = min_audioval;
+				}
+				dst[1] = dst_sample&0xFF;
+				dst_sample >>= 8;
+				dst[0] = dst_sample&0xFF;
+				dst += 2;
+			}
+#endif
+		}
+		break;
+
+		default: /* If this happens... FIXME! */
+			SDL_SetError("SDL_MixAudio(): unknown audio format");
+			return;
+	}
+}
+

src/dep/src/SDL/audio/SDL_mixer_MMX.c

@@ -0,0 +1,206 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2006 Sam Lantinga
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+    Sam Lantinga
+    slouken@libsdl.org
+*/
+#include "SDL_config.h"
+
+/*
+    MMX assembler version of SDL_MixAudio for signed little endian 16 bit samples and signed 8 bit samples
+    Copyright 2002 Stephane Marchesin (stephane.marchesin@wanadoo.fr)
+    This code is licensed under the LGPL (see COPYING for details)
+ 
+    Assumes buffer size in bytes is a multiple of 16
+    Assumes SDL_MIX_MAXVOLUME = 128
+*/
+
+
+/***********************************************
+*   Mixing for 16 bit signed buffers
+***********************************************/
+
+#if defined(__GNUC__) && defined(__i386__) && defined(SDL_ASSEMBLY_ROUTINES)
+void SDL_MixAudio_MMX_S16(char* dst,char* src,unsigned int size,int volume)
+{
+    __asm__ __volatile__ (
+
+"	movl %3,%%eax\n"	/* eax = volume */
+
+"	movl %2,%%edx\n"	/* edx = size */
+
+"	shrl $4,%%edx\n"	/* process 16 bytes per iteration = 8 samples */
+
+"	jz .endS16\n"
+
+"	pxor %%mm0,%%mm0\n"
+
+"	movd %%eax,%%mm0\n"
+"	movq %%mm0,%%mm1\n"
+"	psllq $16,%%mm0\n"
+"	por %%mm1,%%mm0\n"
+"	psllq $16,%%mm0\n"
+"	por %%mm1,%%mm0\n"
+"	psllq $16,%%mm0\n"
+"	por %%mm1,%%mm0\n"		/* mm0 = vol|vol|vol|vol */
+
+".align 8\n"
+"	.mixloopS16:\n"
+
+"	movq (%1),%%mm1\n" /* mm1 = a|b|c|d */
+
+"	movq %%mm1,%%mm2\n" /* mm2 = a|b|c|d */
+
+"	movq 8(%1),%%mm4\n" /* mm4 = e|f|g|h */
+
+	/* pré charger le buffer dst dans mm7 */
+"	movq (%0),%%mm7\n" /* mm7 = dst[0] */
+
+	/* multiplier par le volume */
+"	pmullw %%mm0,%%mm1\n" /* mm1 = l(a*v)|l(b*v)|l(c*v)|l(d*v) */
+
+"	pmulhw %%mm0,%%mm2\n" /* mm2 = h(a*v)|h(b*v)|h(c*v)|h(d*v) */
+"	movq %%mm4,%%mm5\n" /* mm5 = e|f|g|h */
+
+"	pmullw %%mm0,%%mm4\n" /* mm4 = l(e*v)|l(f*v)|l(g*v)|l(h*v) */
+
+"	pmulhw %%mm0,%%mm5\n" /* mm5 = h(e*v)|h(f*v)|h(g*v)|h(h*v) */
+"	movq %%mm1,%%mm3\n" /* mm3 = l(a*v)|l(b*v)|l(c*v)|l(d*v) */
+
+"	punpckhwd %%mm2,%%mm1\n" /* mm1 = a*v|b*v */
+
+"	movq %%mm4,%%mm6\n" /* mm6 = l(e*v)|l(f*v)|l(g*v)|l(h*v) */
+"	punpcklwd %%mm2,%%mm3\n" /* mm3 = c*v|d*v */
+
+"	punpckhwd %%mm5,%%mm4\n" /* mm4 = e*f|f*v */
+
+"	punpcklwd %%mm5,%%mm6\n" /* mm6 = g*v|h*v */
+
+	/* pré charger le buffer dst dans mm5 */
+"	movq 8(%0),%%mm5\n" /* mm5 = dst[1] */
+
+	/* diviser par 128 */
+"	psrad $7,%%mm1\n" /* mm1 = a*v/128|b*v/128 , 128 = SDL_MIX_MAXVOLUME */
+"	add $16,%1\n"
+
+"	psrad $7,%%mm3\n" /* mm3 = c*v/128|d*v/128 */
+
+"	psrad $7,%%mm4\n" /* mm4 = e*v/128|f*v/128 */
+
+	/* mm1 = le sample avec le volume modifié */
+"	packssdw %%mm1,%%mm3\n" /* mm3 = s(a*v|b*v|c*v|d*v) */
+
+"	psrad $7,%%mm6\n" /* mm6= g*v/128|h*v/128 */
+"	paddsw %%mm7,%%mm3\n" /* mm3 = adjust_volume(src)+dst */
+
+	/* mm4 = le sample avec le volume modifié */
+"	packssdw %%mm4,%%mm6\n" /* mm6 = s(e*v|f*v|g*v|h*v) */
+"	movq %%mm3,(%0)\n"
+
+"	paddsw %%mm5,%%mm6\n" /* mm6 = adjust_volume(src)+dst */
+
+"	movq %%mm6,8(%0)\n"
+
+"	add $16,%0\n"
+
+"	dec %%edx\n"
+
+"	jnz .mixloopS16\n"
+
+"	emms\n"
+
+".endS16:\n"
+	 :
+	 : "r" (dst), "r"(src),"m"(size),
+	 "m"(volume)
+	 : "eax","edx","memory"
+	 );
+}
+
+
+
+/*////////////////////////////////////////////// */
+/* Mixing for 8 bit signed buffers */
+/*////////////////////////////////////////////// */
+
+void SDL_MixAudio_MMX_S8(char* dst,char* src,unsigned int size,int volume)
+{
+    __asm__ __volatile__ (
+
+"	movl %3,%%eax\n"	/* eax = volume */
+
+"	movd %%eax,%%mm0\n"
+"	movq %%mm0,%%mm1\n"
+"	psllq $16,%%mm0\n"
+"	por %%mm1,%%mm0\n"
+"	psllq $16,%%mm0\n"
+"	por %%mm1,%%mm0\n"
+"	psllq $16,%%mm0\n"
+"	por %%mm1,%%mm0\n"
+
+"	movl %2,%%edx\n"	/* edx = size */
+"	shr $3,%%edx\n"	/* process 8 bytes per iteration = 8 samples */
+
+"	cmp $0,%%edx\n"
+"	je .endS8\n"
+
+".align 8\n"
+"	.mixloopS8:\n"
+
+"	pxor %%mm2,%%mm2\n"		/* mm2 = 0 */
+"	movq (%1),%%mm1\n"	/* mm1 = a|b|c|d|e|f|g|h */
+
+"	movq %%mm1,%%mm3\n" 	/* mm3 = a|b|c|d|e|f|g|h */
+
+	/* on va faire le "sign extension" en faisant un cmp avec 0 qui retourne 1 si <0, 0 si >0 */
+"	pcmpgtb %%mm1,%%mm2\n"	/* mm2 = 11111111|00000000|00000000.... */
+
+"	punpckhbw %%mm2,%%mm1\n"	/* mm1 = 0|a|0|b|0|c|0|d */
+
+"	punpcklbw %%mm2,%%mm3\n"	/* mm3 = 0|e|0|f|0|g|0|h */
+"	movq (%0),%%mm2\n"	/* mm2 = destination */
+
+"	pmullw %%mm0,%%mm1\n"	/* mm1 = v*a|v*b|v*c|v*d */
+"	add $8,%1\n"
+
+"	pmullw %%mm0,%%mm3\n"	/* mm3 = v*e|v*f|v*g|v*h */
+"	psraw $7,%%mm1\n"		/* mm1 = v*a/128|v*b/128|v*c/128|v*d/128  */
+
+"	psraw $7,%%mm3\n"		/* mm3 = v*e/128|v*f/128|v*g/128|v*h/128 */
+
+"	packsswb %%mm1,%%mm3\n"	/* mm1 = v*a/128|v*b/128|v*c/128|v*d/128|v*e/128|v*f/128|v*g/128|v*h/128 */
+
+"	paddsb %%mm2,%%mm3\n"	/* add to destination buffer */
+
+"	movq %%mm3,(%0)\n"	/* store back to ram */
+"	add $8,%0\n"
+
+"	dec %%edx\n"
+
+"	jnz .mixloopS8\n"
+
+".endS8:\n"
+"	emms\n"
+	 :
+	 : "r" (dst), "r"(src),"m"(size),
+	 "m"(volume)
+	 : "eax","edx","memory"
+	 );
+}
+#endif
+

src/dep/src/SDL/audio/SDL_mixer_MMX.h

@@ -0,0 +1,15 @@
+/*
+    headers for MMX assembler version of SDL_MixAudio
+    Copyright 2002 Stephane Marchesin (stephane.marchesin@wanadoo.fr)
+    This code is licensed under the LGPL (see COPYING for details)
+
+    Assumes buffer size in bytes is a multiple of 16
+    Assumes SDL_MIX_MAXVOLUME = 128
+*/
+#include "SDL_config.h"
+
+#if defined(__GNUC__) && defined(__i386__) && defined(SDL_ASSEMBLY_ROUTINES)
+void SDL_MixAudio_MMX_S16(char* ,char* ,unsigned int ,int );
+void SDL_MixAudio_MMX_S8(char* ,char* ,unsigned int ,int );
+#endif
+

src/dep/src/SDL/audio/SDL_mixer_MMX_VC.c

@@ -0,0 +1,181 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2006 Sam Lantinga
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+    Sam Lantinga
+    slouken@libsdl.org
+*/
+#include "SDL_config.h"
+
+#include "SDL_mixer_MMX_VC.h"
+
+#if ((defined(_MSC_VER) && defined(_M_IX86)) || defined(__WATCOMC__)) && defined(SDL_ASSEMBLY_ROUTINES)
+// MMX assembler version of SDL_MixAudio for signed little endian 16 bit samples and signed 8 bit samples
+// Copyright 2002 Stephane Marchesin (stephane.marchesin@wanadoo.fr)
+// Converted to Intel ASM notation by Cth
+// This code is licensed under the LGPL (see COPYING for details)
+// 
+// Assumes buffer size in bytes is a multiple of 16
+// Assumes SDL_MIX_MAXVOLUME = 128
+
+
+////////////////////////////////////////////////
+// Mixing for 16 bit signed buffers
+////////////////////////////////////////////////
+
+void SDL_MixAudio_MMX_S16_VC(char* dst,char* src,unsigned int nSize,int volume)
+{
+	__asm
+	{
+
+		push	edi
+		push	esi
+		push	ebx
+		
+		mov		edi, dst		// edi = dst
+		mov		esi, src		// esi = src
+		mov		eax, volume		// eax = volume
+		mov		ebx, nSize		// ebx = size
+		shr		ebx, 4			// process 16 bytes per iteration = 8 samples
+		jz		endS16
+		
+		pxor	mm0, mm0
+		movd	mm0, eax		//%%eax,%%mm0
+		movq	mm1, mm0		//%%mm0,%%mm1
+		psllq	mm0, 16			//$16,%%mm0
+		por		mm0, mm1		//%%mm1,%%mm0
+		psllq	mm0, 16			//$16,%%mm0
+		por		mm0, mm1		//%%mm1,%%mm0
+		psllq	mm0, 16			//$16,%%mm0
+		por		mm0, mm1		//%%mm1,%%mm0			// mm0 = vol|vol|vol|vol
+
+		#ifndef __WATCOMC__
+		align	16
+		#endif
+mixloopS16:
+		movq	mm1, [esi]		//(%%esi),%%mm1\n" // mm1 = a|b|c|d
+		movq	mm2, mm1		//%%mm1,%%mm2\n" // mm2 = a|b|c|d
+		movq	mm4, [esi + 8]	//8(%%esi),%%mm4\n" // mm4 = e|f|g|h
+		// pre charger le buffer dst dans mm7
+		movq	mm7, [edi]		//(%%edi),%%mm7\n" // mm7 = dst[0]"
+		// multiplier par le volume
+		pmullw	mm1, mm0		//%%mm0,%%mm1\n" // mm1 = l(a*v)|l(b*v)|l(c*v)|l(d*v)
+		pmulhw	mm2, mm0		//%%mm0,%%mm2\n" // mm2 = h(a*v)|h(b*v)|h(c*v)|h(d*v)
+		movq	mm5, mm4		//%%mm4,%%mm5\n" // mm5 = e|f|g|h
+		pmullw	mm4, mm0		//%%mm0,%%mm4\n" // mm4 = l(e*v)|l(f*v)|l(g*v)|l(h*v)
+		pmulhw	mm5, mm0		//%%mm0,%%mm5\n" // mm5 = h(e*v)|h(f*v)|h(g*v)|h(h*v)
+		movq	mm3, mm1		//%%mm1,%%mm3\n" // mm3 = l(a*v)|l(b*v)|l(c*v)|l(d*v)
+		punpckhwd	mm1, mm2	//%%mm2,%%mm1\n" // mm1 = a*v|b*v
+		movq		mm6, mm4	//%%mm4,%%mm6\n" // mm6 = l(e*v)|l(f*v)|l(g*v)|l(h*v)
+		punpcklwd	mm3, mm2	//%%mm2,%%mm3\n" // mm3 = c*v|d*v
+		punpckhwd	mm4, mm5	//%%mm5,%%mm4\n" // mm4 = e*f|f*v
+		punpcklwd	mm6, mm5	//%%mm5,%%mm6\n" // mm6 = g*v|h*v
+		// pre charger le buffer dst dans mm5
+		movq	mm5, [edi + 8]	//8(%%edi),%%mm5\n" // mm5 = dst[1]
+		// diviser par 128
+		psrad	mm1, 7			//$7,%%mm1\n" // mm1 = a*v/128|b*v/128 , 128 = SDL_MIX_MAXVOLUME
+		add		esi, 16			//$16,%%esi\n"
+		psrad	mm3, 7			//$7,%%mm3\n" // mm3 = c*v/128|d*v/128
+		psrad	mm4, 7			//$7,%%mm4\n" // mm4 = e*v/128|f*v/128
+		// mm1 = le sample avec le volume modifie
+		packssdw	mm3, mm1	//%%mm1,%%mm3\n" // mm3 = s(a*v|b*v|c*v|d*v)
+		psrad	mm6, 7			//$7,%%mm6\n" // mm6= g*v/128|h*v/128
+		paddsw	mm3, mm7		//%%mm7,%%mm3\n" // mm3 = adjust_volume(src)+dst
+		// mm4 = le sample avec le volume modifie
+		packssdw	mm6, mm4	//%%mm4,%%mm6\n" // mm6 = s(e*v|f*v|g*v|h*v)
+		movq	[edi], mm3		//%%mm3,(%%edi)\n"
+		paddsw	mm6, mm5		//%%mm5,%%mm6\n" // mm6 = adjust_volume(src)+dst
+		movq	[edi + 8], mm6	//%%mm6,8(%%edi)\n"
+		add		edi, 16			//$16,%%edi\n"
+		dec		ebx				//%%ebx\n"
+		jnz mixloopS16
+
+ends16:
+		emms
+		
+		pop		ebx
+		pop		esi
+		pop		edi
+	}
+
+}
+
+////////////////////////////////////////////////
+// Mixing for 8 bit signed buffers
+////////////////////////////////////////////////
+
+void SDL_MixAudio_MMX_S8_VC(char* dst,char* src,unsigned int nSize,int volume)
+{
+	_asm
+	{
+
+		push	edi
+		push	esi
+		push	ebx
+		
+		mov		edi, dst	//movl	%0,%%edi	// edi = dst
+		mov		esi, src	//%1,%%esi	// esi = src
+		mov		eax, volume	//%3,%%eax	// eax = volume
+
+		movd	mm0, eax	//%%eax,%%mm0
+		movq	mm1, mm0	//%%mm0,%%mm1
+		psllq	mm0, 16		//$16,%%mm0
+		por		mm0, mm1	//%%mm1,%%mm0
+		psllq	mm0, 16		//$16,%%mm0
+		por		mm0, mm1	//%%mm1,%%mm0
+		psllq	mm0, 16		//$16,%%mm0
+		por		mm0, mm1	//%%mm1,%%mm0
+		
+		mov		ebx, nSize	//%2,%%ebx	// ebx = size
+		shr		ebx, 3		//$3,%%ebx	// process 8 bytes per iteration = 8 samples
+		cmp		ebx, 0		//$0,%%ebx
+		je		endS8
+
+		#ifndef __WATCOMC__
+		align 16
+		#endif
+mixloopS8:
+		pxor	mm2, mm2	//%%mm2,%%mm2		// mm2 = 0
+		movq	mm1, [esi]	//(%%esi),%%mm1	// mm1 = a|b|c|d|e|f|g|h
+		movq	mm3, mm1	//%%mm1,%%mm3 	// mm3 = a|b|c|d|e|f|g|h
+		// on va faire le "sign extension" en faisant un cmp avec 0 qui retourne 1 si <0, 0 si >0
+		pcmpgtb		mm2, mm1	//%%mm1,%%mm2	// mm2 = 11111111|00000000|00000000....
+		punpckhbw	mm1, mm2	//%%mm2,%%mm1	// mm1 = 0|a|0|b|0|c|0|d
+		punpcklbw	mm3, mm2	//%%mm2,%%mm3	// mm3 = 0|e|0|f|0|g|0|h
+		movq	mm2, [edi]	//(%%edi),%%mm2	// mm2 = destination
+		pmullw	mm1, mm0	//%%mm0,%%mm1	// mm1 = v*a|v*b|v*c|v*d
+		add		esi, 8		//$8,%%esi
+		pmullw	mm3, mm0	//%%mm0,%%mm3	// mm3 = v*e|v*f|v*g|v*h
+		psraw	mm1, 7		//$7,%%mm1		// mm1 = v*a/128|v*b/128|v*c/128|v*d/128 
+		psraw	mm3, 7		//$7,%%mm3		// mm3 = v*e/128|v*f/128|v*g/128|v*h/128
+		packsswb mm3, mm1	//%%mm1,%%mm3	// mm1 = v*a/128|v*b/128|v*c/128|v*d/128|v*e/128|v*f/128|v*g/128|v*h/128
+		paddsb	mm3, mm2	//%%mm2,%%mm3	// add to destination buffer
+		movq	[edi], mm3	//%%mm3,(%%edi)	// store back to ram
+		add		edi, 8		//$8,%%edi
+		dec		ebx			//%%ebx
+		jnz		mixloopS8
+		
+endS8:
+		emms
+		
+		pop		ebx
+		pop		esi
+		pop		edi
+	}
+}
+
+#endif /* SDL_ASSEMBLY_ROUTINES */

src/dep/src/SDL/audio/SDL_mixer_MMX_VC.h

@@ -0,0 +1,36 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2006 Sam Lantinga
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+    Sam Lantinga
+    slouken@libsdl.org
+*/
+#include "SDL_config.h"
+
+
+#if ((defined(_MSC_VER) && defined(_M_IX86)) || defined(__WATCOMC__)) && defined(SDL_ASSEMBLY_ROUTINES)
+/* headers for MMX assembler version of SDL_MixAudio
+   Copyright 2002 Stephane Marchesin (stephane.marchesin@wanadoo.fr)
+   Converted to Intel ASM notation by Cth
+   This code is licensed under the LGPL (see COPYING for details)
+   
+   Assumes buffer size in bytes is a multiple of 16
+   Assumes SDL_MIX_MAXVOLUME = 128
+*/
+void SDL_MixAudio_MMX_S16_VC(char* ,char* ,unsigned int ,int );
+void SDL_MixAudio_MMX_S8_VC(char* ,char* ,unsigned int ,int );
+#endif

src/dep/src/SDL/audio/SDL_mixer_m68k.c

@@ -0,0 +1,211 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2004 Sam Lantinga
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Library General Public
+    License as published by the Free Software Foundation; either
+    version 2 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Library General Public License for more details.
+
+    You should have received a copy of the GNU Library General Public
+    License along with this library; if not, write to the Free
+    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+    Sam Lantinga
+    slouken@libsdl.org
+*/
+#include "SDL_config.h"
+
+/*
+	m68k assembly mix routines
+
+	Patrice Mandin
+*/
+
+#if defined(__M68000__) && defined(__GNUC__)
+void SDL_MixAudio_m68k_U8(char* dst, char* src, long len, long volume, char* mix8)
+{
+    __asm__ __volatile__ (
+
+	"tstl	%2\n"
+"	beqs	stoploop_u8\n"
+"mixloop_u8:\n"
+
+	/* Mix a sample */
+
+"	moveq	#0,%%d0\n"
+"	moveq	#0,%%d1\n"
+
+"	moveb	%1@+,%%d0\n"	/* d0 = *src++ */
+"	sub	#128,%%d0\n"	/* d0 -= 128 */
+"	muls	%3,%%d0\n"	/* d0 *= volume (0<=volume<=128) */
+"	moveb	%0@,%%d1\n"	/* d1 = *dst */
+"	asr	#7,%%d0\n"	/* d0 /= 128 (SDL_MIX_MAXVOLUME) */
+"	add	#128,%%d0\n"	/* d0 += 128 */
+
+"	add	%%d1,%%d0\n"
+
+"	moveb	%4@(%%d0:w),%0@+\n"
+
+	/* Loop till done */
+
+"	subql	#1,%2\n"
+"	bhis	mixloop_u8\n"
+"stoploop_u8:\n"
+
+	 : /* no return value */
+	 : /* input */
+	 	"a"(dst), "a"(src), "d"(len), "d"(volume), "a"(mix8)	
+	 : /* clobbered registers */
+	 	"d0", "d1", "cc", "memory" 
+	 );
+}
+
+void SDL_MixAudio_m68k_S8(char* dst, char* src, long len, long volume)
+{
+    __asm__ __volatile__ (
+
+	"tstl	%2\n"
+"	beqs	stoploop_s8\n"
+"	moveq	#-128,%%d2\n"
+"	moveq	#127,%%d3\n"
+"mixloop_s8:\n"
+
+	/* Mix a sample */
+
+"	moveq	#0,%%d0\n"
+"	moveq	#0,%%d1\n"
+
+"	moveb	%1@+,%%d0\n"	/* d0 = *src++ */
+"	muls	%3,%%d0\n"	/* d0 *= volume (0<=volume<=128) */
+"	moveb	%0@,%%d1\n"	/* d1 = *dst */
+"	asr	#7,%%d0\n"	/* d0 /= 128 (SDL_MIX_MAXVOLUME) */
+
+"	add	%%d1,%%d0\n"
+
+"	cmp	%%d2,%%d0\n"
+"	bges	lower_limit_s8\n"
+"	move	%%d2,%%d0\n"
+"lower_limit_s8:\n"
+
+"	cmp	%%d3,%%d0\n"
+"	bles	upper_limit_s8\n"
+"	move	%%d3,%%d0\n"
+"upper_limit_s8:\n"
+"	moveb	%%d0,%0@+\n"
+
+	/* Loop till done */
+
+"	subql	#1,%2\n"
+"	bhis	mixloop_s8\n"
+"stoploop_s8:\n"
+
+	 : /* no return value */
+	 : /* input */
+	 	"a"(dst), "a"(src), "d"(len), "d"(volume)	
+	 : /* clobbered registers */
+	 	"d0", "d1", "d2", "d3", "cc", "memory" 
+	 );
+}
+
+void SDL_MixAudio_m68k_S16MSB(short* dst, short* src, long len, long volume)
+{
+    __asm__ __volatile__ (
+
+	"tstl	%2\n"
+"	beqs	stoploop_s16msb\n"
+"	movel	#-32768,%%d2\n"
+"	movel	#32767,%%d3\n"
+"	lsrl	#1,%2\n"
+"mixloop_s16msb:\n"
+
+	/* Mix a sample */
+
+"	move	%1@+,%%d0\n"	/* d0 = *src++ */
+"	muls	%3,%%d0\n"	/* d0 *= volume (0<=volume<=128) */
+"	move	%0@,%%d1\n"	/* d1 = *dst */
+"	extl	%%d1\n"		/* extend d1 to 32 bits */
+"	asrl	#7,%%d0\n"	/* d0 /= 128 (SDL_MIX_MAXVOLUME) */
+
+"	addl	%%d1,%%d0\n"
+
+"	cmpl	%%d2,%%d0\n"
+"	bges	lower_limit_s16msb\n"
+"	move	%%d2,%%d0\n"
+"lower_limit_s16msb:\n"
+
+"	cmpl	%%d3,%%d0\n"
+"	bles	upper_limit_s16msb\n"
+"	move	%%d3,%%d0\n"
+"upper_limit_s16msb:\n"
+"	move	%%d0,%0@+\n"
+
+	/* Loop till done */
+
+"	subql	#1,%2\n"
+"	bhis	mixloop_s16msb\n"
+"stoploop_s16msb:\n"
+
+	 : /* no return value */
+	 : /* input */
+	 	"a"(dst), "a"(src), "d"(len), "d"(volume)	
+	 : /* clobbered registers */
+	 	"d0", "d1", "d2", "d3", "cc", "memory" 
+	 );
+}
+
+void SDL_MixAudio_m68k_S16LSB(short* dst, short* src, long len, long volume)
+{
+    __asm__ __volatile__ (
+
+	"tstl	%2\n"
+"	beqs	stoploop_s16lsb\n"
+"	movel	#-32768,%%d2\n"
+"	movel	#32767,%%d3\n"
+"	lsrl	#1,%2\n"
+"mixloop_s16lsb:\n"
+
+	/* Mix a sample */
+
+"	move	%1@+,%%d0\n"	/* d0 = *src++ */
+"	rorw	#8,%%d0\n"
+"	muls	%3,%%d0\n"	/* d0 *= volume (0<=volume<=128) */
+"	move	%0@,%%d1\n"	/* d1 = *dst */
+"	rorw	#8,%%d1\n"
+"	extl	%%d1\n"		/* extend d1 to 32 bits */
+"	asrl	#7,%%d0\n"	/* d0 /= 128 (SDL_MIX_MAXVOLUME) */
+
+"	addl	%%d1,%%d0\n"
+
+"	cmpl	%%d2,%%d0\n"
+"	bges	lower_limit_s16lsb\n"
+"	move	%%d2,%%d0\n"
+"lower_limit_s16lsb:\n"
+
+"	cmpl	%%d3,%%d0\n"
+"	bles	upper_limit_s16lsb\n"
+"	move	%%d3,%%d0\n"
+"upper_limit_s16lsb:\n"
+"	rorw	#8,%%d0\n"
+"	move	%%d0,%0@+\n"
+
+	/* Loop till done */
+
+"	subql	#1,%2\n"
+"	bhis	mixloop_s16lsb\n"
+"stoploop_s16lsb:\n"
+
+	 : /* no return value */
+	 : /* input */
+	 	"a"(dst), "a"(src), "d"(len), "d"(volume)	
+	 : /* clobbered registers */
+	 	"d0", "d1", "d2", "d3", "cc", "memory" 
+	 );
+}
+#endif
+

src/dep/src/SDL/audio/SDL_mixer_m68k.h

@@ -0,0 +1,36 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2004 Sam Lantinga
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Library General Public
+    License as published by the Free Software Foundation; either
+    version 2 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Library General Public License for more details.
+
+    You should have received a copy of the GNU Library General Public
+    License along with this library; if not, write to the Free
+    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+    Sam Lantinga
+    slouken@libsdl.org
+*/
+#include "SDL_config.h"
+
+/*
+	m68k assembly mix routines
+
+	Patrice Mandin
+*/
+
+#if defined(__M68000__) && defined(__GNUC__)
+void SDL_MixAudio_m68k_U8(char* dst,char* src, long len, long volume, char* mix8);
+void SDL_MixAudio_m68k_S8(char* dst,char* src, long len, long volume);
+
+void SDL_MixAudio_m68k_S16MSB(short* dst,short* src, long len, long volume);
+void SDL_MixAudio_m68k_S16LSB(short* dst,short* src, long len, long volume);
+#endif

src/dep/src/SDL/audio/SDL_sysaudio.h

@@ -0,0 +1,178 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2006 Sam Lantinga
+
+    This library is SDL_free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+    Sam Lantinga
+    slouken@libsdl.org
+*/
+#include "SDL_config.h"
+
+#ifndef _SDL_sysaudio_h
+#define _SDL_sysaudio_h
+
+#include "SDL_mutex.h"
+#include "SDL_thread.h"
+
+/* The SDL audio driver */
+typedef struct SDL_AudioDevice SDL_AudioDevice;
+
+/* Define the SDL audio driver structure */
+#define _THIS	SDL_AudioDevice *_this
+#ifndef _STATUS
+#define _STATUS	SDL_status *status
+#endif
+struct SDL_AudioDevice {
+	/* * * */
+	/* The name of this audio driver */
+	const char *name;
+
+	/* * * */
+	/* The description of this audio driver */
+	const char *desc;
+
+	/* * * */
+	/* Public driver functions */
+	int  (*OpenAudio)(_THIS, SDL_AudioSpec *spec);
+	void (*ThreadInit)(_THIS);	/* Called by audio thread at start */
+	void (*WaitAudio)(_THIS);
+	void (*PlayAudio)(_THIS);
+	Uint8 *(*GetAudioBuf)(_THIS);
+	void (*WaitDone)(_THIS);
+	void (*CloseAudio)(_THIS);
+
+	/* * * */
+	/* Lock / Unlock functions added for the Mac port */
+	void (*LockAudio)(_THIS);
+	void (*UnlockAudio)(_THIS);
+
+	/* * * */
+	/* Data common to all devices */
+
+	/* The current audio specification (shared with audio thread) */
+	SDL_AudioSpec spec;
+
+	/* An audio conversion block for audio format emulation */
+	SDL_AudioCVT convert;
+
+	/* Current state flags */
+	int enabled;
+	int paused;
+	int opened;
+
+	/* Fake audio buffer for when the audio hardware is busy */
+	Uint8 *fake_stream;
+
+	/* A semaphore for locking the mixing buffers */
+	SDL_mutex *mixer_lock;
+
+	/* A thread to feed the audio device */
+	SDL_Thread *thread;
+	Uint32 threadid;
+
+	/* * * */
+	/* Data private to this driver */
+	struct SDL_PrivateAudioData *hidden;
+
+	/* * * */
+	/* The function used to dispose of this structure */
+	void (*free)(_THIS);
+};
+#undef _THIS
+
+typedef struct AudioBootStrap {
+	const char *name;
+	const char *desc;
+	int (*available)(void);
+	SDL_AudioDevice *(*create)(int devindex);
+} AudioBootStrap;
+
+#if SDL_AUDIO_DRIVER_BSD
+extern AudioBootStrap BSD_AUDIO_bootstrap;
+#endif
+#if SDL_AUDIO_DRIVER_OSS
+extern AudioBootStrap DSP_bootstrap;
+extern AudioBootStrap DMA_bootstrap;
+#endif
+#if SDL_AUDIO_DRIVER_ALSA
+extern AudioBootStrap ALSA_bootstrap;
+#endif
+#if SDL_AUDIO_DRIVER_QNXNTO
+extern AudioBootStrap QNXNTOAUDIO_bootstrap;
+#endif
+#if SDL_AUDIO_DRIVER_SUNAUDIO
+extern AudioBootStrap SUNAUDIO_bootstrap;
+#endif
+#if SDL_AUDIO_DRIVER_DMEDIA
+extern AudioBootStrap DMEDIA_bootstrap;
+#endif
+#if SDL_AUDIO_DRIVER_ARTS
+extern AudioBootStrap ARTS_bootstrap;
+#endif
+#if SDL_AUDIO_DRIVER_ESD
+extern AudioBootStrap ESD_bootstrap;
+#endif
+#if SDL_AUDIO_DRIVER_NAS
+extern AudioBootStrap NAS_bootstrap;
+#endif
+#if SDL_AUDIO_DRIVER_DSOUND
+extern AudioBootStrap DSOUND_bootstrap;
+#endif
+#if SDL_AUDIO_DRIVER_WAVEOUT
+extern AudioBootStrap WAVEOUT_bootstrap;
+#endif
+#if SDL_AUDIO_DRIVER_PAUD
+extern AudioBootStrap Paud_bootstrap;
+#endif
+#if SDL_AUDIO_DRIVER_BAUDIO
+extern AudioBootStrap BAUDIO_bootstrap;
+#endif
+#if SDL_AUDIO_DRIVER_COREAUDIO
+extern AudioBootStrap COREAUDIO_bootstrap;
+#endif
+#if SDL_AUDIO_DRIVER_SNDMGR
+extern AudioBootStrap SNDMGR_bootstrap;
+#endif
+#if SDL_AUDIO_DRIVER_AHI
+extern AudioBootStrap AHI_bootstrap;
+#endif
+#if SDL_AUDIO_DRIVER_MINT
+extern AudioBootStrap MINTAUDIO_GSXB_bootstrap;
+extern AudioBootStrap MINTAUDIO_MCSN_bootstrap;
+extern AudioBootStrap MINTAUDIO_STFA_bootstrap;
+extern AudioBootStrap MINTAUDIO_XBIOS_bootstrap;
+extern AudioBootStrap MINTAUDIO_DMA8_bootstrap;
+#endif
+#if SDL_AUDIO_DRIVER_DISK
+extern AudioBootStrap DISKAUD_bootstrap;
+#endif
+#if SDL_AUDIO_DRIVER_DUMMY
+extern AudioBootStrap DUMMYAUD_bootstrap;
+#endif
+#if SDL_AUDIO_DRIVER_DC
+extern AudioBootStrap DCAUD_bootstrap;
+#endif
+#if SDL_AUDIO_DRIVER_MMEAUDIO
+extern AudioBootStrap MMEAUDIO_bootstrap;
+#endif
+#if SDL_AUDIO_DRIVER_DART
+extern AudioBootStrap DART_bootstrap;
+#endif
+
+/* This is the current audio device */
+extern SDL_AudioDevice *current_audio;
+
+#endif /* _SDL_sysaudio_h */

src/dep/src/SDL/audio/SDL_wave.c

@@ -0,0 +1,597 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2006 Sam Lantinga
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+    Sam Lantinga
+    slouken@libsdl.org
+*/
+#include "SDL_config.h"
+
+/* Microsoft WAVE file loading routines */
+
+#include "SDL_audio.h"
+#include "SDL_wave.h"
+
+
+static int ReadChunk(SDL_RWops *src, Chunk *chunk);
+
+struct MS_ADPCM_decodestate {
+	Uint8 hPredictor;
+	Uint16 iDelta;
+	Sint16 iSamp1;
+	Sint16 iSamp2;
+};
+static struct MS_ADPCM_decoder {
+	WaveFMT wavefmt;
+	Uint16 wSamplesPerBlock;
+	Uint16 wNumCoef;
+	Sint16 aCoeff[7][2];
+	/* * * */
+	struct MS_ADPCM_decodestate state[2];
+} MS_ADPCM_state;
+
+static int InitMS_ADPCM(WaveFMT *format)
+{
+	Uint8 *rogue_feel;
+	Uint16 extra_info;
+	int i;
+
+	/* Set the rogue pointer to the MS_ADPCM specific data */
+	MS_ADPCM_state.wavefmt.encoding = SDL_SwapLE16(format->encoding);
+	MS_ADPCM_state.wavefmt.channels = SDL_SwapLE16(format->channels);
+	MS_ADPCM_state.wavefmt.frequency = SDL_SwapLE32(format->frequency);
+	MS_ADPCM_state.wavefmt.byterate = SDL_SwapLE32(format->byterate);
+	MS_ADPCM_state.wavefmt.blockalign = SDL_SwapLE16(format->blockalign);
+	MS_ADPCM_state.wavefmt.bitspersample =
+					 SDL_SwapLE16(format->bitspersample);
+	rogue_feel = (Uint8 *)format+sizeof(*format);
+	if ( sizeof(*format) == 16 ) {
+		extra_info = ((rogue_feel[1]<<8)|rogue_feel[0]);
+		rogue_feel += sizeof(Uint16);
+	}
+	MS_ADPCM_state.wSamplesPerBlock = ((rogue_feel[1]<<8)|rogue_feel[0]);
+	rogue_feel += sizeof(Uint16);
+	MS_ADPCM_state.wNumCoef = ((rogue_feel[1]<<8)|rogue_feel[0]);
+	rogue_feel += sizeof(Uint16);
+	if ( MS_ADPCM_state.wNumCoef != 7 ) {
+		SDL_SetError("Unknown set of MS_ADPCM coefficients");
+		return(-1);
+	}
+	for ( i=0; i<MS_ADPCM_state.wNumCoef; ++i ) {
+		MS_ADPCM_state.aCoeff[i][0] = ((rogue_feel[1]<<8)|rogue_feel[0]);
+		rogue_feel += sizeof(Uint16);
+		MS_ADPCM_state.aCoeff[i][1] = ((rogue_feel[1]<<8)|rogue_feel[0]);
+		rogue_feel += sizeof(Uint16);
+	}
+	return(0);
+}
+
+static Sint32 MS_ADPCM_nibble(struct MS_ADPCM_decodestate *state,
+					Uint8 nybble, Sint16 *coeff)
+{
+	const Sint32 max_audioval = ((1<<(16-1))-1);
+	const Sint32 min_audioval = -(1<<(16-1));
+	const Sint32 adaptive[] = {
+		230, 230, 230, 230, 307, 409, 512, 614,
+		768, 614, 512, 409, 307, 230, 230, 230
+	};
+	Sint32 new_sample, delta;
+
+	new_sample = ((state->iSamp1 * coeff[0]) +
+		      (state->iSamp2 * coeff[1]))/256;
+	if ( nybble & 0x08 ) {
+		new_sample += state->iDelta * (nybble-0x10);
+	} else {
+		new_sample += state->iDelta * nybble;
+	}
+	if ( new_sample < min_audioval ) {
+		new_sample = min_audioval;
+	} else
+	if ( new_sample > max_audioval ) {
+		new_sample = max_audioval;
+	}
+	delta = ((Sint32)state->iDelta * adaptive[nybble])/256;
+	if ( delta < 16 ) {
+		delta = 16;
+	}
+	state->iDelta = (Uint16)delta;
+	state->iSamp2 = state->iSamp1;
+	state->iSamp1 = (Sint16)new_sample;
+	return(new_sample);
+}
+
+static int MS_ADPCM_decode(Uint8 **audio_buf, Uint32 *audio_len)
+{
+	struct MS_ADPCM_decodestate *state[2];
+	Uint8 *freeable, *encoded, *decoded;
+	Sint32 encoded_len, samplesleft;
+	Sint8 nybble, stereo;
+	Sint16 *coeff[2];
+	Sint32 new_sample;
+
+	/* Allocate the proper sized output buffer */
+	encoded_len = *audio_len;
+	encoded = *audio_buf;
+	freeable = *audio_buf;
+	*audio_len = (encoded_len/MS_ADPCM_state.wavefmt.blockalign) * 
+				MS_ADPCM_state.wSamplesPerBlock*
+				MS_ADPCM_state.wavefmt.channels*sizeof(Sint16);
+	*audio_buf = (Uint8 *)SDL_malloc(*audio_len);
+	if ( *audio_buf == NULL ) {
+		SDL_Error(SDL_ENOMEM);
+		return(-1);
+	}
+	decoded = *audio_buf;
+
+	/* Get ready... Go! */
+	stereo = (MS_ADPCM_state.wavefmt.channels == 2);
+	state[0] = &MS_ADPCM_state.state[0];
+	state[1] = &MS_ADPCM_state.state[stereo];
+	while ( encoded_len >= MS_ADPCM_state.wavefmt.blockalign ) {
+		/* Grab the initial information for this block */
+		state[0]->hPredictor = *encoded++;
+		if ( stereo ) {
+			state[1]->hPredictor = *encoded++;
+		}
+		state[0]->iDelta = ((encoded[1]<<8)|encoded[0]);
+		encoded += sizeof(Sint16);
+		if ( stereo ) {
+			state[1]->iDelta = ((encoded[1]<<8)|encoded[0]);
+			encoded += sizeof(Sint16);
+		}
+		state[0]->iSamp1 = ((encoded[1]<<8)|encoded[0]);
+		encoded += sizeof(Sint16);
+		if ( stereo ) {
+			state[1]->iSamp1 = ((encoded[1]<<8)|encoded[0]);
+			encoded += sizeof(Sint16);
+		}
+		state[0]->iSamp2 = ((encoded[1]<<8)|encoded[0]);
+		encoded += sizeof(Sint16);
+		if ( stereo ) {
+			state[1]->iSamp2 = ((encoded[1]<<8)|encoded[0]);
+			encoded += sizeof(Sint16);
+		}
+		coeff[0] = MS_ADPCM_state.aCoeff[state[0]->hPredictor];
+		coeff[1] = MS_ADPCM_state.aCoeff[state[1]->hPredictor];
+
+		/* Store the two initial samples we start with */
+		decoded[0] = state[0]->iSamp2&0xFF;
+		decoded[1] = state[0]->iSamp2>>8;
+		decoded += 2;
+		if ( stereo ) {
+			decoded[0] = state[1]->iSamp2&0xFF;
+			decoded[1] = state[1]->iSamp2>>8;
+			decoded += 2;
+		}
+		decoded[0] = state[0]->iSamp1&0xFF;
+		decoded[1] = state[0]->iSamp1>>8;
+		decoded += 2;
+		if ( stereo ) {
+			decoded[0] = state[1]->iSamp1&0xFF;
+			decoded[1] = state[1]->iSamp1>>8;
+			decoded += 2;
+		}
+
+		/* Decode and store the other samples in this block */
+		samplesleft = (MS_ADPCM_state.wSamplesPerBlock-2)*
+					MS_ADPCM_state.wavefmt.channels;
+		while ( samplesleft > 0 ) {
+			nybble = (*encoded)>>4;
+			new_sample = MS_ADPCM_nibble(state[0],nybble,coeff[0]);
+			decoded[0] = new_sample&0xFF;
+			new_sample >>= 8;
+			decoded[1] = new_sample&0xFF;
+			decoded += 2;
+
+			nybble = (*encoded)&0x0F;
+			new_sample = MS_ADPCM_nibble(state[1],nybble,coeff[1]);
+			decoded[0] = new_sample&0xFF;
+			new_sample >>= 8;
+			decoded[1] = new_sample&0xFF;
+			decoded += 2;
+
+			++encoded;
+			samplesleft -= 2;
+		}
+		encoded_len -= MS_ADPCM_state.wavefmt.blockalign;
+	}
+	SDL_free(freeable);
+	return(0);
+}
+
+struct IMA_ADPCM_decodestate {
+	Sint32 sample;
+	Sint8 index;
+};
+static struct IMA_ADPCM_decoder {
+	WaveFMT wavefmt;
+	Uint16 wSamplesPerBlock;
+	/* * * */
+	struct IMA_ADPCM_decodestate state[2];
+} IMA_ADPCM_state;
+
+static int InitIMA_ADPCM(WaveFMT *format)
+{
+	Uint8 *rogue_feel;
+	Uint16 extra_info;
+
+	/* Set the rogue pointer to the IMA_ADPCM specific data */
+	IMA_ADPCM_state.wavefmt.encoding = SDL_SwapLE16(format->encoding);
+	IMA_ADPCM_state.wavefmt.channels = SDL_SwapLE16(format->channels);
+	IMA_ADPCM_state.wavefmt.frequency = SDL_SwapLE32(format->frequency);
+	IMA_ADPCM_state.wavefmt.byterate = SDL_SwapLE32(format->byterate);
+	IMA_ADPCM_state.wavefmt.blockalign = SDL_SwapLE16(format->blockalign);
+	IMA_ADPCM_state.wavefmt.bitspersample =
+					 SDL_SwapLE16(format->bitspersample);
+	rogue_feel = (Uint8 *)format+sizeof(*format);
+	if ( sizeof(*format) == 16 ) {
+		extra_info = ((rogue_feel[1]<<8)|rogue_feel[0]);
+		rogue_feel += sizeof(Uint16);
+	}
+	IMA_ADPCM_state.wSamplesPerBlock = ((rogue_feel[1]<<8)|rogue_feel[0]);
+	return(0);
+}
+
+static Sint32 IMA_ADPCM_nibble(struct IMA_ADPCM_decodestate *state,Uint8 nybble)
+{
+	const Sint32 max_audioval = ((1<<(16-1))-1);
+	const Sint32 min_audioval = -(1<<(16-1));
+	const int index_table[16] = {
+		-1, -1, -1, -1,
+		 2,  4,  6,  8,
+		-1, -1, -1, -1,
+		 2,  4,  6,  8
+	};
+	const Sint32 step_table[89] = {
+		7, 8, 9, 10, 11, 12, 13, 14, 16, 17, 19, 21, 23, 25, 28, 31,
+		34, 37, 41, 45, 50, 55, 60, 66, 73, 80, 88, 97, 107, 118, 130,
+		143, 157, 173, 190, 209, 230, 253, 279, 307, 337, 371, 408,
+		449, 494, 544, 598, 658, 724, 796, 876, 963, 1060, 1166, 1282,
+		1411, 1552, 1707, 1878, 2066, 2272, 2499, 2749, 3024, 3327,
+		3660, 4026, 4428, 4871, 5358, 5894, 6484, 7132, 7845, 8630,
+		9493, 10442, 11487, 12635, 13899, 15289, 16818, 18500, 20350,
+		22385, 24623, 27086, 29794, 32767
+	};
+	Sint32 delta, step;
+
+	/* Compute difference and new sample value */
+	step = step_table[state->index];
+	delta = step >> 3;
+	if ( nybble & 0x04 ) delta += step;
+	if ( nybble & 0x02 ) delta += (step >> 1);
+	if ( nybble & 0x01 ) delta += (step >> 2);
+	if ( nybble & 0x08 ) delta = -delta;
+	state->sample += delta;
+
+	/* Update index value */
+	state->index += index_table[nybble];
+	if ( state->index > 88 ) {
+		state->index = 88;
+	} else
+	if ( state->index < 0 ) {
+		state->index = 0;
+	}
+
+	/* Clamp output sample */
+	if ( state->sample > max_audioval ) {
+		state->sample = max_audioval;
+	} else
+	if ( state->sample < min_audioval ) {
+		state->sample = min_audioval;
+	}
+	return(state->sample);
+}
+
+/* Fill the decode buffer with a channel block of data (8 samples) */
+static void Fill_IMA_ADPCM_block(Uint8 *decoded, Uint8 *encoded,
+	int channel, int numchannels, struct IMA_ADPCM_decodestate *state)
+{
+	int i;
+	Sint8 nybble;
+	Sint32 new_sample;
+
+	decoded += (channel * 2);
+	for ( i=0; i<4; ++i ) {
+		nybble = (*encoded)&0x0F;
+		new_sample = IMA_ADPCM_nibble(state, nybble);
+		decoded[0] = new_sample&0xFF;
+		new_sample >>= 8;
+		decoded[1] = new_sample&0xFF;
+		decoded += 2 * numchannels;
+
+		nybble = (*encoded)>>4;
+		new_sample = IMA_ADPCM_nibble(state, nybble);
+		decoded[0] = new_sample&0xFF;
+		new_sample >>= 8;
+		decoded[1] = new_sample&0xFF;
+		decoded += 2 * numchannels;
+
+		++encoded;
+	}
+}
+
+static int IMA_ADPCM_decode(Uint8 **audio_buf, Uint32 *audio_len)
+{
+	struct IMA_ADPCM_decodestate *state;
+	Uint8 *freeable, *encoded, *decoded;
+	Sint32 encoded_len, samplesleft;
+	unsigned int c, channels;
+
+	/* Check to make sure we have enough variables in the state array */
+	channels = IMA_ADPCM_state.wavefmt.channels;
+	if ( channels > SDL_arraysize(IMA_ADPCM_state.state) ) {
+		SDL_SetError("IMA ADPCM decoder can only handle %d channels",
+					SDL_arraysize(IMA_ADPCM_state.state));
+		return(-1);
+	}
+	state = IMA_ADPCM_state.state;
+
+	/* Allocate the proper sized output buffer */
+	encoded_len = *audio_len;
+	encoded = *audio_buf;
+	freeable = *audio_buf;
+	*audio_len = (encoded_len/IMA_ADPCM_state.wavefmt.blockalign) * 
+				IMA_ADPCM_state.wSamplesPerBlock*
+				IMA_ADPCM_state.wavefmt.channels*sizeof(Sint16);
+	*audio_buf = (Uint8 *)SDL_malloc(*audio_len);
+	if ( *audio_buf == NULL ) {
+		SDL_Error(SDL_ENOMEM);
+		return(-1);
+	}
+	decoded = *audio_buf;
+
+	/* Get ready... Go! */
+	while ( encoded_len >= IMA_ADPCM_state.wavefmt.blockalign ) {
+		/* Grab the initial information for this block */
+		for ( c=0; c<channels; ++c ) {
+			/* Fill the state information for this block */
+			state[c].sample = ((encoded[1]<<8)|encoded[0]);
+			encoded += 2;
+			if ( state[c].sample & 0x8000 ) {
+				state[c].sample -= 0x10000;
+			}
+			state[c].index = *encoded++;
+			/* Reserved byte in buffer header, should be 0 */
+			if ( *encoded++ != 0 ) {
+				/* Uh oh, corrupt data?  Buggy code? */;
+			}
+
+			/* Store the initial sample we start with */
+			decoded[0] = (Uint8)(state[c].sample&0xFF);
+			decoded[1] = (Uint8)(state[c].sample>>8);
+			decoded += 2;
+		}
+
+		/* Decode and store the other samples in this block */
+		samplesleft = (IMA_ADPCM_state.wSamplesPerBlock-1)*channels;
+		while ( samplesleft > 0 ) {
+			for ( c=0; c<channels; ++c ) {
+				Fill_IMA_ADPCM_block(decoded, encoded,
+						c, channels, &state[c]);
+				encoded += 4;
+				samplesleft -= 8;
+			}
+			decoded += (channels * 8 * 2);
+		}
+		encoded_len -= IMA_ADPCM_state.wavefmt.blockalign;
+	}
+	SDL_free(freeable);
+	return(0);
+}
+
+SDL_AudioSpec * SDL_LoadWAV_RW (SDL_RWops *src, int freesrc,
+		SDL_AudioSpec *spec, Uint8 **audio_buf, Uint32 *audio_len)
+{
+	int was_error;
+	Chunk chunk;
+	int lenread;
+	int MS_ADPCM_encoded, IMA_ADPCM_encoded;
+	int samplesize;
+
+	/* WAV magic header */
+	Uint32 RIFFchunk;
+	Uint32 wavelen = 0;
+	Uint32 WAVEmagic;
+	Uint32 headerDiff = 0;
+
+	/* FMT chunk */
+	WaveFMT *format = NULL;
+
+	/* Make sure we are passed a valid data source */
+	was_error = 0;
+	if ( src == NULL ) {
+		was_error = 1;
+		goto done;
+	}
+		
+	/* Check the magic header */
+	RIFFchunk	= SDL_ReadLE32(src);
+	wavelen		= SDL_ReadLE32(src);
+	if ( wavelen == WAVE ) { /* The RIFFchunk has already been read */
+		WAVEmagic = wavelen;
+		wavelen   = RIFFchunk;
+		RIFFchunk = RIFF;
+	} else {
+		WAVEmagic = SDL_ReadLE32(src);
+	}
+	if ( (RIFFchunk != RIFF) || (WAVEmagic != WAVE) ) {
+		SDL_SetError("Unrecognized file type (not WAVE)");
+		was_error = 1;
+		goto done;
+	}
+	headerDiff += sizeof(Uint32); /* for WAVE */
+
+	/* Read the audio data format chunk */
+	chunk.data = NULL;
+	do {
+		if ( chunk.data != NULL ) {
+			SDL_free(chunk.data);
+		}
+		lenread = ReadChunk(src, &chunk);
+		if ( lenread < 0 ) {
+			was_error = 1;
+			goto done;
+		}
+		/* 2 Uint32's for chunk header+len, plus the lenread */
+		headerDiff += lenread + 2 * sizeof(Uint32);
+	} while ( (chunk.magic == FACT) || (chunk.magic == LIST) );
+
+	/* Decode the audio data format */
+	format = (WaveFMT *)chunk.data;
+	if ( chunk.magic != FMT ) {
+		SDL_SetError("Complex WAVE files not supported");
+		was_error = 1;
+		goto done;
+	}
+	MS_ADPCM_encoded = IMA_ADPCM_encoded = 0;
+	switch (SDL_SwapLE16(format->encoding)) {
+		case PCM_CODE:
+			/* We can understand this */
+			break;
+		case MS_ADPCM_CODE:
+			/* Try to understand this */
+			if ( InitMS_ADPCM(format) < 0 ) {
+				was_error = 1;
+				goto done;
+			}
+			MS_ADPCM_encoded = 1;
+			break;
+		case IMA_ADPCM_CODE:
+			/* Try to understand this */
+			if ( InitIMA_ADPCM(format) < 0 ) {
+				was_error = 1;
+				goto done;
+			}
+			IMA_ADPCM_encoded = 1;
+			break;
+		case MP3_CODE:
+			SDL_SetError("MPEG Layer 3 data not supported",
+					SDL_SwapLE16(format->encoding));
+			was_error = 1;
+			goto done;
+		default:
+			SDL_SetError("Unknown WAVE data format: 0x%.4x",
+					SDL_SwapLE16(format->encoding));
+			was_error = 1;
+			goto done;
+	}
+	SDL_memset(spec, 0, (sizeof *spec));
+	spec->freq = SDL_SwapLE32(format->frequency);
+	switch (SDL_SwapLE16(format->bitspersample)) {
+		case 4:
+			if ( MS_ADPCM_encoded || IMA_ADPCM_encoded ) {
+				spec->format = AUDIO_S16;
+			} else {
+				was_error = 1;
+			}
+			break;
+		case 8:
+			spec->format = AUDIO_U8;
+			break;
+		case 16:
+			spec->format = AUDIO_S16;
+			break;
+		default:
+			was_error = 1;
+			break;
+	}
+	if ( was_error ) {
+		SDL_SetError("Unknown %d-bit PCM data format",
+			SDL_SwapLE16(format->bitspersample));
+		goto done;
+	}
+	spec->channels = (Uint8)SDL_SwapLE16(format->channels);
+	spec->samples = 4096;		/* Good default buffer size */
+
+	/* Read the audio data chunk */
+	*audio_buf = NULL;
+	do {
+		if ( *audio_buf != NULL ) {
+			SDL_free(*audio_buf);
+		}
+		lenread = ReadChunk(src, &chunk);
+		if ( lenread < 0 ) {
+			was_error = 1;
+			goto done;
+		}
+		*audio_len = lenread;
+		*audio_buf = chunk.data;
+		if(chunk.magic != DATA) headerDiff += lenread + 2 * sizeof(Uint32);
+	} while ( chunk.magic != DATA );
+	headerDiff += 2 * sizeof(Uint32); /* for the data chunk and len */
+
+	if ( MS_ADPCM_encoded ) {
+		if ( MS_ADPCM_decode(audio_buf, audio_len) < 0 ) {
+			was_error = 1;
+			goto done;
+		}
+	}
+	if ( IMA_ADPCM_encoded ) {
+		if ( IMA_ADPCM_decode(audio_buf, audio_len) < 0 ) {
+			was_error = 1;
+			goto done;
+		}
+	}
+
+	/* Don't return a buffer that isn't a multiple of samplesize */
+	samplesize = ((spec->format & 0xFF)/8)*spec->channels;
+	*audio_len &= ~(samplesize-1);
+
+done:
+	if ( format != NULL ) {
+		SDL_free(format);
+	}
+	if ( src ) {
+		if ( freesrc ) {
+			SDL_RWclose(src);
+		} else {
+			/* seek to the end of the file (given by the RIFF chunk) */
+			SDL_RWseek(src, wavelen - chunk.length - headerDiff, RW_SEEK_CUR);
+		}
+	}
+	if ( was_error ) {
+		spec = NULL;
+	}
+	return(spec);
+}
+
+/* Since the WAV memory is allocated in the shared library, it must also
+   be freed here.  (Necessary under Win32, VC++)
+ */
+void SDL_FreeWAV(Uint8 *audio_buf)
+{
+	if ( audio_buf != NULL ) {
+		SDL_free(audio_buf);
+	}
+}
+
+static int ReadChunk(SDL_RWops *src, Chunk *chunk)
+{
+	chunk->magic	= SDL_ReadLE32(src);
+	chunk->length	= SDL_ReadLE32(src);
+	chunk->data = (Uint8 *)SDL_malloc(chunk->length);
+	if ( chunk->data == NULL ) {
+		SDL_Error(SDL_ENOMEM);
+		return(-1);
+	}
+	if ( SDL_RWread(src, chunk->data, chunk->length, 1) != 1 ) {
+		SDL_Error(SDL_EFREAD);
+		SDL_free(chunk->data);
+		return(-1);
+	}
+	return(chunk->length);
+}

src/dep/src/SDL/audio/SDL_wave.h

@@ -0,0 +1,62 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2006 Sam Lantinga
+
+    This library is SDL_free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+    Sam Lantinga
+    slouken@libsdl.org
+*/
+#include "SDL_config.h"
+
+/* WAVE files are little-endian */
+
+/*******************************************/
+/* Define values for Microsoft WAVE format */
+/*******************************************/
+#define RIFF		0x46464952		/* "RIFF" */
+#define WAVE		0x45564157		/* "WAVE" */
+#define FACT		0x74636166		/* "fact" */
+#define LIST		0x5453494c		/* "LIST" */
+#define FMT		0x20746D66		/* "fmt " */
+#define DATA		0x61746164		/* "data" */
+#define PCM_CODE	0x0001
+#define MS_ADPCM_CODE	0x0002
+#define IMA_ADPCM_CODE	0x0011
+#define MP3_CODE	0x0055
+#define WAVE_MONO	1
+#define WAVE_STEREO	2
+
+/* Normally, these three chunks come consecutively in a WAVE file */
+typedef struct WaveFMT {
+/* Not saved in the chunk we read:
+	Uint32	FMTchunk;
+	Uint32	fmtlen;
+*/
+	Uint16	encoding;	
+	Uint16	channels;		/* 1 = mono, 2 = stereo */
+	Uint32	frequency;		/* One of 11025, 22050, or 44100 Hz */
+	Uint32	byterate;		/* Average bytes per second */
+	Uint16	blockalign;		/* Bytes per sample block */
+	Uint16	bitspersample;		/* One of 8, 12, 16, or 4 for ADPCM */
+} WaveFMT;
+
+/* The general chunk found in the WAVE file */
+typedef struct Chunk {
+	Uint32 magic;
+	Uint32 length;
+	Uint8 *data;
+} Chunk;
+

src/dep/src/SDL/audio/alsa/SDL_alsa_audio.c

@@ -0,0 +1,538 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2004 Sam Lantinga
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Library General Public
+    License as published by the Free Software Foundation; either
+    version 2 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Library General Public License for more details.
+
+    You should have received a copy of the GNU Library General Public
+    License along with this library; if not, write to the Free
+    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+    Sam Lantinga
+    slouken@libsdl.org
+*/
+#include "SDL_config.h"
+
+/* Allow access to a raw mixing buffer */
+
+#include <sys/types.h>
+#include <signal.h>	/* For kill() */
+
+#include "SDL_timer.h"
+#include "SDL_audio.h"
+#include "../SDL_audiomem.h"
+#include "../SDL_audio_c.h"
+#include "SDL_alsa_audio.h"
+
+#ifdef SDL_AUDIO_DRIVER_ALSA_DYNAMIC
+#include <dlfcn.h>
+#include "SDL_name.h"
+#include "SDL_loadso.h"
+#else
+#define SDL_NAME(X)	X
+#endif
+
+
+/* The tag name used by ALSA audio */
+#define DRIVER_NAME         "alsa"
+
+/* The default ALSA audio driver */
+#define DEFAULT_DEVICE	"default"
+
+/* Audio driver functions */
+static int ALSA_OpenAudio(_THIS, SDL_AudioSpec *spec);
+static void ALSA_WaitAudio(_THIS);
+static void ALSA_PlayAudio(_THIS);
+static Uint8 *ALSA_GetAudioBuf(_THIS);
+static void ALSA_CloseAudio(_THIS);
+
+#ifdef SDL_AUDIO_DRIVER_ALSA_DYNAMIC
+
+static const char *alsa_library = SDL_AUDIO_DRIVER_ALSA_DYNAMIC;
+static void *alsa_handle = NULL;
+static int alsa_loaded = 0;
+
+static int (*SDL_snd_pcm_open)(snd_pcm_t **pcm, const char *name, snd_pcm_stream_t stream, int mode);
+static int (*SDL_NAME(snd_pcm_open))(snd_pcm_t **pcm, const char *name, snd_pcm_stream_t stream, int mode);
+static int (*SDL_NAME(snd_pcm_close))(snd_pcm_t *pcm);
+static snd_pcm_sframes_t (*SDL_NAME(snd_pcm_writei))(snd_pcm_t *pcm, const void *buffer, snd_pcm_uframes_t size);
+static int (*SDL_NAME(snd_pcm_resume))(snd_pcm_t *pcm);
+static int (*SDL_NAME(snd_pcm_prepare))(snd_pcm_t *pcm);
+static int (*SDL_NAME(snd_pcm_drain))(snd_pcm_t *pcm);
+static const char *(*SDL_NAME(snd_strerror))(int errnum);
+static size_t (*SDL_NAME(snd_pcm_hw_params_sizeof))(void);
+static size_t (*SDL_NAME(snd_pcm_sw_params_sizeof))(void);
+static int (*SDL_NAME(snd_pcm_hw_params_any))(snd_pcm_t *pcm, snd_pcm_hw_params_t *params);
+static int (*SDL_NAME(snd_pcm_hw_params_set_access))(snd_pcm_t *pcm, snd_pcm_hw_params_t *params, snd_pcm_access_t access);
+static int (*SDL_NAME(snd_pcm_hw_params_set_format))(snd_pcm_t *pcm, snd_pcm_hw_params_t *params, snd_pcm_format_t val);
+static int (*SDL_NAME(snd_pcm_hw_params_set_channels))(snd_pcm_t *pcm, snd_pcm_hw_params_t *params, unsigned int val);
+static int (*SDL_NAME(snd_pcm_hw_params_get_channels))(const snd_pcm_hw_params_t *params);
+static unsigned int (*SDL_NAME(snd_pcm_hw_params_set_rate_near))(snd_pcm_t *pcm, snd_pcm_hw_params_t *params, unsigned int val, int *dir);
+static snd_pcm_uframes_t (*SDL_NAME(snd_pcm_hw_params_set_period_size_near))(snd_pcm_t *pcm, snd_pcm_hw_params_t *params, snd_pcm_uframes_t val, int *dir);
+static snd_pcm_sframes_t (*SDL_NAME(snd_pcm_hw_params_get_period_size))(const snd_pcm_hw_params_t *params);
+static unsigned int (*SDL_NAME(snd_pcm_hw_params_set_periods_near))(snd_pcm_t *pcm, snd_pcm_hw_params_t *params, unsigned int val, int *dir);
+static int (*SDL_NAME(snd_pcm_hw_params_get_periods))(snd_pcm_hw_params_t *params);
+static int (*SDL_NAME(snd_pcm_hw_params))(snd_pcm_t *pcm, snd_pcm_hw_params_t *params);
+/*
+*/
+static int (*SDL_NAME(snd_pcm_sw_params_current))(snd_pcm_t *pcm, snd_pcm_sw_params_t *swparams);
+static int (*SDL_NAME(snd_pcm_sw_params_set_start_threshold))(snd_pcm_t *pcm, snd_pcm_sw_params_t *params, snd_pcm_uframes_t val);
+static int (*SDL_NAME(snd_pcm_sw_params_set_avail_min))(snd_pcm_t *pcm, snd_pcm_sw_params_t *params, snd_pcm_uframes_t val);
+static int (*SDL_NAME(snd_pcm_sw_params))(snd_pcm_t *pcm, snd_pcm_sw_params_t *params);
+static int (*SDL_NAME(snd_pcm_nonblock))(snd_pcm_t *pcm, int nonblock);
+#define snd_pcm_hw_params_sizeof SDL_NAME(snd_pcm_hw_params_sizeof)
+#define snd_pcm_sw_params_sizeof SDL_NAME(snd_pcm_sw_params_sizeof)
+
+/* cast funcs to char* first, to please GCC's strict aliasing rules. */
+static struct {
+	const char *name;
+	void **func;
+} alsa_functions[] = {
+	{ "snd_pcm_open",	(void**)(char*)&SDL_NAME(snd_pcm_open)		},
+	{ "snd_pcm_close",	(void**)(char*)&SDL_NAME(snd_pcm_close)	},
+	{ "snd_pcm_writei",	(void**)(char*)&SDL_NAME(snd_pcm_writei)	},
+	{ "snd_pcm_resume",	(void**)(char*)&SDL_NAME(snd_pcm_resume)	},
+	{ "snd_pcm_prepare",	(void**)(char*)&SDL_NAME(snd_pcm_prepare)	},
+	{ "snd_pcm_drain",	(void**)(char*)&SDL_NAME(snd_pcm_drain)	},
+	{ "snd_strerror",	(void**)(char*)&SDL_NAME(snd_strerror)		},
+	{ "snd_pcm_hw_params_sizeof",		(void**)(char*)&SDL_NAME(snd_pcm_hw_params_sizeof)		},
+	{ "snd_pcm_sw_params_sizeof",		(void**)(char*)&SDL_NAME(snd_pcm_sw_params_sizeof)		},
+	{ "snd_pcm_hw_params_any",		(void**)(char*)&SDL_NAME(snd_pcm_hw_params_any)		},
+	{ "snd_pcm_hw_params_set_access",	(void**)(char*)&SDL_NAME(snd_pcm_hw_params_set_access)		},
+	{ "snd_pcm_hw_params_set_format",	(void**)(char*)&SDL_NAME(snd_pcm_hw_params_set_format)		},
+	{ "snd_pcm_hw_params_set_channels",	(void**)(char*)&SDL_NAME(snd_pcm_hw_params_set_channels)	},
+	{ "snd_pcm_hw_params_get_channels",	(void**)(char*)&SDL_NAME(snd_pcm_hw_params_get_channels)	},
+	{ "snd_pcm_hw_params_set_rate_near",	(void**)(char*)&SDL_NAME(snd_pcm_hw_params_set_rate_near)	},
+	{ "snd_pcm_hw_params_set_period_size_near",	(void**)(char*)&SDL_NAME(snd_pcm_hw_params_set_period_size_near)	},
+	{ "snd_pcm_hw_params_get_period_size",	(void**)(char*)&SDL_NAME(snd_pcm_hw_params_get_period_size)	},
+	{ "snd_pcm_hw_params_set_periods_near",	(void**)(char*)&SDL_NAME(snd_pcm_hw_params_set_periods_near)	},
+	{ "snd_pcm_hw_params_get_periods",	(void**)(char*)&SDL_NAME(snd_pcm_hw_params_get_periods)	},
+	{ "snd_pcm_hw_params",	(void**)(char*)&SDL_NAME(snd_pcm_hw_params)	},
+	{ "snd_pcm_sw_params_current",	(void**)(char*)&SDL_NAME(snd_pcm_sw_params_current)	},
+	{ "snd_pcm_sw_params_set_start_threshold",	(void**)(char*)&SDL_NAME(snd_pcm_sw_params_set_start_threshold)	},
+	{ "snd_pcm_sw_params_set_avail_min",	(void**)(char*)&SDL_NAME(snd_pcm_sw_params_set_avail_min)	},
+	{ "snd_pcm_sw_params",	(void**)(char*)&SDL_NAME(snd_pcm_sw_params)	},
+	{ "snd_pcm_nonblock",	(void**)(char*)&SDL_NAME(snd_pcm_nonblock)	},
+};
+
+static void UnloadALSALibrary(void) {
+	if (alsa_loaded) {
+/*		SDL_UnloadObject(alsa_handle);*/
+		dlclose(alsa_handle);
+		alsa_handle = NULL;
+		alsa_loaded = 0;
+	}
+}
+
+static int LoadALSALibrary(void) {
+	int i, retval = -1;
+
+/*	alsa_handle = SDL_LoadObject(alsa_library);*/
+	alsa_handle = dlopen(alsa_library,RTLD_NOW);
+	if (alsa_handle) {
+		alsa_loaded = 1;
+		retval = 0;
+		for (i = 0; i < SDL_arraysize(alsa_functions); i++) {
+/*			*alsa_functions[i].func = SDL_LoadFunction(alsa_handle,alsa_functions[i].name);*/
+#if HAVE_DLVSYM
+			*alsa_functions[i].func = dlvsym(alsa_handle,alsa_functions[i].name,"ALSA_0.9");
+			if (!*alsa_functions[i].func)
+#endif
+				*alsa_functions[i].func = dlsym(alsa_handle,alsa_functions[i].name);
+			if (!*alsa_functions[i].func) {
+				retval = -1;
+				UnloadALSALibrary();
+				break;
+			}
+		}
+	}
+	return retval;
+}
+
+#else
+
+static void UnloadALSALibrary(void) {
+	return;
+}
+
+static int LoadALSALibrary(void) {
+	return 0;
+}
+
+#endif /* SDL_AUDIO_DRIVER_ALSA_DYNAMIC */
+
+static const char *get_audio_device(int channels)
+{
+	const char *device;
+	
+	device = SDL_getenv("AUDIODEV");	/* Is there a standard variable name? */
+	if ( device == NULL ) {
+		if (channels == 6) device = "surround51";
+		else if (channels == 4) device = "surround40";
+		else device = DEFAULT_DEVICE;
+	}
+	return device;
+}
+
+/* Audio driver bootstrap functions */
+
+static int Audio_Available(void)
+{
+	int available;
+	int status;
+	snd_pcm_t *handle;
+
+	available = 0;
+	if (LoadALSALibrary() < 0) {
+		return available;
+	}
+	status = SDL_NAME(snd_pcm_open)(&handle, get_audio_device(2), SND_PCM_STREAM_PLAYBACK, SND_PCM_NONBLOCK);
+	if ( status >= 0 ) {
+		available = 1;
+        	SDL_NAME(snd_pcm_close)(handle);
+	}
+	UnloadALSALibrary();
+	return(available);
+}
+
+static void Audio_DeleteDevice(SDL_AudioDevice *device)
+{
+	SDL_free(device->hidden);
+	SDL_free(device);
+	UnloadALSALibrary();
+}
+
+static SDL_AudioDevice *Audio_CreateDevice(int devindex)
+{
+	SDL_AudioDevice *this;
+
+	/* Initialize all variables that we clean on shutdown */
+	LoadALSALibrary();
+	this = (SDL_AudioDevice *)SDL_malloc(sizeof(SDL_AudioDevice));
+	if ( this ) {
+		SDL_memset(this, 0, (sizeof *this));
+		this->hidden = (struct SDL_PrivateAudioData *)
+				SDL_malloc((sizeof *this->hidden));
+	}
+	if ( (this == NULL) || (this->hidden == NULL) ) {
+		SDL_OutOfMemory();
+		if ( this ) {
+			SDL_free(this);
+		}
+		return(0);
+	}
+	SDL_memset(this->hidden, 0, (sizeof *this->hidden));
+
+	/* Set the function pointers */
+	this->OpenAudio = ALSA_OpenAudio;
+	this->WaitAudio = ALSA_WaitAudio;
+	this->PlayAudio = ALSA_PlayAudio;
+	this->GetAudioBuf = ALSA_GetAudioBuf;
+	this->CloseAudio = ALSA_CloseAudio;
+
+	this->free = Audio_DeleteDevice;
+
+	return this;
+}
+
+AudioBootStrap ALSA_bootstrap = {
+	DRIVER_NAME, "ALSA 0.9 PCM audio",
+	Audio_Available, Audio_CreateDevice
+};
+
+/* This function waits until it is possible to write a full sound buffer */
+static void ALSA_WaitAudio(_THIS)
+{
+	/* Check to see if the thread-parent process is still alive */
+	{ static int cnt = 0;
+		/* Note that this only works with thread implementations 
+		   that use a different process id for each thread.
+		*/
+		if (parent && (((++cnt)%10) == 0)) { /* Check every 10 loops */
+			if ( kill(parent, 0) < 0 ) {
+				this->enabled = 0;
+			}
+		}
+	}
+}
+
+
+/*
+ * http://bugzilla.libsdl.org/show_bug.cgi?id=110
+ * "For Linux ALSA, this is FL-FR-RL-RR-C-LFE
+ *  and for Windows DirectX [and CoreAudio], this is FL-FR-C-LFE-RL-RR"
+ */
+#define SWIZ6(T) \
+    T *ptr = (T *) mixbuf; \
+    const Uint32 count = (this->spec.samples / 6); \
+    Uint32 i; \
+    for (i = 0; i < count; i++, ptr += 6) { \
+        T tmp; \
+        tmp = ptr[2]; ptr[2] = ptr[4]; ptr[4] = tmp; \
+        tmp = ptr[3]; ptr[3] = ptr[5]; ptr[5] = tmp; \
+    }
+
+static __inline__ void swizzle_alsa_channels_6_64bit(_THIS) { SWIZ6(Uint64); }
+static __inline__ void swizzle_alsa_channels_6_32bit(_THIS) { SWIZ6(Uint32); }
+static __inline__ void swizzle_alsa_channels_6_16bit(_THIS) { SWIZ6(Uint16); }
+static __inline__ void swizzle_alsa_channels_6_8bit(_THIS) { SWIZ6(Uint8); }
+
+#undef SWIZ6
+
+
+/*
+ * Called right before feeding this->mixbuf to the hardware. Swizzle channels
+ *  from Windows/Mac order to the format alsalib will want.
+ */
+static __inline__ void swizzle_alsa_channels(_THIS)
+{
+    if (this->spec.channels == 6) {
+        const Uint16 fmtsize = (this->spec.format & 0xFF); /* bits/channel. */
+        if (fmtsize == 16)
+            swizzle_alsa_channels_6_16bit(this);
+        else if (fmtsize == 8)
+            swizzle_alsa_channels_6_8bit(this);
+        else if (fmtsize == 32)
+            swizzle_alsa_channels_6_32bit(this);
+        else if (fmtsize == 64)
+            swizzle_alsa_channels_6_64bit(this);
+    }
+
+    /* !!! FIXME: update this for 7.1 if needed, later. */
+}
+
+
+static void ALSA_PlayAudio(_THIS)
+{
+	int           status;
+	int           sample_len;
+	signed short *sample_buf;
+
+	swizzle_alsa_channels(this);
+
+	sample_len = this->spec.samples;
+	sample_buf = (signed short *)mixbuf;
+
+	while ( sample_len > 0 ) {
+		status = SDL_NAME(snd_pcm_writei)(pcm_handle, sample_buf, sample_len);
+		if ( status < 0 ) {
+			if ( status == -EAGAIN ) {
+				SDL_Delay(1);
+				continue;
+			}
+			if ( status == -ESTRPIPE ) {
+				do {
+					SDL_Delay(1);
+					status = SDL_NAME(snd_pcm_resume)(pcm_handle);
+				} while ( status == -EAGAIN );
+			}
+			if ( status < 0 ) {
+				status = SDL_NAME(snd_pcm_prepare)(pcm_handle);
+			}
+			if ( status < 0 ) {
+				/* Hmm, not much we can do - abort */
+				this->enabled = 0;
+				return;
+			}
+			continue;
+		}
+		sample_buf += status * this->spec.channels;
+		sample_len -= status;
+	}
+}
+
+static Uint8 *ALSA_GetAudioBuf(_THIS)
+{
+	return(mixbuf);
+}
+
+static void ALSA_CloseAudio(_THIS)
+{
+	if ( mixbuf != NULL ) {
+		SDL_FreeAudioMem(mixbuf);
+		mixbuf = NULL;
+	}
+	if ( pcm_handle ) {
+		SDL_NAME(snd_pcm_drain)(pcm_handle);
+		SDL_NAME(snd_pcm_close)(pcm_handle);
+		pcm_handle = NULL;
+	}
+}
+
+static int ALSA_OpenAudio(_THIS, SDL_AudioSpec *spec)
+{
+	int                  status;
+	snd_pcm_hw_params_t *hwparams;
+	snd_pcm_sw_params_t *swparams;
+	snd_pcm_format_t     format;
+	snd_pcm_uframes_t    frames;
+	Uint16               test_format;
+
+	/* Open the audio device */
+	/* Name of device should depend on # channels in spec */
+	status = SDL_NAME(snd_pcm_open)(&pcm_handle, get_audio_device(spec->channels), SND_PCM_STREAM_PLAYBACK, SND_PCM_NONBLOCK);
+
+	if ( status < 0 ) {
+		SDL_SetError("Couldn't open audio device: %s", SDL_NAME(snd_strerror)(status));
+		return(-1);
+	}
+
+	/* Figure out what the hardware is capable of */
+	snd_pcm_hw_params_alloca(&hwparams);
+	status = SDL_NAME(snd_pcm_hw_params_any)(pcm_handle, hwparams);
+	if ( status < 0 ) {
+		SDL_SetError("Couldn't get hardware config: %s", SDL_NAME(snd_strerror)(status));
+		ALSA_CloseAudio(this);
+		return(-1);
+	}
+
+	/* SDL only uses interleaved sample output */
+	status = SDL_NAME(snd_pcm_hw_params_set_access)(pcm_handle, hwparams, SND_PCM_ACCESS_RW_INTERLEAVED);
+	if ( status < 0 ) {
+		SDL_SetError("Couldn't set interleaved access: %s", SDL_NAME(snd_strerror)(status));
+		ALSA_CloseAudio(this);
+		return(-1);
+	}
+
+	/* Try for a closest match on audio format */
+	status = -1;
+	for ( test_format = SDL_FirstAudioFormat(spec->format);
+	      test_format && (status < 0); ) {
+		switch ( test_format ) {
+			case AUDIO_U8:
+				format = SND_PCM_FORMAT_U8;
+				break;
+			case AUDIO_S8:
+				format = SND_PCM_FORMAT_S8;
+				break;
+			case AUDIO_S16LSB:
+				format = SND_PCM_FORMAT_S16_LE;
+				break;
+			case AUDIO_S16MSB:
+				format = SND_PCM_FORMAT_S16_BE;
+				break;
+			case AUDIO_U16LSB:
+				format = SND_PCM_FORMAT_U16_LE;
+				break;
+			case AUDIO_U16MSB:
+				format = SND_PCM_FORMAT_U16_BE;
+				break;
+			default:
+				format = 0;
+				break;
+		}
+		if ( format != 0 ) {
+			status = SDL_NAME(snd_pcm_hw_params_set_format)(pcm_handle, hwparams, format);
+		}
+		if ( status < 0 ) {
+			test_format = SDL_NextAudioFormat();
+		}
+	}
+	if ( status < 0 ) {
+		SDL_SetError("Couldn't find any hardware audio formats");
+		ALSA_CloseAudio(this);
+		return(-1);
+	}
+	spec->format = test_format;
+
+	/* Set the number of channels */
+	status = SDL_NAME(snd_pcm_hw_params_set_channels)(pcm_handle, hwparams, spec->channels);
+	if ( status < 0 ) {
+		status = SDL_NAME(snd_pcm_hw_params_get_channels)(hwparams);
+		if ( (status <= 0) || (status > 2) ) {
+			SDL_SetError("Couldn't set audio channels");
+			ALSA_CloseAudio(this);
+			return(-1);
+		}
+		spec->channels = status;
+	}
+
+	/* Set the audio rate */
+	status = SDL_NAME(snd_pcm_hw_params_set_rate_near)(pcm_handle, hwparams, spec->freq, NULL);
+	if ( status < 0 ) {
+		SDL_SetError("Couldn't set audio frequency: %s", SDL_NAME(snd_strerror)(status));
+		ALSA_CloseAudio(this);
+		return(-1);
+	}
+	spec->freq = status;
+
+	/* Set the buffer size, in samples */
+	frames = spec->samples;
+	frames = SDL_NAME(snd_pcm_hw_params_set_period_size_near)(pcm_handle, hwparams, frames, NULL);
+	spec->samples = frames;
+	SDL_NAME(snd_pcm_hw_params_set_periods_near)(pcm_handle, hwparams, 2, NULL);
+
+	/* "set" the hardware with the desired parameters */
+	status = SDL_NAME(snd_pcm_hw_params)(pcm_handle, hwparams);
+	if ( status < 0 ) {
+		SDL_SetError("Couldn't set hardware audio parameters: %s", SDL_NAME(snd_strerror)(status));
+		ALSA_CloseAudio(this);
+		return(-1);
+	}
+
+/* This is useful for debugging... */
+/*
+{ snd_pcm_sframes_t bufsize; int fragments;
+   bufsize = SDL_NAME(snd_pcm_hw_params_get_period_size)(hwparams);
+   fragments = SDL_NAME(snd_pcm_hw_params_get_periods)(hwparams);
+
+   fprintf(stderr, "ALSA: bufsize = %ld, fragments = %d\n", bufsize, fragments);
+}
+*/
+
+	/* Set the software parameters */
+	snd_pcm_sw_params_alloca(&swparams);
+	status = SDL_NAME(snd_pcm_sw_params_current)(pcm_handle, swparams);
+	if ( status < 0 ) {
+		SDL_SetError("Couldn't get software config: %s", SDL_NAME(snd_strerror)(status));
+		ALSA_CloseAudio(this);
+		return(-1);
+	}
+	status = SDL_NAME(snd_pcm_sw_params_set_start_threshold)(pcm_handle, swparams, 0);
+	if ( status < 0 ) {
+		SDL_SetError("Couldn't set start threshold: %s", SDL_NAME(snd_strerror)(status));
+		ALSA_CloseAudio(this);
+		return(-1);
+	}
+	status = SDL_NAME(snd_pcm_sw_params_set_avail_min)(pcm_handle, swparams, frames);
+	if ( status < 0 ) {
+		SDL_SetError("Couldn't set avail min: %s", SDL_NAME(snd_strerror)(status));
+		ALSA_CloseAudio(this);
+		return(-1);
+	}
+	status = SDL_NAME(snd_pcm_sw_params)(pcm_handle, swparams);
+	if ( status < 0 ) {
+		SDL_SetError("Couldn't set software audio parameters: %s", SDL_NAME(snd_strerror)(status));
+		ALSA_CloseAudio(this);
+		return(-1);
+	}
+
+	/* Calculate the final parameters for this audio specification */
+	SDL_CalculateAudioSpec(spec);
+
+	/* Allocate mixing buffer */
+	mixlen = spec->size;
+	mixbuf = (Uint8 *)SDL_AllocAudioMem(mixlen);
+	if ( mixbuf == NULL ) {
+		ALSA_CloseAudio(this);
+		return(-1);
+	}
+	SDL_memset(mixbuf, spec->silence, spec->size);
+
+	/* Get the parent process id (we're the parent of the audio thread) */
+	parent = getpid();
+
+	/* Switch to blocking mode for playback */
+	SDL_NAME(snd_pcm_nonblock)(pcm_handle, 0);
+
+	/* We're ready to rock and roll. :-) */
+	return(0);
+}

src/dep/src/SDL/audio/alsa/SDL_alsa_audio.h

@@ -0,0 +1,54 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2004 Sam Lantinga
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Library General Public
+    License as published by the Free Software Foundation; either
+    version 2 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Library General Public License for more details.
+
+    You should have received a copy of the GNU Library General Public
+    License along with this library; if not, write to the Free
+    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+    Sam Lantinga
+    slouken@libsdl.org
+*/
+#include "SDL_config.h"
+
+#ifndef _ALSA_PCM_audio_h
+#define _ALSA_PCM_audio_h
+
+#define ALSA_PCM_OLD_HW_PARAMS_API
+#define ALSA_PCM_OLD_SW_PARAMS_API
+#include <alsa/asoundlib.h>
+
+#include "../SDL_sysaudio.h"
+
+/* Hidden "this" pointer for the video functions */
+#define _THIS	SDL_AudioDevice *this
+
+struct SDL_PrivateAudioData {
+	/* The audio device handle */
+	snd_pcm_t *pcm_handle;
+
+	/* The parent process id, to detect when application quits */
+	pid_t parent;
+
+	/* Raw mixing buffer */
+	Uint8 *mixbuf;
+	int    mixlen;
+};
+
+/* Old variable names */
+#define pcm_handle		(this->hidden->pcm_handle)
+#define parent			(this->hidden->parent)
+#define mixbuf			(this->hidden->mixbuf)
+#define mixlen			(this->hidden->mixlen)
+
+#endif /* _ALSA_PCM_audio_h */

src/dep/src/SDL/audio/amigaos/SDL_ahiaudio.c

@@ -0,0 +1,337 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2006 Sam Lantinga
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+    Sam Lantinga
+    slouken@libsdl.org
+*/
+#include "SDL_config.h"
+
+/* Allow access to a raw mixing buffer (for AmigaOS) */
+
+#include "SDL_audio.h"
+#include "../SDL_audio_c.h"
+#include "SDL_ahiaudio.h"
+
+/* Audio driver functions */
+static int AHI_OpenAudio(_THIS, SDL_AudioSpec *spec);
+static void AHI_WaitAudio(_THIS);
+static void AHI_PlayAudio(_THIS);
+static Uint8 *AHI_GetAudioBuf(_THIS);
+static void AHI_CloseAudio(_THIS);
+
+#ifndef __SASC
+	#define mymalloc(x) AllocVec(x,MEMF_PUBLIC) 
+	#define myfree FreeVec
+#else
+	#define mymalloc malloc
+	#define myfree free
+#endif
+
+/* Audio driver bootstrap functions */
+
+static int Audio_Available(void)
+{
+	int ok=0;
+	struct MsgPort *p;
+	struct AHIRequest *req;
+
+	if(p=CreateMsgPort())
+	{
+		if(req=(struct AHIRequest *)CreateIORequest(p,sizeof(struct AHIRequest)))
+		{
+			req->ahir_Version=4;
+
+			if(!OpenDevice(AHINAME,0,(struct IORequest *)req,NULL))
+			{
+				D(bug("AHI available.\n"));
+				ok=1;
+				CloseDevice((struct IORequest *)req);
+			}
+			DeleteIORequest((struct IORequest *)req);
+		}
+		DeleteMsgPort(p);
+	}
+
+	D(if(!ok) bug("AHI not available\n"));
+	return ok;
+}
+
+static void Audio_DeleteDevice(SDL_AudioDevice *device)
+{
+	SDL_free(device->hidden);
+	SDL_free(device);
+}
+
+static SDL_AudioDevice *Audio_CreateDevice(int devindex)
+{
+	SDL_AudioDevice *this;
+
+#ifndef NO_AMIGADEBUG
+	D(bug("AHI created...\n"));
+#endif
+
+	/* Initialize all variables that we clean on shutdown */
+	this = (SDL_AudioDevice *)SDL_malloc(sizeof(SDL_AudioDevice));
+	if ( this ) {
+		SDL_memset(this, 0, (sizeof *this));
+		this->hidden = (struct SDL_PrivateAudioData *)
+				SDL_malloc((sizeof *this->hidden));
+	}
+	if ( (this == NULL) || (this->hidden == NULL) ) {
+		SDL_OutOfMemory();
+		if ( this ) {
+			SDL_free(this);
+		}
+		return(0);
+	}
+	SDL_memset(this->hidden, 0, (sizeof *this->hidden));
+
+	/* Set the function pointers */
+	this->OpenAudio = AHI_OpenAudio;
+	this->WaitAudio = AHI_WaitAudio;
+	this->PlayAudio = AHI_PlayAudio;
+	this->GetAudioBuf = AHI_GetAudioBuf;
+	this->CloseAudio = AHI_CloseAudio;
+
+	this->free = Audio_DeleteDevice;
+
+	return this;
+}
+
+AudioBootStrap AHI_bootstrap = {
+	"AHI", Audio_Available, Audio_CreateDevice
+};
+
+
+void static AHI_WaitAudio(_THIS)
+{
+	if(!CheckIO((struct IORequest *)audio_req[current_buffer]))
+	{
+		WaitIO((struct IORequest *)audio_req[current_buffer]);
+//		AbortIO((struct IORequest *)audio_req[current_buffer]);
+	}
+}
+
+static void AHI_PlayAudio(_THIS)
+{
+	if(playing>1)
+		WaitIO((struct IORequest *)audio_req[current_buffer]);
+
+	/* Write the audio data out */
+	audio_req[current_buffer] -> ahir_Std. io_Message.mn_Node.ln_Pri = 60;
+	audio_req[current_buffer] -> ahir_Std. io_Data                = mixbuf[current_buffer];
+	audio_req[current_buffer] -> ahir_Std. io_Length              = this->hidden->size;
+	audio_req[current_buffer] -> ahir_Std. io_Offset              = 0;
+	audio_req[current_buffer] -> ahir_Std . io_Command            = CMD_WRITE;
+	audio_req[current_buffer] -> ahir_Frequency                   = this->hidden->freq;
+	audio_req[current_buffer] -> ahir_Volume                      = 0x10000;
+	audio_req[current_buffer] -> ahir_Type                        = this->hidden->type;
+	audio_req[current_buffer] -> ahir_Position                    = 0x8000;
+	audio_req[current_buffer] -> ahir_Link                        = (playing>0 ? audio_req[current_buffer^1] : NULL);
+
+	SendIO((struct IORequest *)audio_req[current_buffer]);
+	current_buffer^=1;
+
+	playing++;
+}
+
+static Uint8 *AHI_GetAudioBuf(_THIS)
+{
+	return(mixbuf[current_buffer]);
+}
+
+static void AHI_CloseAudio(_THIS)
+{
+	D(bug("Closing audio...\n"));
+
+	playing=0;
+
+	if(audio_req[0])
+	{
+		if(audio_req[1])
+		{
+			D(bug("Break req[1]...\n"));
+
+			AbortIO((struct IORequest *)audio_req[1]);
+			WaitIO((struct IORequest *)audio_req[1]);
+		}
+
+		D(bug("Break req[0]...\n"));
+
+		AbortIO((struct IORequest *)audio_req[0]);
+		WaitIO((struct IORequest *)audio_req[0]);
+
+		if(audio_req[1])
+		{
+			D(bug("Break AGAIN req[1]...\n"));
+			AbortIO((struct IORequest *)audio_req[1]);
+			WaitIO((struct IORequest *)audio_req[1]);
+		}
+// Double abort to be sure to break the dbuffering process.
+
+		SDL_Delay(200);
+
+		D(bug("Reqs breaked, closing device...\n"));
+		CloseDevice((struct IORequest *)audio_req[0]);
+		D(bug("Device closed, freeing memory...\n"));
+		myfree(audio_req[1]);
+		D(bug("Memory freed, deleting IOReq...\n")); 
+		DeleteIORequest((struct IORequest *)audio_req[0]);
+		audio_req[0]=audio_req[1]=NULL;
+	}
+
+	D(bug("Freeing mixbuf[0]...\n"));
+	if ( mixbuf[0] != NULL ) {
+		myfree(mixbuf[0]);
+//		SDL_FreeAudioMem(mixbuf[0]);
+		mixbuf[0] = NULL;
+	}
+
+	D(bug("Freeing mixbuf[1]...\n"));
+	if ( mixbuf[1] != NULL ) {
+		myfree(mixbuf[1]);
+//		SDL_FreeAudioMem(mixbuf[1]);
+		mixbuf[1] = NULL;
+	}
+
+	D(bug("Freeing audio_port...\n"));
+
+	if ( audio_port != NULL ) {
+		DeleteMsgPort(audio_port);
+		audio_port = NULL;
+	}
+	D(bug("...done!\n"));
+}
+
+static int AHI_OpenAudio(_THIS, SDL_AudioSpec *spec)
+{	
+//	int width;
+
+	D(bug("AHI opening...\n"));
+
+	/* Determine the audio parameters from the AudioSpec */
+	switch ( spec->format & 0xFF ) {
+
+		case 8: { /* Signed 8 bit audio data */
+			D(bug("Samples a 8 bit...\n"));
+			spec->format = AUDIO_S8;
+			this->hidden->bytespersample=1;
+			if(spec->channels<2)
+				this->hidden->type = AHIST_M8S;
+			else
+				this->hidden->type = AHIST_S8S;
+		}
+		break;
+
+		case 16: { /* Signed 16 bit audio data */
+			D(bug("Samples a 16 bit...\n"));
+			spec->format = AUDIO_S16MSB;
+			this->hidden->bytespersample=2;
+			if(spec->channels<2)
+				this->hidden->type = AHIST_M16S;
+			else
+				this->hidden->type = AHIST_S16S;
+		}
+		break;
+
+		default: {
+			SDL_SetError("Unsupported audio format");
+			return(-1);
+		}
+	}
+
+	if(spec->channels!=1 && spec->channels!=2)
+	{
+		D(bug("Wrong channel number!\n"));
+		SDL_SetError("Channel number non supported");
+		return -1;
+	}
+
+	D(bug("Before CalculateAudioSpec\n"));
+	/* Update the fragment size as size in bytes */
+	SDL_CalculateAudioSpec(spec);
+
+	D(bug("Before CreateMsgPort\n"));
+
+	if(!(audio_port=CreateMsgPort()))
+	{
+		SDL_SetError("Unable to create a MsgPort");
+		return -1;
+	}
+
+	D(bug("Before CreateIORequest\n"));
+
+	if(!(audio_req[0]=(struct AHIRequest *)CreateIORequest(audio_port,sizeof(struct AHIRequest))))
+	{
+		SDL_SetError("Unable to create an AHIRequest");
+		DeleteMsgPort(audio_port);
+		return -1;
+	}
+
+	audio_req[0]->ahir_Version = 4;
+
+	if(OpenDevice(AHINAME,0,(struct IORequest *)audio_req[0],NULL))
+	{
+		SDL_SetError("Unable to open AHI device!\n");
+		DeleteIORequest((struct IORequest *)audio_req[0]);
+		DeleteMsgPort(audio_port);
+		return -1;
+	}
+	
+	D(bug("AFTER opendevice\n"));
+
+	/* Set output frequency and size */
+	this->hidden->freq = spec->freq;
+	this->hidden->size = spec->size;
+
+	D(bug("Before buffer allocation\n"));
+
+	/* Allocate mixing buffer */
+	mixbuf[0] = (Uint8 *)mymalloc(spec->size);
+	mixbuf[1] = (Uint8 *)mymalloc(spec->size);
+
+	D(bug("Before audio_req allocation\n"));
+
+	if(!(audio_req[1]=mymalloc(sizeof(struct AHIRequest))))
+	{
+		SDL_OutOfMemory();
+		return(-1);
+	}
+	
+	D(bug("Before audio_req memcpy\n"));
+
+	SDL_memcpy(audio_req[1],audio_req[0],sizeof(struct AHIRequest));
+
+	if ( mixbuf[0] == NULL || mixbuf[1] == NULL ) {
+		SDL_OutOfMemory();
+		return(-1);
+	}
+
+	D(bug("Before mixbuf memset\n"));
+
+	SDL_memset(mixbuf[0], spec->silence, spec->size);
+	SDL_memset(mixbuf[1], spec->silence, spec->size);
+
+	current_buffer=0;
+	playing=0;
+
+	D(bug("AHI opened: freq:%ld mixbuf:%lx/%lx buflen:%ld bits:%ld channels:%ld\n",spec->freq,mixbuf[0],mixbuf[1],spec->size,this->hidden->bytespersample*8,spec->channels));
+
+	/* We're ready to rock and roll. :-) */
+	return(0);
+}

src/dep/src/SDL/audio/amigaos/SDL_ahiaudio.h

@@ -0,0 +1,60 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2006 Sam Lantinga
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+    Sam Lantinga
+    slouken@libsdl.org
+*/
+#include "SDL_config.h"
+
+#ifndef _SDL_ahiaudio_h
+#define _SDL_ahiaudio_h
+
+#include <exec/exec.h>
+#include <dos/dos.h>
+#ifdef __SASC
+#include <proto/exec.h>
+#else
+#include <inline/exec.h>
+#endif
+
+#include <devices/ahi.h>
+#include "mydebug.h"
+
+#include "../SDL_sysaudio.h"
+
+/* Hidden "this" pointer for the audio functions */
+#define _THIS	SDL_AudioDevice *this
+
+struct SDL_PrivateAudioData {
+	/* The handle for the audio device */
+	struct AHIRequest *audio_req[2];
+	struct MsgPort *audio_port;
+	Sint32 freq,type,bytespersample,size;
+	Uint8 *mixbuf[2];           /* The app mixing buffer */
+	int current_buffer;
+	Uint32 playing;
+};
+
+/* Old variable names */
+#define audio_port		(this->hidden->audio_port)
+#define audio_req		(this->hidden->audio_req)
+#define mixbuf			(this->hidden->mixbuf)
+#define current_buffer		(this->hidden->current_buffer)
+#define playing			(this->hidden->playing)
+
+#endif /* _SDL_ahiaudio_h */

src/dep/src/SDL/audio/arts/SDL_artsaudio.c

@@ -0,0 +1,333 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2006 Sam Lantinga
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+    Sam Lantinga
+    slouken@libsdl.org
+*/
+#include "SDL_config.h"
+
+/* Allow access to a raw mixing buffer */
+
+#include "SDL_timer.h"
+#include "SDL_audio.h"
+#include "../SDL_audiomem.h"
+#include "../SDL_audio_c.h"
+#include "../SDL_audiodev_c.h"
+#include "SDL_artsaudio.h"
+
+#ifdef SDL_AUDIO_DRIVER_ARTS_DYNAMIC
+#include "SDL_name.h"
+#include "SDL_loadso.h"
+#else
+#define SDL_NAME(X)	X
+#endif
+
+/* The tag name used by artsc audio */
+#define ARTS_DRIVER_NAME         "arts"
+
+/* Audio driver functions */
+static int ARTS_OpenAudio(_THIS, SDL_AudioSpec *spec);
+static void ARTS_WaitAudio(_THIS);
+static void ARTS_PlayAudio(_THIS);
+static Uint8 *ARTS_GetAudioBuf(_THIS);
+static void ARTS_CloseAudio(_THIS);
+
+#ifdef SDL_AUDIO_DRIVER_ARTS_DYNAMIC
+
+static const char *arts_library = SDL_AUDIO_DRIVER_ARTS_DYNAMIC;
+static void *arts_handle = NULL;
+static int arts_loaded = 0;
+
+static int (*SDL_NAME(arts_init))(void);
+static void (*SDL_NAME(arts_free))(void);
+static arts_stream_t (*SDL_NAME(arts_play_stream))(int rate, int bits, int channels, const char *name);
+static int (*SDL_NAME(arts_stream_set))(arts_stream_t s, arts_parameter_t param, int value);
+static int (*SDL_NAME(arts_stream_get))(arts_stream_t s, arts_parameter_t param);
+static int (*SDL_NAME(arts_write))(arts_stream_t s, const void *buffer, int count);
+static void (*SDL_NAME(arts_close_stream))(arts_stream_t s);
+
+static struct {
+	const char *name;
+	void **func;
+} arts_functions[] = {
+	{ "arts_init",		(void **)&SDL_NAME(arts_init)		},
+	{ "arts_free",		(void **)&SDL_NAME(arts_free)		},
+	{ "arts_play_stream",	(void **)&SDL_NAME(arts_play_stream)	},
+	{ "arts_stream_set",	(void **)&SDL_NAME(arts_stream_set)	},
+	{ "arts_stream_get",	(void **)&SDL_NAME(arts_stream_get)	},
+	{ "arts_write",		(void **)&SDL_NAME(arts_write)		},
+	{ "arts_close_stream",	(void **)&SDL_NAME(arts_close_stream)	},
+};
+
+static void UnloadARTSLibrary()
+{
+	if ( arts_loaded ) {
+		SDL_UnloadObject(arts_handle);
+		arts_handle = NULL;
+		arts_loaded = 0;
+	}
+}
+
+static int LoadARTSLibrary(void)
+{
+	int i, retval = -1;
+
+	arts_handle = SDL_LoadObject(arts_library);
+	if ( arts_handle ) {
+		arts_loaded = 1;
+		retval = 0;
+		for ( i=0; i<SDL_arraysize(arts_functions); ++i ) {
+			*arts_functions[i].func = SDL_LoadFunction(arts_handle, arts_functions[i].name);
+			if ( !*arts_functions[i].func ) {
+				retval = -1;
+				UnloadARTSLibrary();
+				break;
+			}
+		}
+	}
+	return retval;
+}
+
+#else
+
+static void UnloadARTSLibrary()
+{
+	return;
+}
+
+static int LoadARTSLibrary(void)
+{
+	return 0;
+}
+
+#endif /* SDL_AUDIO_DRIVER_ARTS_DYNAMIC */
+
+/* Audio driver bootstrap functions */
+
+static int Audio_Available(void)
+{
+	int available = 0;
+
+	if ( LoadARTSLibrary() < 0 ) {
+		return available;
+	}
+	if ( SDL_NAME(arts_init)() == 0 ) {
+#define ARTS_CRASH_HACK	/* Play a stream so aRts doesn't crash */
+#ifdef ARTS_CRASH_HACK
+		arts_stream_t stream2;
+		stream2=SDL_NAME(arts_play_stream)(44100, 16, 2, "SDL");
+		SDL_NAME(arts_write)(stream2, "", 0);
+		SDL_NAME(arts_close_stream)(stream2);
+#endif
+		available = 1;
+		SDL_NAME(arts_free)();
+	}
+	UnloadARTSLibrary();
+
+	return available;
+}
+
+static void Audio_DeleteDevice(SDL_AudioDevice *device)
+{
+	SDL_free(device->hidden);
+	SDL_free(device);
+	UnloadARTSLibrary();
+}
+
+static SDL_AudioDevice *Audio_CreateDevice(int devindex)
+{
+	SDL_AudioDevice *this;
+
+	/* Initialize all variables that we clean on shutdown */
+	LoadARTSLibrary();
+	this = (SDL_AudioDevice *)SDL_malloc(sizeof(SDL_AudioDevice));
+	if ( this ) {
+		SDL_memset(this, 0, (sizeof *this));
+		this->hidden = (struct SDL_PrivateAudioData *)
+				SDL_malloc((sizeof *this->hidden));
+	}
+	if ( (this == NULL) || (this->hidden == NULL) ) {
+		SDL_OutOfMemory();
+		if ( this ) {
+			SDL_free(this);
+		}
+		return(0);
+	}
+	SDL_memset(this->hidden, 0, (sizeof *this->hidden));
+	stream = 0;
+
+	/* Set the function pointers */
+	this->OpenAudio = ARTS_OpenAudio;
+	this->WaitAudio = ARTS_WaitAudio;
+	this->PlayAudio = ARTS_PlayAudio;
+	this->GetAudioBuf = ARTS_GetAudioBuf;
+	this->CloseAudio = ARTS_CloseAudio;
+
+	this->free = Audio_DeleteDevice;
+
+	return this;
+}
+
+AudioBootStrap ARTS_bootstrap = {
+	ARTS_DRIVER_NAME, "Analog Realtime Synthesizer",
+	Audio_Available, Audio_CreateDevice
+};
+
+/* This function waits until it is possible to write a full sound buffer */
+static void ARTS_WaitAudio(_THIS)
+{
+	Sint32 ticks;
+
+	/* Check to see if the thread-parent process is still alive */
+	{ static int cnt = 0;
+		/* Note that this only works with thread implementations 
+		   that use a different process id for each thread.
+		*/
+		if (parent && (((++cnt)%10) == 0)) { /* Check every 10 loops */
+			if ( kill(parent, 0) < 0 ) {
+				this->enabled = 0;
+			}
+		}
+	}
+
+	/* Use timer for general audio synchronization */
+	ticks = ((Sint32)(next_frame - SDL_GetTicks()))-FUDGE_TICKS;
+	if ( ticks > 0 ) {
+		SDL_Delay(ticks);
+	}
+}
+
+static void ARTS_PlayAudio(_THIS)
+{
+	int written;
+
+	/* Write the audio data */
+	written = SDL_NAME(arts_write)(stream, mixbuf, mixlen);
+	
+	/* If timer synchronization is enabled, set the next write frame */
+	if ( frame_ticks ) {
+		next_frame += frame_ticks;
+	}
+
+	/* If we couldn't write, assume fatal error for now */
+	if ( written < 0 ) {
+		this->enabled = 0;
+	}
+#ifdef DEBUG_AUDIO
+	fprintf(stderr, "Wrote %d bytes of audio data\n", written);
+#endif
+}
+
+static Uint8 *ARTS_GetAudioBuf(_THIS)
+{
+	return(mixbuf);
+}
+
+static void ARTS_CloseAudio(_THIS)
+{
+	if ( mixbuf != NULL ) {
+		SDL_FreeAudioMem(mixbuf);
+		mixbuf = NULL;
+	}
+	if ( stream ) {
+		SDL_NAME(arts_close_stream)(stream);
+		stream = 0;
+	}
+	SDL_NAME(arts_free)();
+}
+
+static int ARTS_OpenAudio(_THIS, SDL_AudioSpec *spec)
+{
+	int bits, frag_spec;
+	Uint16 test_format, format;
+
+	/* Reset the timer synchronization flag */
+	frame_ticks = 0.0;
+
+	mixbuf = NULL;
+
+	/* Try for a closest match on audio format */
+	format = 0;
+	bits = 0;
+	for ( test_format = SDL_FirstAudioFormat(spec->format);
+						! format && test_format; ) {
+#ifdef DEBUG_AUDIO
+		fprintf(stderr, "Trying format 0x%4.4x\n", test_format);
+#endif
+		switch ( test_format ) {
+			case AUDIO_U8:
+				bits = 8;
+				format = 1;
+				break;
+			case AUDIO_S16LSB:
+				bits = 16;
+				format = 1;
+				break;
+			default:
+				format = 0;
+				break;
+		}
+		if ( ! format ) {
+			test_format = SDL_NextAudioFormat();
+		}
+	}
+	if ( format == 0 ) {
+		SDL_SetError("Couldn't find any hardware audio formats");
+		return(-1);
+	}
+	spec->format = test_format;
+
+	if ( SDL_NAME(arts_init)() != 0 ) {
+		SDL_SetError("Unable to initialize ARTS");
+		return(-1);
+	}
+	stream = SDL_NAME(arts_play_stream)(spec->freq, bits, spec->channels, "SDL");
+
+	/* Calculate the final parameters for this audio specification */
+	SDL_CalculateAudioSpec(spec);
+
+	/* Determine the power of two of the fragment size */
+	for ( frag_spec = 0; (0x01<<frag_spec) < spec->size; ++frag_spec );
+	if ( (0x01<<frag_spec) != spec->size ) {
+		SDL_SetError("Fragment size must be a power of two");
+		return(-1);
+	}
+	frag_spec |= 0x00020000;	/* two fragments, for low latency */
+
+#ifdef ARTS_P_PACKET_SETTINGS
+	SDL_NAME(arts_stream_set)(stream, ARTS_P_PACKET_SETTINGS, frag_spec);
+#else
+	SDL_NAME(arts_stream_set)(stream, ARTS_P_PACKET_SIZE, frag_spec&0xffff);
+	SDL_NAME(arts_stream_set)(stream, ARTS_P_PACKET_COUNT, frag_spec>>16);
+#endif
+	spec->size = SDL_NAME(arts_stream_get)(stream, ARTS_P_PACKET_SIZE);
+
+	/* Allocate mixing buffer */
+	mixlen = spec->size;
+	mixbuf = (Uint8 *)SDL_AllocAudioMem(mixlen);
+	if ( mixbuf == NULL ) {
+		return(-1);
+	}
+	SDL_memset(mixbuf, spec->silence, spec->size);
+
+	/* Get the parent process id (we're the parent of the audio thread) */
+	parent = getpid();
+
+	/* We're ready to rock and roll. :-) */
+	return(0);
+}

src/dep/src/SDL/audio/arts/SDL_artsaudio.h

@@ -0,0 +1,60 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2006 Sam Lantinga
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+    Sam Lantinga
+    slouken@libsdl.org
+*/
+#include "SDL_config.h"
+
+#ifndef _SDL_artscaudio_h
+#define _SDL_artscaudio_h
+
+#include <artsc.h>
+
+#include "../SDL_sysaudio.h"
+
+/* Hidden "this" pointer for the video functions */
+#define _THIS	SDL_AudioDevice *this
+
+struct SDL_PrivateAudioData {
+	/* The stream descriptor for the audio device */
+	arts_stream_t stream;
+
+	/* The parent process id, to detect when application quits */
+	pid_t parent;
+
+	/* Raw mixing buffer */
+	Uint8 *mixbuf;
+	int    mixlen;
+
+	/* Support for audio timing using a timer, in addition to select() */
+	float frame_ticks;
+	float next_frame;
+};
+#define FUDGE_TICKS	10	/* The scheduler overhead ticks per frame */
+
+/* Old variable names */
+#define stream			(this->hidden->stream)
+#define parent			(this->hidden->parent)
+#define mixbuf			(this->hidden->mixbuf)
+#define mixlen			(this->hidden->mixlen)
+#define frame_ticks		(this->hidden->frame_ticks)
+#define next_frame		(this->hidden->next_frame)
+
+#endif /* _SDL_artscaudio_h */
+

src/dep/src/SDL/audio/baudio/SDL_beaudio.cc

@@ -0,0 +1,208 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2006 Sam Lantinga
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+    Sam Lantinga
+    slouken@libsdl.org
+*/
+#include "SDL_config.h"
+
+/* Allow access to the audio stream on BeOS */
+
+#include <SoundPlayer.h>
+
+#include "../../main/beos/SDL_BeApp.h"
+
+extern "C" {
+
+#include "SDL_audio.h"
+#include "../SDL_audio_c.h"
+#include "../SDL_sysaudio.h"
+#include "../../thread/beos/SDL_systhread_c.h"
+#include "SDL_beaudio.h"
+
+
+/* Audio driver functions */
+static int BE_OpenAudio(_THIS, SDL_AudioSpec *spec);
+static void BE_WaitAudio(_THIS);
+static void BE_PlayAudio(_THIS);
+static Uint8 *BE_GetAudioBuf(_THIS);
+static void BE_CloseAudio(_THIS);
+
+/* Audio driver bootstrap functions */
+
+static int Audio_Available(void)
+{
+	return(1);
+}
+
+static void Audio_DeleteDevice(SDL_AudioDevice *device)
+{
+	SDL_free(device->hidden);
+	SDL_free(device);
+}
+
+static SDL_AudioDevice *Audio_CreateDevice(int devindex)
+{
+	SDL_AudioDevice *device;
+
+	/* Initialize all variables that we clean on shutdown */
+	device = (SDL_AudioDevice *)SDL_malloc(sizeof(SDL_AudioDevice));
+	if ( device ) {
+		SDL_memset(device, 0, (sizeof *device));
+		device->hidden = (struct SDL_PrivateAudioData *)
+				SDL_malloc((sizeof *device->hidden));
+	}
+	if ( (device == NULL) || (device->hidden == NULL) ) {
+		SDL_OutOfMemory();
+		if ( device ) {
+			SDL_free(device);
+		}
+		return(0);
+	}
+	SDL_memset(device->hidden, 0, (sizeof *device->hidden));
+
+	/* Set the function pointers */
+	device->OpenAudio = BE_OpenAudio;
+	device->WaitAudio = BE_WaitAudio;
+	device->PlayAudio = BE_PlayAudio;
+	device->GetAudioBuf = BE_GetAudioBuf;
+	device->CloseAudio = BE_CloseAudio;
+
+	device->free = Audio_DeleteDevice;
+
+	return device;
+}
+
+AudioBootStrap BAUDIO_bootstrap = {
+	"baudio", "BeOS BSoundPlayer",
+	Audio_Available, Audio_CreateDevice
+};
+
+/* The BeOS callback for handling the audio buffer */
+static void FillSound(void *device, void *stream, size_t len, 
+					const media_raw_audio_format &format)
+{
+	SDL_AudioDevice *audio = (SDL_AudioDevice *)device;
+
+	/* Silence the buffer, since it's ours */
+	SDL_memset(stream, audio->spec.silence, len);
+
+	/* Only do soemthing if audio is enabled */
+	if ( ! audio->enabled )
+		return;
+
+	if ( ! audio->paused ) {
+		if ( audio->convert.needed ) {
+			SDL_mutexP(audio->mixer_lock);
+			(*audio->spec.callback)(audio->spec.userdata,
+				(Uint8 *)audio->convert.buf,audio->convert.len);
+			SDL_mutexV(audio->mixer_lock);
+			SDL_ConvertAudio(&audio->convert);
+			SDL_memcpy(stream,audio->convert.buf,audio->convert.len_cvt);
+		} else {
+			SDL_mutexP(audio->mixer_lock);
+			(*audio->spec.callback)(audio->spec.userdata,
+						(Uint8 *)stream, len);
+			SDL_mutexV(audio->mixer_lock);
+		}
+	}
+	return;
+}
+
+/* Dummy functions -- we don't use thread-based audio */
+void BE_WaitAudio(_THIS)
+{
+	return;
+}
+void BE_PlayAudio(_THIS)
+{
+	return;
+}
+Uint8 *BE_GetAudioBuf(_THIS)
+{
+	return(NULL);
+}
+
+void BE_CloseAudio(_THIS)
+{
+	if ( audio_obj ) {
+		audio_obj->Stop();
+		delete audio_obj;
+		audio_obj = NULL;
+	}
+
+	/* Quit the Be Application, if there's nothing left to do */
+	SDL_QuitBeApp();
+}
+
+int BE_OpenAudio(_THIS, SDL_AudioSpec *spec)
+{
+	media_raw_audio_format format;
+
+	/* Initialize the Be Application, if it's not already started */
+	if ( SDL_InitBeApp() < 0 ) {
+		return(-1);
+	}
+
+	/* Parse the audio format and fill the Be raw audio format */
+	format.frame_rate = (float)spec->freq;
+	format.channel_count = spec->channels;
+	switch (spec->format&~0x1000) {
+		case AUDIO_S8:
+			/* Signed 8-bit audio unsupported, convert to U8 */
+			spec->format = AUDIO_U8;
+		case AUDIO_U8:
+			format.format = media_raw_audio_format::B_AUDIO_UCHAR;
+			format.byte_order = 0;
+			break;
+		case AUDIO_U16:
+			/* Unsigned 16-bit audio unsupported, convert to S16 */
+			spec->format ^= 0x8000;
+		case AUDIO_S16:
+			format.format = media_raw_audio_format::B_AUDIO_SHORT;
+			if ( spec->format & 0x1000 ) {
+				format.byte_order = 1; /* Big endian */
+			} else {
+				format.byte_order = 2; /* Little endian */
+			}
+			break;
+	}
+	format.buffer_size = spec->samples;
+	
+	/* Calculate the final parameters for this audio specification */
+	SDL_CalculateAudioSpec(spec);
+
+	/* Subscribe to the audio stream (creates a new thread) */
+	{ sigset_t omask;
+		SDL_MaskSignals(&omask);
+		audio_obj = new BSoundPlayer(&format, "SDL Audio", FillSound,
+		                                                 NULL, _this);
+		SDL_UnmaskSignals(&omask);
+	}
+	if ( audio_obj->Start() == B_NO_ERROR ) {
+		audio_obj->SetHasData(true);
+	} else {
+		SDL_SetError("Unable to start Be audio");
+		return(-1);
+	}
+
+	/* We're running! */
+	return(1);
+}
+
+};	/* Extern C */

src/dep/src/SDL/audio/baudio/SDL_beaudio.h

@@ -0,0 +1,39 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2006 Sam Lantinga
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+    Sam Lantinga
+    slouken@libsdl.org
+*/
+#include "SDL_config.h"
+
+#ifndef _SDL_lowaudio_h
+#define _SDL_lowaudio_h
+
+#include "../SDL_sysaudio.h"
+
+/* Hidden "this" pointer for the video functions */
+#define _THIS	SDL_AudioDevice *_this
+
+struct SDL_PrivateAudioData {
+	BSoundPlayer *audio_obj;
+};
+
+/* Old variable names */
+#define audio_obj	(_this->hidden->audio_obj)
+
+#endif /* _SDL_lowaudio_h */

src/dep/src/SDL/audio/bsd/SDL_bsdaudio.c

@@ -0,0 +1,404 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2004 Sam Lantinga
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Library General Public
+    License as published by the Free Software Foundation; either
+    version 2 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Library General Public License for more details.
+
+    You should have received a copy of the GNU Library General Public
+    License along with this library; if not, write to the Free
+    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+    Sam Lantinga
+    slouken@libsdl.org
+*/
+#include "SDL_config.h"
+
+/*
+ * Driver for native OpenBSD/NetBSD audio(4).
+ * vedge@vedge.com.ar.
+ */
+
+#include <errno.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <sys/time.h>
+#include <sys/ioctl.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <sys/audioio.h>
+
+#include "SDL_timer.h"
+#include "SDL_audio.h"
+#include "../SDL_audiomem.h"
+#include "../SDL_audio_c.h"
+#include "../SDL_audiodev_c.h"
+#include "SDL_bsdaudio.h"
+
+/* The tag name used by NetBSD/OpenBSD audio */
+#ifdef __NetBSD__
+#define BSD_AUDIO_DRIVER_NAME         "netbsd"
+#define BSD_AUDIO_DRIVER_DESC         "Native NetBSD audio"
+#else
+#define BSD_AUDIO_DRIVER_NAME         "openbsd"
+#define BSD_AUDIO_DRIVER_DESC         "Native OpenBSD audio"
+#endif
+
+/* Open the audio device for playback, and don't block if busy */
+/* #define USE_BLOCKING_WRITES */
+
+/* Use timer for synchronization */
+/* #define USE_TIMER_SYNC */
+
+/* #define DEBUG_AUDIO */
+/* #define DEBUG_AUDIO_STREAM */
+
+#ifdef USE_BLOCKING_WRITES
+#define OPEN_FLAGS	O_WRONLY
+#else
+#define OPEN_FLAGS	(O_WRONLY|O_NONBLOCK)
+#endif
+
+/* Audio driver functions */
+static void OBSD_WaitAudio(_THIS);
+static int OBSD_OpenAudio(_THIS, SDL_AudioSpec *spec);
+static void OBSD_PlayAudio(_THIS);
+static Uint8 *OBSD_GetAudioBuf(_THIS);
+static void OBSD_CloseAudio(_THIS);
+
+#ifdef DEBUG_AUDIO
+static void OBSD_Status(_THIS);
+#endif
+
+/* Audio driver bootstrap functions */
+
+static int
+Audio_Available(void)
+{
+    int fd;
+    int available;
+
+    available = 0;
+    fd = SDL_OpenAudioPath(NULL, 0, OPEN_FLAGS, 0);
+    if(fd >= 0) {
+	available = 1;
+	close(fd);
+    }
+    return(available);
+}
+
+static void
+Audio_DeleteDevice(SDL_AudioDevice *device)
+{
+    SDL_free(device->hidden);
+    SDL_free(device);
+}
+
+static SDL_AudioDevice
+*Audio_CreateDevice(int devindex)
+{
+    SDL_AudioDevice *this;
+
+    /* Initialize all variables that we clean on shutdown */
+    this = (SDL_AudioDevice*)SDL_malloc(sizeof(SDL_AudioDevice));
+    if(this) {
+	SDL_memset(this, 0, (sizeof *this));
+	this->hidden =
+	    (struct SDL_PrivateAudioData*)SDL_malloc((sizeof *this->hidden));
+    }
+    if((this == NULL) || (this->hidden == NULL)) {
+	SDL_OutOfMemory();
+	if(this) SDL_free(this);
+	return(0);
+    }
+    SDL_memset(this->hidden, 0, (sizeof *this->hidden));
+    audio_fd = -1;
+
+    /* Set the function pointers */
+    this->OpenAudio = OBSD_OpenAudio;
+    this->WaitAudio = OBSD_WaitAudio;
+    this->PlayAudio = OBSD_PlayAudio;
+    this->GetAudioBuf = OBSD_GetAudioBuf;
+    this->CloseAudio = OBSD_CloseAudio;
+
+    this->free = Audio_DeleteDevice;
+    
+    return this;
+}
+
+AudioBootStrap BSD_AUDIO_bootstrap = {
+	BSD_AUDIO_DRIVER_NAME, BSD_AUDIO_DRIVER_DESC,
+	Audio_Available, Audio_CreateDevice
+};
+
+/* This function waits until it is possible to write a full sound buffer */
+static void
+OBSD_WaitAudio(_THIS)
+{
+#ifndef USE_BLOCKING_WRITES /* Not necessary when using blocking writes */
+	/* See if we need to use timed audio synchronization */
+	if ( frame_ticks ) {
+		/* Use timer for general audio synchronization */
+		Sint32 ticks;
+
+		ticks = ((Sint32)(next_frame - SDL_GetTicks()))-FUDGE_TICKS;
+		if ( ticks > 0 ) {
+			SDL_Delay(ticks);
+		}
+	} else {
+		/* Use select() for audio synchronization */
+		fd_set fdset;
+		struct timeval timeout;
+
+		FD_ZERO(&fdset);
+		FD_SET(audio_fd, &fdset);
+		timeout.tv_sec = 10;
+		timeout.tv_usec = 0;
+#ifdef DEBUG_AUDIO
+		fprintf(stderr, "Waiting for audio to get ready\n");
+#endif
+		if ( select(audio_fd+1, NULL, &fdset, NULL, &timeout) <= 0 ) {
+			const char *message =
+			"Audio timeout - buggy audio driver? (disabled)";
+			/* In general we should never print to the screen,
+			   but in this case we have no other way of letting
+			   the user know what happened.
+			*/
+			fprintf(stderr, "SDL: %s\n", message);
+			this->enabled = 0;
+			/* Don't try to close - may hang */
+			audio_fd = -1;
+#ifdef DEBUG_AUDIO
+			fprintf(stderr, "Done disabling audio\n");
+#endif
+		}
+#ifdef DEBUG_AUDIO
+		fprintf(stderr, "Ready!\n");
+#endif
+	}
+#endif /* !USE_BLOCKING_WRITES */
+}
+
+static void
+OBSD_PlayAudio(_THIS)
+{
+	int written, p=0;
+
+	/* Write the audio data, checking for EAGAIN on broken audio drivers */
+	do {
+		written = write(audio_fd, &mixbuf[p], mixlen-p);
+		if (written>0)
+		   p += written;
+		if (written == -1 && errno != 0 && errno != EAGAIN && errno != EINTR)
+		{
+		   /* Non recoverable error has occurred. It should be reported!!! */
+		   perror("audio");
+		   break;
+		}
+
+		if ( p < written || ((written < 0) && ((errno == 0) || (errno == EAGAIN))) ) {
+			SDL_Delay(1);	/* Let a little CPU time go by */
+		}
+	} while ( p < written );
+
+	/* If timer synchronization is enabled, set the next write frame */
+	if ( frame_ticks ) {
+		next_frame += frame_ticks;
+	}
+
+	/* If we couldn't write, assume fatal error for now */
+	if ( written < 0 ) {
+		this->enabled = 0;
+	}
+#ifdef DEBUG_AUDIO
+	fprintf(stderr, "Wrote %d bytes of audio data\n", written);
+#endif
+}
+
+static Uint8
+*OBSD_GetAudioBuf(_THIS)
+{
+    return(mixbuf);
+}
+
+static void
+OBSD_CloseAudio(_THIS)
+{
+    if(mixbuf != NULL) {
+	SDL_FreeAudioMem(mixbuf);
+	mixbuf = NULL;
+    }
+    if(audio_fd >= 0) {
+	close(audio_fd);
+	audio_fd = -1;
+    }
+}
+
+#ifdef DEBUG_AUDIO
+void
+OBSD_Status(_THIS)
+{
+    audio_info_t info;
+
+    if(ioctl(audio_fd, AUDIO_GETINFO, &info) < 0) {
+	fprintf(stderr,"AUDIO_GETINFO failed.\n");
+	return;
+    }
+
+    fprintf(stderr,"\n"
+"[play/record info]\n"
+"buffer size	:   %d bytes\n"
+"sample rate	:   %i Hz\n"
+"channels	:   %i\n"
+"precision	:   %i-bit\n"
+"encoding	:   0x%x\n"
+"seek		:   %i\n"
+"sample count	:   %i\n"
+"EOF count	:   %i\n"
+"paused		:   %s\n"
+"error occured	:   %s\n"
+"waiting		:   %s\n"
+"active		:   %s\n"
+"",
+    info.play.buffer_size,
+    info.play.sample_rate,
+    info.play.channels,
+    info.play.precision,
+    info.play.encoding,
+    info.play.seek,
+    info.play.samples,
+    info.play.eof,
+    info.play.pause ? "yes" : "no",
+    info.play.error ? "yes" : "no",
+    info.play.waiting ? "yes" : "no",
+    info.play.active ? "yes": "no");
+
+    fprintf(stderr,"\n"
+"[audio info]\n"
+"monitor_gain	:   %i\n"
+"hw block size	:   %d bytes\n"
+"hi watermark	:   %i\n"
+"lo watermark	:   %i\n"
+"audio mode	:   %s\n"
+"",  
+    info.monitor_gain,
+    info.blocksize,
+    info.hiwat, info.lowat,
+    (info.mode == AUMODE_PLAY) ? "PLAY"
+    : (info.mode = AUMODE_RECORD) ? "RECORD"
+    : (info.mode == AUMODE_PLAY_ALL ? "PLAY_ALL"
+    : "?"));
+}
+#endif /* DEBUG_AUDIO */
+
+static int
+OBSD_OpenAudio(_THIS, SDL_AudioSpec *spec)
+{
+    char audiodev[64];
+    Uint16 format;
+    audio_info_t info;
+
+    AUDIO_INITINFO(&info);
+    
+    /* Calculate the final parameters for this audio specification */
+    SDL_CalculateAudioSpec(spec);
+
+#ifdef USE_TIMER_SYNC
+    frame_ticks = 0.0;
+#endif
+
+    /* Open the audio device */
+    audio_fd = SDL_OpenAudioPath(audiodev, sizeof(audiodev), OPEN_FLAGS, 0);
+    if(audio_fd < 0) {
+	SDL_SetError("Couldn't open %s: %s", audiodev, strerror(errno));
+	return(-1);
+    }
+    
+    /* Set to play mode */
+    info.mode = AUMODE_PLAY;
+    if(ioctl(audio_fd, AUDIO_SETINFO, &info) < 0) {
+	SDL_SetError("Couldn't put device into play mode");
+	return(-1);
+    }
+    
+    mixbuf = NULL;
+    AUDIO_INITINFO(&info);
+    for (format = SDL_FirstAudioFormat(spec->format); 
+    	format; format = SDL_NextAudioFormat())
+    {
+	switch(format) {
+	case AUDIO_U8:
+	    info.play.encoding = AUDIO_ENCODING_ULINEAR;
+	    info.play.precision = 8;
+	    break;
+	case AUDIO_S8:
+	    info.play.encoding = AUDIO_ENCODING_SLINEAR;
+	    info.play.precision = 8;
+	    break;
+	case AUDIO_S16LSB:
+	    info.play.encoding = AUDIO_ENCODING_SLINEAR_LE;
+	    info.play.precision = 16;
+	    break;
+	case AUDIO_S16MSB:
+	    info.play.encoding = AUDIO_ENCODING_SLINEAR_BE;
+	    info.play.precision = 16;
+	    break;
+	case AUDIO_U16LSB:
+	    info.play.encoding = AUDIO_ENCODING_ULINEAR_LE;
+	    info.play.precision = 16;
+	    break;
+	case AUDIO_U16MSB:
+	    info.play.encoding = AUDIO_ENCODING_ULINEAR_BE;
+	    info.play.precision = 16;
+	    break;
+	default:
+	    continue;
+	}
+	if (ioctl(audio_fd, AUDIO_SETINFO, &info) == 0)
+	    break;
+    }
+
+    if(!format) {
+	SDL_SetError("No supported encoding for 0x%x", spec->format);
+	return(-1);
+    }
+
+    spec->format = format;
+
+    AUDIO_INITINFO(&info);
+    info.play.channels = spec->channels;
+    if (ioctl(audio_fd, AUDIO_SETINFO, &info) == -1)
+    	spec->channels = 1;
+    AUDIO_INITINFO(&info);
+    info.play.sample_rate = spec->freq;
+    info.blocksize = spec->size;
+    info.hiwat = 5;
+    info.lowat = 3;
+    (void)ioctl(audio_fd, AUDIO_SETINFO, &info);
+    (void)ioctl(audio_fd, AUDIO_GETINFO, &info);
+    spec->freq  = info.play.sample_rate;
+    /* Allocate mixing buffer */
+    mixlen = spec->size;
+    mixbuf = (Uint8*)SDL_AllocAudioMem(mixlen);
+    if(mixbuf == NULL) {
+	return(-1);
+    }
+    SDL_memset(mixbuf, spec->silence, spec->size);
+    
+    /* Get the parent process id (we're the parent of the audio thread) */
+    parent = getpid();
+
+#ifdef DEBUG_AUDIO
+    OBSD_Status(this);
+#endif
+
+    /* We're ready to rock and roll. :-) */
+    return(0);
+}

src/dep/src/SDL/audio/bsd/SDL_bsdaudio.h

@@ -0,0 +1,58 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2004 Sam Lantinga
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Library General Public
+    License as published by the Free Software Foundation; either
+    version 2 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Library General Public License for more details.
+
+    You should have received a copy of the GNU Library General Public
+    License along with this library; if not, write to the Free
+    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+    Sam Lantinga
+    slouken@libsdl.org
+*/
+#include "SDL_config.h"
+
+#ifndef _SDL_openbsdaudio_h
+#define _SDL_openbsdaudio_h
+
+#include "../SDL_sysaudio.h"
+
+#define _THIS	SDL_AudioDevice *this
+
+struct SDL_PrivateAudioData
+{
+    /* The file descriptor for the audio device */
+    int audio_fd;
+
+    /* The parent process id, to detect when application quits */
+    pid_t parent;
+
+    /* Raw mixing buffer */
+    Uint8 *mixbuf;
+    int    mixlen;
+
+    /* Support for audio timing using a timer, in addition to select() */
+    float frame_ticks;
+    float next_frame;
+};
+
+#define FUDGE_TICKS	10	/* The scheduler overhead ticks per frame */
+
+/* Old variable names */
+#define audio_fd		(this->hidden->audio_fd)
+#define parent			(this->hidden->parent)
+#define mixbuf			(this->hidden->mixbuf)
+#define mixlen			(this->hidden->mixlen)
+#define frame_ticks		(this->hidden->frame_ticks)
+#define next_frame		(this->hidden->next_frame)
+
+#endif /* _SDL_openbsdaudio_h */

src/dep/src/SDL/audio/dart/SDL_dart.c

@@ -0,0 +1,426 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2006 Sam Lantinga
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+    Sam Lantinga
+    slouken@libsdl.org
+*/
+#include "SDL_config.h"
+
+/* Allow access to a raw mixing buffer */
+
+#include "SDL_timer.h"
+#include "SDL_audio.h"
+#include "../SDL_audio_c.h"
+#include "SDL_dart.h"
+
+// Buffer states:
+#define BUFFER_EMPTY       0
+#define BUFFER_USED        1
+
+typedef struct _tMixBufferDesc {
+  int              iBufferUsage;      // BUFFER_EMPTY or BUFFER_USED
+  SDL_AudioDevice *pSDLAudioDevice;
+} tMixBufferDesc, *pMixBufferDesc;
+
+
+//---------------------------------------------------------------------
+// DARTEventFunc
+//
+// This function is called by DART, when an event occures, like end of 
+// playback of a buffer, etc...
+//---------------------------------------------------------------------
+LONG APIENTRY DARTEventFunc(ULONG ulStatus,
+			    PMCI_MIX_BUFFER pBuffer,
+			    ULONG ulFlags)
+{
+  if (ulFlags && MIX_WRITE_COMPLETE)
+  { // Playback of buffer completed!
+
+    // Get pointer to buffer description
+    pMixBufferDesc pBufDesc;
+
+    if (pBuffer)
+    {
+      pBufDesc = (pMixBufferDesc) (*pBuffer).ulUserParm;
+
+      if (pBufDesc)
+      {
+        SDL_AudioDevice *pSDLAudioDevice = pBufDesc->pSDLAudioDevice;
+        // Set the buffer to be empty
+        pBufDesc->iBufferUsage = BUFFER_EMPTY;
+        // And notify DART feeder thread that it will have to work a bit.
+        if (pSDLAudioDevice)
+        DosPostEventSem(pSDLAudioDevice->hidden->hevAudioBufferPlayed);
+      }
+    }
+  }
+  return TRUE;
+}
+
+
+int DART_OpenAudio(_THIS, SDL_AudioSpec *spec)
+{
+  MCI_AMP_OPEN_PARMS AmpOpenParms;
+  MCI_GENERIC_PARMS GenericParms;
+  int iDeviceOrd = 0; // Default device to be used
+  int bOpenShared = 1; // Try opening it shared
+  int iBits = 16; // Default is 16 bits signed
+  int iFreq = 44100; // Default is 44KHz
+  int iChannels = 2; // Default is 2 channels (Stereo)
+  int iNumBufs = 2;  // Number of audio buffers: 2
+  int iBufSize;
+  int iOpenMode;
+  int iSilence;
+  int rc;
+
+  // First thing is to try to open a given DART device!
+  SDL_memset(&AmpOpenParms, 0, sizeof(MCI_AMP_OPEN_PARMS));
+  // pszDeviceType should contain the device type in low word, and device ordinal in high word!
+  AmpOpenParms.pszDeviceType = (PSZ) (MCI_DEVTYPE_AUDIO_AMPMIX | (iDeviceOrd << 16));
+
+  iOpenMode = MCI_WAIT | MCI_OPEN_TYPE_ID;
+  if (bOpenShared) iOpenMode |= MCI_OPEN_SHAREABLE;
+
+  rc = mciSendCommand( 0, MCI_OPEN,
+                       iOpenMode,
+		       (PVOID) &AmpOpenParms, 0);
+  if (rc!=MCIERR_SUCCESS) // No audio available??
+    return (-1);
+  // Save the device ID we got from DART!
+  // We will use this in the next calls!
+  iDeviceOrd = AmpOpenParms.usDeviceID;
+
+  // Determine the audio parameters from the AudioSpec
+  switch ( spec->format & 0xFF )
+  {
+    case 8:
+        /* Unsigned 8 bit audio data */
+        spec->format = AUDIO_U8;
+        iSilence = 0x80;
+        iBits = 8;
+        break;
+    case 16:
+        /* Signed 16 bit audio data */
+        spec->format = AUDIO_S16;
+        iSilence = 0x00;
+        iBits = 16;
+        break;
+    default:
+        // Close DART, and exit with error code!
+        mciSendCommand(iDeviceOrd, MCI_CLOSE, MCI_WAIT, &GenericParms, 0);
+        SDL_SetError("Unsupported audio format");
+        return(-1);
+  }
+  iFreq = spec->freq;
+  iChannels = spec->channels;
+  /* Update the fragment size as size in bytes */
+  SDL_CalculateAudioSpec(spec);
+  iBufSize = spec->size;
+
+  // Now query this device if it supports the given freq/bits/channels!
+  SDL_memset(&(_this->hidden->MixSetupParms), 0, sizeof(MCI_MIXSETUP_PARMS));
+  _this->hidden->MixSetupParms.ulBitsPerSample = iBits;
+  _this->hidden->MixSetupParms.ulFormatTag = MCI_WAVE_FORMAT_PCM;
+  _this->hidden->MixSetupParms.ulSamplesPerSec = iFreq;
+  _this->hidden->MixSetupParms.ulChannels = iChannels;
+  _this->hidden->MixSetupParms.ulFormatMode = MCI_PLAY;
+  _this->hidden->MixSetupParms.ulDeviceType = MCI_DEVTYPE_WAVEFORM_AUDIO;
+  _this->hidden->MixSetupParms.pmixEvent = DARTEventFunc;
+  rc = mciSendCommand (iDeviceOrd, MCI_MIXSETUP,
+                       MCI_WAIT | MCI_MIXSETUP_QUERYMODE,
+                       &(_this->hidden->MixSetupParms), 0);
+  if (rc!=MCIERR_SUCCESS)
+  { // The device cannot handle this format!
+    // Close DART, and exit with error code!
+    mciSendCommand(iDeviceOrd, MCI_CLOSE, MCI_WAIT, &GenericParms, 0);
+    SDL_SetError("Audio device doesn't support requested audio format");
+    return(-1);
+  }
+  // The device can handle this format, so initialize!
+  rc = mciSendCommand(iDeviceOrd, MCI_MIXSETUP,
+                      MCI_WAIT | MCI_MIXSETUP_INIT,
+                      &(_this->hidden->MixSetupParms), 0);
+  if (rc!=MCIERR_SUCCESS)
+  { // The device could not be opened!
+    // Close DART, and exit with error code!
+    mciSendCommand(iDeviceOrd, MCI_CLOSE, MCI_WAIT, &GenericParms, 0);
+    SDL_SetError("Audio device could not be set up");
+    return(-1);
+  }
+  // Ok, the device is initialized.
+  // Now we should allocate buffers. For this, we need a place where
+  // the buffer descriptors will be:
+  _this->hidden->pMixBuffers = (MCI_MIX_BUFFER *) SDL_malloc(sizeof(MCI_MIX_BUFFER)*iNumBufs);
+  if (!(_this->hidden->pMixBuffers))
+  { // Not enough memory!
+    // Close DART, and exit with error code!
+    mciSendCommand(iDeviceOrd, MCI_CLOSE, MCI_WAIT, &GenericParms, 0);
+    SDL_SetError("Not enough memory for audio buffer descriptors");
+    return(-1);
+  }
+  // Now that we have the place for buffer list, we can ask DART for the
+  // buffers!
+  _this->hidden->BufferParms.ulNumBuffers = iNumBufs;               // Number of buffers
+  _this->hidden->BufferParms.ulBufferSize = iBufSize;               // each with this size
+  _this->hidden->BufferParms.pBufList = _this->hidden->pMixBuffers; // getting descriptorts into this list
+  // Allocate buffers!
+  rc = mciSendCommand(iDeviceOrd, MCI_BUFFER,
+                      MCI_WAIT | MCI_ALLOCATE_MEMORY,
+                      &(_this->hidden->BufferParms), 0);
+  if ((rc!=MCIERR_SUCCESS) || (iNumBufs != _this->hidden->BufferParms.ulNumBuffers) || (_this->hidden->BufferParms.ulBufferSize==0))
+  { // Could not allocate memory!
+    // Close DART, and exit with error code!
+    SDL_free(_this->hidden->pMixBuffers); _this->hidden->pMixBuffers = NULL;
+    mciSendCommand(iDeviceOrd, MCI_CLOSE, MCI_WAIT, &GenericParms, 0);
+    SDL_SetError("DART could not allocate buffers");
+    return(-1);
+  }
+  // Ok, we have all the buffers allocated, let's mark them!
+  {
+    int i;
+    for (i=0; i<iNumBufs; i++)
+    {
+      pMixBufferDesc pBufferDesc = (pMixBufferDesc) SDL_malloc(sizeof(tMixBufferDesc));;
+      // Check if this buffer was really allocated by DART
+      if ((!(_this->hidden->pMixBuffers[i].pBuffer)) || (!pBufferDesc))
+      { // Wrong buffer!
+        // Close DART, and exit with error code!
+        // Free buffer descriptions
+        { int j;
+          for (j=0; j<i; j++) SDL_free((void *)(_this->hidden->pMixBuffers[j].ulUserParm));
+        }
+        // and cleanup
+        mciSendCommand(iDeviceOrd, MCI_BUFFER, MCI_WAIT | MCI_DEALLOCATE_MEMORY, &(_this->hidden->BufferParms), 0);
+        SDL_free(_this->hidden->pMixBuffers); _this->hidden->pMixBuffers = NULL;
+        mciSendCommand(iDeviceOrd, MCI_CLOSE, MCI_WAIT, &GenericParms, 0);
+        SDL_SetError("Error at internal buffer check");
+        return(-1);
+      }
+      pBufferDesc->iBufferUsage = BUFFER_EMPTY;
+      pBufferDesc->pSDLAudioDevice = _this;
+
+      _this->hidden->pMixBuffers[i].ulBufferLength = _this->hidden->BufferParms.ulBufferSize;
+      _this->hidden->pMixBuffers[i].ulUserParm = (ULONG) pBufferDesc; // User parameter: Description of buffer
+      _this->hidden->pMixBuffers[i].ulFlags = 0; // Some stuff should be flagged here for DART, like end of
+                                            // audio data, but as we will continously send
+                                            // audio data, there will be no end.:)
+      SDL_memset(_this->hidden->pMixBuffers[i].pBuffer, iSilence, iBufSize);
+    }
+  }
+  _this->hidden->iNextFreeBuffer = 0;
+  _this->hidden->iLastPlayedBuf = -1;
+  // Create event semaphore
+  if (DosCreateEventSem(NULL, &(_this->hidden->hevAudioBufferPlayed), 0, FALSE)!=NO_ERROR)
+  {
+    // Could not create event semaphore!
+    {
+      int i;
+      for (i=0; i<iNumBufs; i++) SDL_free((void *)(_this->hidden->pMixBuffers[i].ulUserParm));
+    }
+    mciSendCommand(iDeviceOrd, MCI_BUFFER, MCI_WAIT | MCI_DEALLOCATE_MEMORY, &(_this->hidden->BufferParms), 0);
+    SDL_free(_this->hidden->pMixBuffers); _this->hidden->pMixBuffers = NULL;
+    mciSendCommand(iDeviceOrd, MCI_CLOSE, MCI_WAIT, &GenericParms, 0);
+    SDL_SetError("Could not create event semaphore");
+    return(-1);
+  }
+
+  // Store the new settings in global variables
+  _this->hidden->iCurrDeviceOrd = iDeviceOrd;
+  _this->hidden->iCurrFreq = iFreq;
+  _this->hidden->iCurrBits = iBits;
+  _this->hidden->iCurrChannels = iChannels;
+  _this->hidden->iCurrNumBufs = iNumBufs;
+  _this->hidden->iCurrBufSize = iBufSize;
+
+  return (0);
+}
+
+
+
+void DART_ThreadInit(_THIS)
+{
+  return;
+}
+
+/* This function waits until it is possible to write a full sound buffer */
+void DART_WaitAudio(_THIS)
+{
+  int i;
+  pMixBufferDesc pBufDesc;
+  ULONG ulPostCount;
+
+  DosResetEventSem(_this->hidden->hevAudioBufferPlayed, &ulPostCount);
+  // If there is already an empty buffer, then return now!
+  for (i=0; i<_this->hidden->iCurrNumBufs; i++)
+  {
+    pBufDesc = (pMixBufferDesc) _this->hidden->pMixBuffers[i].ulUserParm;
+    if (pBufDesc->iBufferUsage == BUFFER_EMPTY)
+      return;
+  }
+  // If there is no empty buffer, wait for one to be empty!
+  DosWaitEventSem(_this->hidden->hevAudioBufferPlayed, 1000); // Wait max 1 sec!!! Important!
+  return;
+}
+
+void DART_PlayAudio(_THIS)
+{
+  int iFreeBuf = _this->hidden->iNextFreeBuffer;
+  pMixBufferDesc pBufDesc;
+
+  pBufDesc = (pMixBufferDesc) _this->hidden->pMixBuffers[iFreeBuf].ulUserParm;
+  pBufDesc->iBufferUsage = BUFFER_USED;
+  // Send it to DART to be queued
+  _this->hidden->MixSetupParms.pmixWrite(_this->hidden->MixSetupParms.ulMixHandle,
+                                        &(_this->hidden->pMixBuffers[iFreeBuf]), 1);
+
+  _this->hidden->iLastPlayedBuf = iFreeBuf;
+  iFreeBuf = (iFreeBuf+1) % _this->hidden->iCurrNumBufs;
+  _this->hidden->iNextFreeBuffer = iFreeBuf;
+}
+
+Uint8 *DART_GetAudioBuf(_THIS)
+{
+  int iFreeBuf;
+  Uint8 *pResult;
+  pMixBufferDesc pBufDesc;
+
+  if (_this)
+  {
+    if (_this->hidden)
+    {
+      iFreeBuf = _this->hidden->iNextFreeBuffer;
+      pBufDesc = (pMixBufferDesc) _this->hidden->pMixBuffers[iFreeBuf].ulUserParm;
+      
+      if (pBufDesc)
+      {
+        if (pBufDesc->iBufferUsage == BUFFER_EMPTY)
+        {
+          pResult = _this->hidden->pMixBuffers[iFreeBuf].pBuffer;
+          return pResult; 
+        }
+      } else
+        printf("[DART_GetAudioBuf] : ERROR! pBufDesc = %p\n", pBufDesc);
+    } else
+      printf("[DART_GetAudioBuf] : ERROR! _this->hidden = %p\n", _this->hidden);
+  } else
+    printf("[DART_GetAudioBuf] : ERROR! _this = %p\n", _this);
+  return NULL;
+}
+
+void DART_WaitDone(_THIS)
+{
+  pMixBufferDesc pBufDesc;
+  ULONG ulPostCount;
+  APIRET rc;
+
+  pBufDesc = (pMixBufferDesc) _this->hidden->pMixBuffers[_this->hidden->iLastPlayedBuf].ulUserParm;
+  rc = NO_ERROR;
+  while ((pBufDesc->iBufferUsage != BUFFER_EMPTY) && (rc==NO_ERROR))
+  {
+    DosResetEventSem(_this->hidden->hevAudioBufferPlayed, &ulPostCount);
+    rc = DosWaitEventSem(_this->hidden->hevAudioBufferPlayed, 1000); // 1 sec timeout! Important!
+  }
+}
+
+void DART_CloseAudio(_THIS)
+{
+  MCI_GENERIC_PARMS GenericParms;
+  int rc;
+
+  // Stop DART playback
+  rc = mciSendCommand(_this->hidden->iCurrDeviceOrd, MCI_STOP, MCI_WAIT, &GenericParms, 0);
+  if (rc!=MCIERR_SUCCESS)
+  {
+#ifdef SFX_DEBUG_BUILD
+    printf("Could not stop DART playback!\n");
+    fflush(stdout);
+#endif
+  }
+
+  // Close event semaphore
+  DosCloseEventSem(_this->hidden->hevAudioBufferPlayed);
+
+  // Free memory of buffer descriptions
+  {
+    int i;
+    for (i=0; i<_this->hidden->iCurrNumBufs; i++) SDL_free((void *)(_this->hidden->pMixBuffers[i].ulUserParm));
+  }
+
+  // Deallocate buffers
+  rc = mciSendCommand(_this->hidden->iCurrDeviceOrd, MCI_BUFFER, MCI_WAIT | MCI_DEALLOCATE_MEMORY, &(_this->hidden->BufferParms), 0);
+
+  // Free bufferlist
+  SDL_free(_this->hidden->pMixBuffers); _this->hidden->pMixBuffers = NULL;
+
+  // Close dart
+  rc = mciSendCommand(_this->hidden->iCurrDeviceOrd, MCI_CLOSE, MCI_WAIT, &(GenericParms), 0);
+}
+
+/* Audio driver bootstrap functions */
+
+int Audio_Available(void)
+{
+  return(1);
+}
+
+void Audio_DeleteDevice(SDL_AudioDevice *device)
+{
+  SDL_free(device->hidden);
+  SDL_free(device);
+}
+
+SDL_AudioDevice *Audio_CreateDevice(int devindex)
+{
+  SDL_AudioDevice *this;
+
+  /* Initialize all variables that we clean on shutdown */
+  this = (SDL_AudioDevice *)SDL_malloc(sizeof(SDL_AudioDevice));
+  if ( this )
+  {
+    SDL_memset(this, 0, (sizeof *this));
+    this->hidden = (struct SDL_PrivateAudioData *)
+      SDL_malloc((sizeof *this->hidden));
+  }
+  if ( (this == NULL) || (this->hidden == NULL) )
+  {
+    SDL_OutOfMemory();
+    if ( this )
+      SDL_free(this);
+    return(0);
+  }
+  SDL_memset(this->hidden, 0, (sizeof *this->hidden));
+
+  /* Set the function pointers */
+  this->OpenAudio = DART_OpenAudio;
+  this->ThreadInit = DART_ThreadInit;
+  this->WaitAudio = DART_WaitAudio;
+  this->PlayAudio = DART_PlayAudio;
+  this->GetAudioBuf = DART_GetAudioBuf;
+  this->WaitDone = DART_WaitDone;
+  this->CloseAudio = DART_CloseAudio;
+
+  this->free = Audio_DeleteDevice;
+
+  return this;
+}
+
+AudioBootStrap DART_bootstrap = {
+	"dart", "OS/2 Direct Audio RouTines (DART)",
+	Audio_Available, Audio_CreateDevice
+};
+

src/dep/src/SDL/audio/dart/SDL_dart.h

@@ -0,0 +1,63 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2006 Sam Lantinga
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+    Sam Lantinga
+    slouken@libsdl.org
+*/
+#include "SDL_config.h"
+
+#ifndef _SDL_lowaudio_h
+#define _SDL_lowaudio_h
+
+#define INCL_TYPES
+#define INCL_DOSSEMAPHORES
+#define INCL_DOSRESOURCES
+#define INCL_DOSMISC
+#define INCL_DOSERRORS
+
+#define INCL_OS2MM
+#define INCL_MMIOOS2
+#define INCL_MCIOS2
+#include <os2.h>
+#include <os2me.h>     // DART stuff and MMIO stuff
+
+#include "../SDL_sysaudio.h"
+
+/* Hidden "this" pointer for the audio functions */
+#define _THIS	SDL_AudioDevice *_this
+
+/* The DirectSound objects */
+struct SDL_PrivateAudioData
+{
+  int iCurrDeviceOrd;
+  int iCurrFreq;
+  int iCurrBits;
+  int iCurrChannels;
+  int iCurrNumBufs;
+  int iCurrBufSize;
+
+  int iLastPlayedBuf;
+  int iNextFreeBuffer;
+
+  MCI_BUFFER_PARMS BufferParms;     // Sound buffer parameters
+  MCI_MIX_BUFFER *pMixBuffers;      // Sound buffers
+  MCI_MIXSETUP_PARMS MixSetupParms; // Mixer setup parameters
+  HEV hevAudioBufferPlayed;         // Event semaphore to indicate that an audio buffer has been played by DART
+};
+
+#endif /* _SDL_lowaudio_h */

src/dep/src/SDL/audio/dc/SDL_dcaudio.c

@@ -0,0 +1,229 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2006 Sam Lantinga
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+    Sam Lantinga
+    slouken@libsdl.org
+
+*/
+#include "SDL_config.h"
+
+/* Output dreamcast aica */
+
+#include "SDL_timer.h"
+#include "SDL_audio.h"
+#include "../SDL_audiomem.h"
+#include "../SDL_audio_c.h"
+#include "../SDL_audiodev_c.h"
+#include "SDL_dcaudio.h"
+
+#include "aica.h"
+#include <dc/spu.h>
+
+/* Audio driver functions */
+static int DCAUD_OpenAudio(_THIS, SDL_AudioSpec *spec);
+static void DCAUD_WaitAudio(_THIS);
+static void DCAUD_PlayAudio(_THIS);
+static Uint8 *DCAUD_GetAudioBuf(_THIS);
+static void DCAUD_CloseAudio(_THIS);
+
+/* Audio driver bootstrap functions */
+static int DCAUD_Available(void)
+{
+	return 1;
+}
+
+static void DCAUD_DeleteDevice(SDL_AudioDevice *device)
+{
+	SDL_free(device->hidden);
+	SDL_free(device);
+}
+
+static SDL_AudioDevice *DCAUD_CreateDevice(int devindex)
+{
+	SDL_AudioDevice *this;
+
+	/* Initialize all variables that we clean on shutdown */
+	this = (SDL_AudioDevice *)SDL_malloc(sizeof(SDL_AudioDevice));
+	if ( this ) {
+		SDL_memset(this, 0, (sizeof *this));
+		this->hidden = (struct SDL_PrivateAudioData *)
+				SDL_malloc((sizeof *this->hidden));
+	}
+	if ( (this == NULL) || (this->hidden == NULL) ) {
+		SDL_OutOfMemory();
+		if ( this ) {
+			SDL_free(this);
+		}
+		return(0);
+	}
+	SDL_memset(this->hidden, 0, (sizeof *this->hidden));
+
+	/* Set the function pointers */
+	this->OpenAudio = DCAUD_OpenAudio;
+	this->WaitAudio = DCAUD_WaitAudio;
+	this->PlayAudio = DCAUD_PlayAudio;
+	this->GetAudioBuf = DCAUD_GetAudioBuf;
+	this->CloseAudio = DCAUD_CloseAudio;
+
+	this->free = DCAUD_DeleteDevice;
+
+	spu_init();
+
+	return this;
+}
+
+AudioBootStrap DCAUD_bootstrap = {
+	"dcaudio", "Dreamcast AICA audio",
+	DCAUD_Available, DCAUD_CreateDevice
+};
+
+/* This function waits until it is possible to write a full sound buffer */
+static void DCAUD_WaitAudio(_THIS)
+{
+	if (this->hidden->playing) {
+		/* wait */
+		while(aica_get_pos(0)/this->spec.samples == this->hidden->nextbuf) {
+			thd_pass();
+		}
+	}
+}
+
+#define	SPU_RAM_BASE	0xa0800000
+
+static void spu_memload_stereo8(int leftpos,int rightpos,void *src0,size_t size)
+{
+	uint8 *src = src0;
+	uint32 *left  = (uint32*)(leftpos +SPU_RAM_BASE);
+	uint32 *right = (uint32*)(rightpos+SPU_RAM_BASE);
+	size = (size+7)/8;
+	while(size--) {
+		unsigned lval,rval;
+		lval = *src++;
+		rval = *src++;
+		lval|= (*src++)<<8;
+		rval|= (*src++)<<8;
+		lval|= (*src++)<<16;
+		rval|= (*src++)<<16;
+		lval|= (*src++)<<24;
+		rval|= (*src++)<<24;
+		g2_write_32(left++,lval);
+		g2_write_32(right++,rval);
+		g2_fifo_wait();
+	}
+}
+
+static void spu_memload_stereo16(int leftpos,int rightpos,void *src0,size_t size)
+{
+	uint16 *src = src0;
+	uint32 *left  = (uint32*)(leftpos +SPU_RAM_BASE);
+	uint32 *right = (uint32*)(rightpos+SPU_RAM_BASE);
+	size = (size+7)/8;
+	while(size--) {
+		unsigned lval,rval;
+		lval = *src++;
+		rval = *src++;
+		lval|= (*src++)<<16;
+		rval|= (*src++)<<16;
+		g2_write_32(left++,lval);
+		g2_write_32(right++,rval);
+		g2_fifo_wait();
+	}
+}
+
+static void DCAUD_PlayAudio(_THIS)
+{
+	SDL_AudioSpec *spec = &this->spec;
+	unsigned int offset;
+
+	if (this->hidden->playing) {
+		/* wait */
+		while(aica_get_pos(0)/spec->samples == this->hidden->nextbuf) {
+			thd_pass();
+		}
+	}
+
+	offset = this->hidden->nextbuf*spec->size;
+	this->hidden->nextbuf^=1;
+	/* Write the audio data, checking for EAGAIN on broken audio drivers */
+	if (spec->channels==1) {
+		spu_memload(this->hidden->leftpos+offset,this->hidden->mixbuf,this->hidden->mixlen);
+	} else {
+		offset/=2;
+		if ((this->spec.format&255)==8) {
+			spu_memload_stereo8(this->hidden->leftpos+offset,this->hidden->rightpos+offset,this->hidden->mixbuf,this->hidden->mixlen);
+		} else {
+			spu_memload_stereo16(this->hidden->leftpos+offset,this->hidden->rightpos+offset,this->hidden->mixbuf,this->hidden->mixlen);
+		}
+	}
+
+	if (!this->hidden->playing) {
+		int mode;
+		this->hidden->playing = 1;
+		mode = (spec->format==AUDIO_S8)?SM_8BIT:SM_16BIT;
+		if (spec->channels==1) {
+			aica_play(0,mode,this->hidden->leftpos,0,spec->samples*2,spec->freq,255,128,1);
+		} else {
+			aica_play(0,mode,this->hidden->leftpos ,0,spec->samples*2,spec->freq,255,0,1);
+			aica_play(1,mode,this->hidden->rightpos,0,spec->samples*2,spec->freq,255,255,1);
+		}
+	}
+}
+
+static Uint8 *DCAUD_GetAudioBuf(_THIS)
+{
+	return(this->hidden->mixbuf);
+}
+
+static void DCAUD_CloseAudio(_THIS)
+{
+	aica_stop(0);
+	if (this->spec.channels==2) aica_stop(1);
+	if ( this->hidden->mixbuf != NULL ) {
+		SDL_FreeAudioMem(this->hidden->mixbuf);
+		this->hidden->mixbuf = NULL;
+	}
+}
+
+static int DCAUD_OpenAudio(_THIS, SDL_AudioSpec *spec)
+{
+	switch(spec->format&0xff) {
+	case  8: spec->format = AUDIO_S8; break;
+	case 16: spec->format = AUDIO_S16LSB; break;
+	default:
+		SDL_SetError("Unsupported audio format");
+		return(-1);
+	}
+
+	/* Update the fragment size as size in bytes */
+	SDL_CalculateAudioSpec(spec);
+
+	/* Allocate mixing buffer */
+	this->hidden->mixlen = spec->size;
+	this->hidden->mixbuf = (Uint8 *) SDL_AllocAudioMem(this->hidden->mixlen);
+	if ( this->hidden->mixbuf == NULL ) {
+		return(-1);
+	}
+	SDL_memset(this->hidden->mixbuf, spec->silence, spec->size);
+	this->hidden->leftpos = 0x11000;
+	this->hidden->rightpos = 0x11000+spec->size;
+	this->hidden->playing = 0;
+	this->hidden->nextbuf = 0;
+
+	/* We're ready to rock and roll. :-) */
+	return(0);
+}

src/dep/src/SDL/audio/dc/SDL_dcaudio.h

@@ -0,0 +1,41 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2006 Sam Lantinga
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+    Sam Lantinga
+    slouken@libsdl.org
+*/
+#include "SDL_config.h"
+
+#ifndef _SDL_dcaudio_h
+#define _SDL_dcaudio_h
+
+#include "../SDL_sysaudio.h"
+
+/* Hidden "this" pointer for the video functions */
+#define _THIS	SDL_AudioDevice *this
+
+struct SDL_PrivateAudioData {
+	/* The file descriptor for the audio device */
+	Uint8 *mixbuf;
+	Uint32 mixlen;
+	int playing;
+	int leftpos,rightpos;
+	int nextbuf;
+};
+
+#endif /* _SDL_dcaudio_h */

src/dep/src/SDL/audio/dc/aica.c

@@ -0,0 +1,271 @@
+/* This file is part of the Dreamcast function library.
+ * Please see libdream.c for further details.
+ *
+ * (c)2000 Dan Potter
+ * modify BERO
+ */
+#include "aica.h"
+
+#include <arch/irq.h>
+#include <dc/spu.h>
+
+/* #define dc_snd_base ((volatile unsigned char *)0x00800000) */ /* arm side */
+#define dc_snd_base ((volatile unsigned char *)0xa0700000) /* dc side */
+
+/* Some convienence macros */
+#define	SNDREGADDR(x)	(0xa0700000 + (x))
+#define	CHNREGADDR(ch,x)	SNDREGADDR(0x80*(ch)+(x))
+
+
+#define SNDREG32(x)	(*(volatile unsigned long *)SNDREGADDR(x))
+#define SNDREG8(x)	(*(volatile unsigned char *)SNDREGADDR(x))
+#define CHNREG32(ch, x) (*(volatile unsigned long *)CHNREGADDR(ch,x))
+#define CHNREG8(ch, x)	(*(volatile unsigned long *)CHNREGADDR(ch,x))
+
+#define G2_LOCK(OLD) \
+	do { \
+		if (!irq_inside_int()) \
+			OLD = irq_disable(); \
+		/* suspend any G2 DMA here... */ \
+		while((*(volatile unsigned int *)0xa05f688c) & 0x20) \
+			; \
+	} while(0)
+
+#define G2_UNLOCK(OLD) \
+	do { \
+		/* resume any G2 DMA here... */ \
+		if (!irq_inside_int()) \
+			irq_restore(OLD); \
+	} while(0)
+
+
+void aica_init() {
+	int i, j, old = 0;
+	
+	/* Initialize AICA channels */	
+	G2_LOCK(old);
+	SNDREG32(0x2800) = 0x0000;
+	
+	for (i=0; i<64; i++) {
+		for (j=0; j<0x80; j+=4) {
+			if ((j&31)==0) g2_fifo_wait();
+			CHNREG32(i, j) = 0;
+		}
+		g2_fifo_wait();
+		CHNREG32(i,0) = 0x8000;
+		CHNREG32(i,20) = 0x1f;
+	}
+
+	SNDREG32(0x2800) = 0x000f;
+	g2_fifo_wait();
+	G2_UNLOCK(old);
+}
+
+/* Translates a volume from linear form to logarithmic form (required by
+   the AICA chip */
+/* int logs[] = {
+
+0, 40, 50, 58, 63, 68, 73, 77, 80, 83, 86, 89, 92, 94, 97, 99, 101, 103,
+105, 107, 109, 111, 112, 114, 116, 117, 119, 120, 122, 123, 125, 126, 127,
+129, 130, 131, 133, 134, 135, 136, 137, 139, 140, 141, 142, 143, 144, 145,
+146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 156, 157, 158, 159,
+160, 161, 162, 162, 163, 164, 165, 166, 166, 167, 168, 169, 170, 170, 171,
+172, 172, 173, 174, 175, 175, 176, 177, 177, 178, 179, 180, 180, 181, 182,
+182, 183, 183, 184, 185, 185, 186, 187, 187, 188, 188, 189, 190, 190, 191,
+191, 192, 193, 193, 194, 194, 195, 196, 196, 197, 197, 198, 198, 199, 199,
+200, 201, 201, 202, 202, 203, 203, 204, 204, 205, 205, 206, 206, 207, 207,
+208, 208, 209, 209, 210, 210, 211, 211, 212, 212, 213, 213, 214, 214, 215,
+215, 216, 216, 217, 217, 217, 218, 218, 219, 219, 220, 220, 221, 221, 222,
+222, 222, 223, 223, 224, 224, 225, 225, 225, 226, 226, 227, 227, 228, 228,
+228, 229, 229, 230, 230, 230, 231, 231, 232, 232, 232, 233, 233, 234, 234,
+234, 235, 235, 236, 236, 236, 237, 237, 238, 238, 238, 239, 239, 240, 240,
+240, 241, 241, 241, 242, 242, 243, 243, 243, 244, 244, 244, 245, 245, 245,
+246, 246, 247, 247, 247, 248, 248, 248, 249, 249, 249, 250, 250, 250, 251,
+251, 251, 252, 252, 252, 253, 253, 253, 254, 254, 254, 255
+
+}; */
+
+const static unsigned char logs[] = {
+	0, 15, 22, 27, 31, 35, 39, 42, 45, 47, 50, 52, 55, 57, 59, 61,
+	63, 65, 67, 69, 71, 73, 74, 76, 78, 79, 81, 82, 84, 85, 87, 88,
+	90, 91, 92, 94, 95, 96, 98, 99, 100, 102, 103, 104, 105, 106,
+	108, 109, 110, 111, 112, 113, 114, 116, 117, 118, 119, 120, 121,
+	122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134,
+	135, 136, 137, 138, 138, 139, 140, 141, 142, 143, 144, 145, 146,
+	146, 147, 148, 149, 150, 151, 152, 152, 153, 154, 155, 156, 156,
+	157, 158, 159, 160, 160, 161, 162, 163, 164, 164, 165, 166, 167,
+	167, 168, 169, 170, 170, 171, 172, 173, 173, 174, 175, 176, 176,
+	177, 178, 178, 179, 180, 181, 181, 182, 183, 183, 184, 185, 185,
+	186, 187, 187, 188, 189, 189, 190, 191, 191, 192, 193, 193, 194,
+	195, 195, 196, 197, 197, 198, 199, 199, 200, 200, 201, 202, 202,
+	203, 204, 204, 205, 205, 206, 207, 207, 208, 209, 209, 210, 210,
+	211, 212, 212, 213, 213, 214, 215, 215, 216, 216, 217, 217, 218,
+	219, 219, 220, 220, 221, 221, 222, 223, 223, 224, 224, 225, 225,
+	226, 227, 227, 228, 228, 229, 229, 230, 230, 231, 232, 232, 233,
+	233, 234, 234, 235, 235, 236, 236, 237, 237, 238, 239, 239, 240,
+	240, 241, 241, 242, 242, 243, 243, 244, 244, 245, 245, 246, 246,
+	247, 247, 248, 248, 249, 249, 250, 250, 251, 251, 252, 252, 253, 254, 255
+};
+
+/* For the moment this is going to have to suffice, until we really
+   figure out what these mean. */
+#define AICA_PAN(x) ((x)==0x80?(0):((x)<0x80?(0x1f):(0x0f)))
+#define AICA_VOL(x) (0xff - logs[128 + (((x) & 0xff) / 2)])
+//#define AICA_VOL(x) (0xff - logs[x&255])
+
+static inline unsigned  AICA_FREQ(unsigned freq)	{
+	unsigned long freq_lo, freq_base = 5644800;
+	int freq_hi = 7;
+
+	/* Need to convert frequency to floating point format
+	   (freq_hi is exponent, freq_lo is mantissa)
+	   Formula is ferq = 44100*2^freq_hi*(1+freq_lo/1024) */
+	while (freq < freq_base && freq_hi > -8) {
+		freq_base >>= 1;
+		--freq_hi;
+	}
+	while (freq < freq_base && freq_hi > -8) {
+		freq_base >>= 1;
+		freq_hi--;
+	}
+	freq_lo = (freq<<10) / freq_base;
+	return (freq_hi << 11) | (freq_lo & 1023);
+}
+
+/* Sets up a sound channel completely. This is generally good if you want
+   a quick and dirty way to play notes. If you want a more comprehensive
+   set of routines (more like PC wavetable cards) see below.
+   
+   ch is the channel to play on (0 - 63)
+   smpptr is the pointer to the sound data; if you're running off the
+     SH4, then this ought to be (ptr - 0xa0800000); otherwise it's just
+     ptr. Basically, it's an offset into sound ram.
+   mode is one of the mode constants (16 bit, 8 bit, ADPCM)
+   nsamp is the number of samples to play (not number of bytes!)
+   freq is the sampling rate of the sound
+   vol is the volume, 0 to 0xff (0xff is louder)
+   pan is a panning constant -- 0 is left, 128 is center, 255 is right.
+
+   This routine (and the similar ones) owe a lot to Marcus' sound example -- 
+   I hadn't gotten quite this far into dissecting the individual regs yet. */
+void aica_play(int ch,int mode,unsigned long smpptr,int loopst,int loopend,int freq,int vol,int pan,int loopflag) {
+/*	int i;
+*/
+	int val;
+	int old = 0;
+
+	/* Stop the channel (if it's already playing) */
+	aica_stop(ch);
+	/* doesn't seem to be needed, but it's here just in case */
+/*
+	for (i=0; i<256; i++) {
+		asm("nop");
+		asm("nop");
+		asm("nop");
+		asm("nop");
+	}
+*/
+	G2_LOCK(old);
+	/* Envelope setup. The first of these is the loop point,
+	   e.g., where the sample starts over when it loops. The second
+	   is the loop end. This is the full length of the sample when
+	   you are not looping, or the loop end point when you are (though
+	   storing more than that is a waste of memory if you're not doing
+	   volume enveloping). */
+	CHNREG32(ch, 8) = loopst & 0xffff;
+	CHNREG32(ch, 12) = loopend & 0xffff;
+	
+	/* Write resulting values */
+	CHNREG32(ch, 24) = AICA_FREQ(freq);
+	
+	/* Set volume, pan, and some other things that we don't know what
+	   they do =) */
+	CHNREG32(ch, 36) = AICA_PAN(pan) | (0xf<<8);
+	/* Convert the incoming volume and pan into hardware values */
+	/* Vol starts at zero so we can ramp */
+	vol = AICA_VOL(vol);
+	CHNREG32(ch, 40) = 0x24 | (vol<<8);
+	/* Convert the incoming volume and pan into hardware values */
+	/* Vol starts at zero so we can ramp */
+
+	/* If we supported volume envelopes (which we don't yet) then
+	   this value would set that up. The top 4 bits determine the
+	   envelope speed. f is the fastest, 1 is the slowest, and 0
+	   seems to be an invalid value and does weird things). The
+	   default (below) sets it into normal mode (play and terminate/loop).
+	CHNREG32(ch, 16) = 0xf010;
+	*/
+	CHNREG32(ch, 16) = 0x1f;	/* No volume envelope */
+	
+	
+	/* Set sample format, buffer address, and looping control. If
+	   0x0200 mask is set on reg 0, the sample loops infinitely. If
+	   it's not set, the sample plays once and terminates. We'll
+	   also set the bits to start playback here. */
+	CHNREG32(ch, 4) = smpptr & 0xffff;
+	val = 0xc000 | 0x0000 | (mode<<7) | (smpptr >> 16);
+	if (loopflag) val|=0x200;
+	
+	CHNREG32(ch, 0) = val;
+	
+	G2_UNLOCK(old);
+
+	/* Enable playback */
+	/* CHNREG32(ch, 0) |= 0xc000; */
+	g2_fifo_wait();
+
+#if 0
+	for (i=0xff; i>=vol; i--) {
+		if ((i&7)==0) g2_fifo_wait();
+		CHNREG32(ch, 40) =  0x24 | (i<<8);;
+	}
+
+	g2_fifo_wait();
+#endif
+}
+
+/* Stop the sound on a given channel */
+void aica_stop(int ch) {
+	g2_write_32(CHNREGADDR(ch, 0),(g2_read_32(CHNREGADDR(ch, 0)) & ~0x4000) | 0x8000);
+	g2_fifo_wait();
+}
+
+
+/* The rest of these routines can change the channel in mid-stride so you
+   can do things like vibrato and panning effects. */
+   
+/* Set channel volume */
+void aica_vol(int ch,int vol) {
+//	g2_write_8(CHNREGADDR(ch, 41),AICA_VOL(vol));
+	g2_write_32(CHNREGADDR(ch, 40),(g2_read_32(CHNREGADDR(ch, 40))&0xffff00ff)|(AICA_VOL(vol)<<8) );
+	g2_fifo_wait();
+}
+
+/* Set channel pan */
+void aica_pan(int ch,int pan) {
+//	g2_write_8(CHNREGADDR(ch, 36),AICA_PAN(pan));
+	g2_write_32(CHNREGADDR(ch, 36),(g2_read_32(CHNREGADDR(ch, 36))&0xffffff00)|(AICA_PAN(pan)) );
+	g2_fifo_wait();
+}
+
+/* Set channel frequency */
+void aica_freq(int ch,int freq) {
+	g2_write_32(CHNREGADDR(ch, 24),AICA_FREQ(freq));
+	g2_fifo_wait();
+}
+
+/* Get channel position */
+int aica_get_pos(int ch) {
+#if 1
+	/* Observe channel ch */
+	g2_write_32(SNDREGADDR(0x280c),(g2_read_32(SNDREGADDR(0x280c))&0xffff00ff) | (ch<<8));
+	g2_fifo_wait();
+	/* Update position counters */
+	return g2_read_32(SNDREGADDR(0x2814)) & 0xffff;
+#else
+	/* Observe channel ch */
+	g2_write_8(SNDREGADDR(0x280d),ch);
+	/* Update position counters */
+	return g2_read_32(SNDREGADDR(0x2814)) & 0xffff;
+#endif
+}

src/dep/src/SDL/audio/dc/aica.h

@@ -0,0 +1,40 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2006 Sam Lantinga
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+    Sam Lantinga
+    slouken@libsdl.org
+*/
+#include "SDL_config.h"
+
+#ifndef _AICA_H_
+#define _AICA_H_
+
+#define	AICA_MEM	0xa0800000
+
+#define SM_8BIT		1
+#define SM_16BIT	0
+#define SM_ADPCM	2
+
+void aica_play(int ch,int mode,unsigned long smpptr,int looptst,int loopend,int freq,int vol,int pan,int loopflag);
+void aica_stop(int ch);
+void aica_vol(int ch,int vol);
+void aica_pan(int ch,int pan);
+void aica_freq(int ch,int freq);
+int aica_get_pos(int ch);
+
+#endif

src/dep/src/SDL/audio/disk/SDL_diskaudio.c

@@ -0,0 +1,186 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2006 Sam Lantinga
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+    Sam Lantinga
+    slouken@libsdl.org
+
+    This file written by Ryan C. Gordon (icculus@icculus.org)
+*/
+#include "SDL_config.h"
+
+/* Output raw audio data to a file. */
+
+#if HAVE_STDIO_H
+#include <stdio.h>
+#endif
+
+#include "SDL_rwops.h"
+#include "SDL_timer.h"
+#include "SDL_audio.h"
+#include "../SDL_audiomem.h"
+#include "../SDL_audio_c.h"
+#include "../SDL_audiodev_c.h"
+#include "SDL_diskaudio.h"
+
+/* The tag name used by DISK audio */
+#define DISKAUD_DRIVER_NAME         "disk"
+
+/* environment variables and defaults. */
+#define DISKENVR_OUTFILE         "SDL_DISKAUDIOFILE"
+#define DISKDEFAULT_OUTFILE      "sdlaudio.raw"
+#define DISKENVR_WRITEDELAY      "SDL_DISKAUDIODELAY"
+#define DISKDEFAULT_WRITEDELAY   150
+
+/* Audio driver functions */
+static int DISKAUD_OpenAudio(_THIS, SDL_AudioSpec *spec);
+static void DISKAUD_WaitAudio(_THIS);
+static void DISKAUD_PlayAudio(_THIS);
+static Uint8 *DISKAUD_GetAudioBuf(_THIS);
+static void DISKAUD_CloseAudio(_THIS);
+
+static const char *DISKAUD_GetOutputFilename(void)
+{
+	const char *envr = SDL_getenv(DISKENVR_OUTFILE);
+	return((envr != NULL) ? envr : DISKDEFAULT_OUTFILE);
+}
+
+/* Audio driver bootstrap functions */
+static int DISKAUD_Available(void)
+{
+	const char *envr = SDL_getenv("SDL_AUDIODRIVER");
+	if (envr && (SDL_strcmp(envr, DISKAUD_DRIVER_NAME) == 0)) {
+		return(1);
+	}
+	return(0);
+}
+
+static void DISKAUD_DeleteDevice(SDL_AudioDevice *device)
+{
+	SDL_free(device->hidden);
+	SDL_free(device);
+}
+
+static SDL_AudioDevice *DISKAUD_CreateDevice(int devindex)
+{
+	SDL_AudioDevice *this;
+	const char *envr;
+
+	/* Initialize all variables that we clean on shutdown */
+	this = (SDL_AudioDevice *)SDL_malloc(sizeof(SDL_AudioDevice));
+	if ( this ) {
+		SDL_memset(this, 0, (sizeof *this));
+		this->hidden = (struct SDL_PrivateAudioData *)
+				SDL_malloc((sizeof *this->hidden));
+	}
+	if ( (this == NULL) || (this->hidden == NULL) ) {
+		SDL_OutOfMemory();
+		if ( this ) {
+			SDL_free(this);
+		}
+		return(0);
+	}
+	SDL_memset(this->hidden, 0, (sizeof *this->hidden));
+
+	envr = SDL_getenv(DISKENVR_WRITEDELAY);
+	this->hidden->write_delay = (envr) ? SDL_atoi(envr) : DISKDEFAULT_WRITEDELAY;
+
+	/* Set the function pointers */
+	this->OpenAudio = DISKAUD_OpenAudio;
+	this->WaitAudio = DISKAUD_WaitAudio;
+	this->PlayAudio = DISKAUD_PlayAudio;
+	this->GetAudioBuf = DISKAUD_GetAudioBuf;
+	this->CloseAudio = DISKAUD_CloseAudio;
+
+	this->free = DISKAUD_DeleteDevice;
+
+	return this;
+}
+
+AudioBootStrap DISKAUD_bootstrap = {
+	DISKAUD_DRIVER_NAME, "direct-to-disk audio",
+	DISKAUD_Available, DISKAUD_CreateDevice
+};
+
+/* This function waits until it is possible to write a full sound buffer */
+static void DISKAUD_WaitAudio(_THIS)
+{
+	SDL_Delay(this->hidden->write_delay);
+}
+
+static void DISKAUD_PlayAudio(_THIS)
+{
+	int written;
+
+	/* Write the audio data */
+	written = SDL_RWwrite(this->hidden->output,
+                        this->hidden->mixbuf, 1,
+                        this->hidden->mixlen);
+
+	/* If we couldn't write, assume fatal error for now */
+	if ( (Uint32)written != this->hidden->mixlen ) {
+		this->enabled = 0;
+	}
+#ifdef DEBUG_AUDIO
+	fprintf(stderr, "Wrote %d bytes of audio data\n", written);
+#endif
+}
+
+static Uint8 *DISKAUD_GetAudioBuf(_THIS)
+{
+	return(this->hidden->mixbuf);
+}
+
+static void DISKAUD_CloseAudio(_THIS)
+{
+	if ( this->hidden->mixbuf != NULL ) {
+		SDL_FreeAudioMem(this->hidden->mixbuf);
+		this->hidden->mixbuf = NULL;
+	}
+	if ( this->hidden->output != NULL ) {
+		SDL_RWclose(this->hidden->output);
+		this->hidden->output = NULL;
+	}
+}
+
+static int DISKAUD_OpenAudio(_THIS, SDL_AudioSpec *spec)
+{
+	const char *fname = DISKAUD_GetOutputFilename();
+
+	/* Open the audio device */
+	this->hidden->output = SDL_RWFromFile(fname, "wb");
+	if ( this->hidden->output == NULL ) {
+		return(-1);
+	}
+
+#if HAVE_STDIO_H
+	fprintf(stderr, "WARNING: You are using the SDL disk writer"
+                    " audio driver!\n Writing to file [%s].\n", fname);
+#endif
+
+	/* Allocate mixing buffer */
+	this->hidden->mixlen = spec->size;
+	this->hidden->mixbuf = (Uint8 *) SDL_AllocAudioMem(this->hidden->mixlen);
+	if ( this->hidden->mixbuf == NULL ) {
+		return(-1);
+	}
+	SDL_memset(this->hidden->mixbuf, spec->silence, spec->size);
+
+	/* We're ready to rock and roll. :-) */
+	return(0);
+}
+

src/dep/src/SDL/audio/disk/SDL_diskaudio.h

@@ -0,0 +1,41 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2006 Sam Lantinga
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+    Sam Lantinga
+    slouken@libsdl.org
+*/
+#include "SDL_config.h"
+
+#ifndef _SDL_diskaudio_h
+#define _SDL_diskaudio_h
+
+#include "SDL_rwops.h"
+#include "../SDL_sysaudio.h"
+
+/* Hidden "this" pointer for the video functions */
+#define _THIS	SDL_AudioDevice *this
+
+struct SDL_PrivateAudioData {
+	/* The file descriptor for the audio device */
+	SDL_RWops *output;
+	Uint8 *mixbuf;
+	Uint32 mixlen;
+	Uint32 write_delay;
+};
+
+#endif /* _SDL_diskaudio_h */

src/dep/src/SDL/audio/dma/SDL_dmaaudio.c

@@ -0,0 +1,455 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2006 Sam Lantinga
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+    Sam Lantinga
+    slouken@libsdl.org
+*/
+#include "SDL_config.h"
+
+/* Allow access to a raw mixing buffer */
+
+#include <stdio.h>
+#include <string.h>	/* For strerror() */
+#include <errno.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <signal.h>
+#include <sys/types.h>
+#include <sys/time.h>
+#include <sys/ioctl.h>
+#include <sys/stat.h>
+#include <sys/mman.h>
+
+#if SDL_AUDIO_DRIVER_OSS_SOUNDCARD_H
+/* This is installed on some systems */
+#include <soundcard.h>
+#else
+/* This is recommended by OSS */
+#include <sys/soundcard.h>
+#endif
+
+#ifndef MAP_FAILED
+#define MAP_FAILED	((Uint8 *)-1)
+#endif
+
+#include "SDL_timer.h"
+#include "SDL_audio.h"
+#include "../SDL_audio_c.h"
+#include "../SDL_audiodev_c.h"
+#include "SDL_dmaaudio.h"
+
+/* The tag name used by DMA audio */
+#define DMA_DRIVER_NAME         "dma"
+
+/* Open the audio device for playback, and don't block if busy */
+#define OPEN_FLAGS	(O_RDWR|O_NONBLOCK)
+
+/* Audio driver functions */
+static int DMA_OpenAudio(_THIS, SDL_AudioSpec *spec);
+static void DMA_WaitAudio(_THIS);
+static void DMA_PlayAudio(_THIS);
+static Uint8 *DMA_GetAudioBuf(_THIS);
+static void DMA_CloseAudio(_THIS);
+
+/* Audio driver bootstrap functions */
+
+static int Audio_Available(void)
+{
+	int available;
+	int fd;
+
+	available = 0;
+
+	fd = SDL_OpenAudioPath(NULL, 0, OPEN_FLAGS, 0);
+	if ( fd >= 0 ) {
+		int caps;
+		struct audio_buf_info info;
+
+		if ( (ioctl(fd, SNDCTL_DSP_GETCAPS, &caps) == 0) &&
+	             (caps & DSP_CAP_TRIGGER) && (caps & DSP_CAP_MMAP) &&
+		     (ioctl(fd, SNDCTL_DSP_GETOSPACE, &info) == 0) ) {
+			available = 1;
+		}
+		close(fd);
+	}
+	return(available);
+}
+
+static void Audio_DeleteDevice(SDL_AudioDevice *device)
+{
+	SDL_free(device->hidden);
+	SDL_free(device);
+}
+
+static SDL_AudioDevice *Audio_CreateDevice(int devindex)
+{
+	SDL_AudioDevice *this;
+
+	/* Initialize all variables that we clean on shutdown */
+	this = (SDL_AudioDevice *)SDL_malloc(sizeof(SDL_AudioDevice));
+	if ( this ) {
+		SDL_memset(this, 0, (sizeof *this));
+		this->hidden = (struct SDL_PrivateAudioData *)
+				SDL_malloc((sizeof *this->hidden));
+	}
+	if ( (this == NULL) || (this->hidden == NULL) ) {
+		SDL_OutOfMemory();
+		if ( this ) {
+			SDL_free(this);
+		}
+		return(0);
+	}
+	SDL_memset(this->hidden, 0, (sizeof *this->hidden));
+	audio_fd = -1;
+
+	/* Set the function pointers */
+	this->OpenAudio = DMA_OpenAudio;
+	this->WaitAudio = DMA_WaitAudio;
+	this->PlayAudio = DMA_PlayAudio;
+	this->GetAudioBuf = DMA_GetAudioBuf;
+	this->CloseAudio = DMA_CloseAudio;
+
+	this->free = Audio_DeleteDevice;
+
+	return this;
+}
+
+AudioBootStrap DMA_bootstrap = {
+	DMA_DRIVER_NAME, "OSS /dev/dsp DMA audio",
+	Audio_Available, Audio_CreateDevice
+};
+
+/* This function waits until it is possible to write a full sound buffer */
+static void DMA_WaitAudio(_THIS)
+{
+	fd_set fdset;
+
+	/* Check to see if the thread-parent process is still alive */
+	{ static int cnt = 0;
+		/* Note that this only works with thread implementations 
+		   that use a different process id for each thread.
+		*/
+		if (parent && (((++cnt)%10) == 0)) { /* Check every 10 loops */
+			if ( kill(parent, 0) < 0 ) {
+				this->enabled = 0;
+			}
+		}
+	}
+
+	/* See if we need to use timed audio synchronization */
+	if ( frame_ticks ) {
+		/* Use timer for general audio synchronization */
+		Sint32 ticks;
+
+		ticks = ((Sint32)(next_frame - SDL_GetTicks()))-FUDGE_TICKS;
+		if ( ticks > 0 ) {
+			SDL_Delay(ticks);
+		}
+	} else {
+		/* Use select() for audio synchronization */
+		struct timeval timeout;
+		FD_ZERO(&fdset);
+		FD_SET(audio_fd, &fdset);
+		timeout.tv_sec = 10;
+		timeout.tv_usec = 0;
+#ifdef DEBUG_AUDIO
+		fprintf(stderr, "Waiting for audio to get ready\n");
+#endif
+		if ( select(audio_fd+1, NULL, &fdset, NULL, &timeout) <= 0 ) {
+			const char *message =
+#ifdef AUDIO_OSPACE_HACK
+			"Audio timeout - buggy audio driver? (trying ospace)";
+#else
+			"Audio timeout - buggy audio driver? (disabled)";
+#endif
+			/* In general we should never print to the screen,
+			   but in this case we have no other way of letting
+			   the user know what happened.
+			*/
+			fprintf(stderr, "SDL: %s\n", message);
+#ifdef AUDIO_OSPACE_HACK
+			/* We may be able to use GET_OSPACE trick */
+			frame_ticks = (float)(this->spec->samples*1000) /
+			                      this->spec->freq;
+			next_frame = SDL_GetTicks()+frame_ticks;
+#else
+			this->enabled = 0;
+			/* Don't try to close - may hang */
+			audio_fd = -1;
+#ifdef DEBUG_AUDIO
+			fprintf(stderr, "Done disabling audio\n");
+#endif
+#endif /* AUDIO_OSPACE_HACK */
+		}
+#ifdef DEBUG_AUDIO
+		fprintf(stderr, "Ready!\n");
+#endif
+	}
+}
+
+static void DMA_PlayAudio(_THIS)
+{
+	/* If timer synchronization is enabled, set the next write frame */
+	if ( frame_ticks ) {
+		next_frame += frame_ticks;
+	}
+	return;
+}
+
+static Uint8 *DMA_GetAudioBuf(_THIS)
+{
+	count_info info;
+	int playing;
+	int filling;
+
+	/* Get number of blocks, looping if we're not using select() */
+	do {
+		if ( ioctl(audio_fd, SNDCTL_DSP_GETOPTR, &info) < 0 ) {
+			/* Uh oh... */
+			this->enabled = 0;
+			return(NULL);
+		}
+	} while ( frame_ticks && (info.blocks < 1) );
+#ifdef DEBUG_AUDIO
+	if ( info.blocks > 1 ) {
+		printf("Warning: audio underflow (%d frags)\n", info.blocks-1);
+	}
+#endif
+	playing = info.ptr / this->spec.size;
+	filling = (playing + 1)%num_buffers;
+	return (dma_buf + (filling * this->spec.size));
+}
+
+static void DMA_CloseAudio(_THIS)
+{
+	if ( dma_buf != NULL ) {
+		munmap(dma_buf, dma_len);
+		dma_buf = NULL;
+	}
+	if ( audio_fd >= 0 ) {
+		close(audio_fd);
+		audio_fd = -1;
+	}
+}
+
+static int DMA_ReopenAudio(_THIS, const char *audiodev, int format, int stereo,
+							SDL_AudioSpec *spec)
+{
+	int frag_spec;
+	int value;
+
+	/* Close and then reopen the audio device */
+	close(audio_fd);
+	audio_fd = open(audiodev, O_RDWR, 0);
+	if ( audio_fd < 0 ) {
+		SDL_SetError("Couldn't open %s: %s", audiodev, strerror(errno));
+		return(-1);
+	}
+
+	/* Calculate the final parameters for this audio specification */
+	SDL_CalculateAudioSpec(spec);
+
+	/* Determine the power of two of the fragment size */
+	for ( frag_spec = 0; (0x01<<frag_spec) < spec->size; ++frag_spec );
+	if ( (0x01<<frag_spec) != spec->size ) {
+		SDL_SetError("Fragment size must be a power of two");
+		return(-1);
+	}
+
+	/* Set the audio buffering parameters */
+	if ( ioctl(audio_fd, SNDCTL_DSP_SETFRAGMENT, &frag_spec) < 0 ) {
+		SDL_SetError("Couldn't set audio fragment spec");
+		return(-1);
+	}
+
+	/* Set the audio format */
+	value = format;
+	if ( (ioctl(audio_fd, SNDCTL_DSP_SETFMT, &value) < 0) ||
+						(value != format) ) {
+		SDL_SetError("Couldn't set audio format");
+		return(-1);
+	}
+
+	/* Set mono or stereo audio */
+	value = (spec->channels > 1);
+	if ( (ioctl(audio_fd, SNDCTL_DSP_STEREO, &stereo) < 0) ||
+						(value != stereo) ) {
+		SDL_SetError("Couldn't set audio channels");
+		return(-1);
+	}
+
+	/* Set the DSP frequency */
+	value = spec->freq;
+	if ( ioctl(audio_fd, SNDCTL_DSP_SPEED, &value) < 0 ) {
+		SDL_SetError("Couldn't set audio frequency");
+		return(-1);
+	}
+	spec->freq = value;
+
+	/* We successfully re-opened the audio */
+	return(0);
+}
+
+static int DMA_OpenAudio(_THIS, SDL_AudioSpec *spec)
+{
+	char audiodev[1024];
+	int format;
+	int stereo;
+	int value;
+	Uint16 test_format;
+	struct audio_buf_info info;
+
+	/* Reset the timer synchronization flag */
+	frame_ticks = 0.0;
+
+	/* Open the audio device */
+	audio_fd = SDL_OpenAudioPath(audiodev, sizeof(audiodev), OPEN_FLAGS, 0);
+	if ( audio_fd < 0 ) {
+		SDL_SetError("Couldn't open %s: %s", audiodev, strerror(errno));
+		return(-1);
+	}
+	dma_buf = NULL;
+	ioctl(audio_fd, SNDCTL_DSP_RESET, 0);
+
+	/* Get a list of supported hardware formats */
+	if ( ioctl(audio_fd, SNDCTL_DSP_GETFMTS, &value) < 0 ) {
+		SDL_SetError("Couldn't get audio format list");
+		return(-1);
+	}
+
+	/* Try for a closest match on audio format */
+	format = 0;
+	for ( test_format = SDL_FirstAudioFormat(spec->format);
+						! format && test_format; ) {
+#ifdef DEBUG_AUDIO
+		fprintf(stderr, "Trying format 0x%4.4x\n", test_format);
+#endif
+		switch ( test_format ) {
+			case AUDIO_U8:
+				if ( value & AFMT_U8 ) {
+					format = AFMT_U8;
+				}
+				break;
+			case AUDIO_S8:
+				if ( value & AFMT_S8 ) {
+					format = AFMT_S8;
+				}
+				break;
+			case AUDIO_S16LSB:
+				if ( value & AFMT_S16_LE ) {
+					format = AFMT_S16_LE;
+				}
+				break;
+			case AUDIO_S16MSB:
+				if ( value & AFMT_S16_BE ) {
+					format = AFMT_S16_BE;
+				}
+				break;
+			case AUDIO_U16LSB:
+				if ( value & AFMT_U16_LE ) {
+					format = AFMT_U16_LE;
+				}
+				break;
+			case AUDIO_U16MSB:
+				if ( value & AFMT_U16_BE ) {
+					format = AFMT_U16_BE;
+				}
+				break;
+			default:
+				format = 0;
+				break;
+		}
+		if ( ! format ) {
+			test_format = SDL_NextAudioFormat();
+		}
+	}
+	if ( format == 0 ) {
+		SDL_SetError("Couldn't find any hardware audio formats");
+		return(-1);
+	}
+	spec->format = test_format;
+
+	/* Set the audio format */
+	value = format;
+	if ( (ioctl(audio_fd, SNDCTL_DSP_SETFMT, &value) < 0) ||
+						(value != format) ) {
+		SDL_SetError("Couldn't set audio format");
+		return(-1);
+	}
+
+	/* Set mono or stereo audio (currently only two channels supported) */
+	stereo = (spec->channels > 1);
+	ioctl(audio_fd, SNDCTL_DSP_STEREO, &stereo);
+	if ( stereo ) {
+		spec->channels = 2;
+	} else {
+		spec->channels = 1;
+	}
+
+	/* Because some drivers don't allow setting the buffer size
+	   after setting the format, we must re-open the audio device
+	   once we know what format and channels are supported
+	 */
+	if ( DMA_ReopenAudio(this, audiodev, format, stereo, spec) < 0 ) {
+		/* Error is set by DMA_ReopenAudio() */
+		return(-1);
+	}
+
+	/* Memory map the audio buffer */
+	if ( ioctl(audio_fd, SNDCTL_DSP_GETOSPACE, &info) < 0 ) {
+		SDL_SetError("Couldn't get OSPACE parameters");
+		return(-1);
+	}
+	spec->size = info.fragsize;
+	spec->samples = spec->size / ((spec->format & 0xFF) / 8);
+	spec->samples /= spec->channels;
+	num_buffers = info.fragstotal;
+	dma_len = num_buffers*spec->size;
+	dma_buf = (Uint8 *)mmap(NULL, dma_len, PROT_WRITE, MAP_SHARED,
+							audio_fd, 0);
+	if ( dma_buf == MAP_FAILED ) {
+		SDL_SetError("DMA memory map failed");
+		dma_buf = NULL;
+		return(-1);
+	}
+	SDL_memset(dma_buf, spec->silence, dma_len);
+
+	/* Check to see if we need to use select() workaround */
+	{ char *workaround;
+		workaround = SDL_getenv("SDL_DSP_NOSELECT");
+		if ( workaround ) {
+			frame_ticks = (float)(spec->samples*1000)/spec->freq;
+			next_frame = SDL_GetTicks()+frame_ticks;
+		}
+	}
+
+	/* Trigger audio playback */
+	value = 0;
+	ioctl(audio_fd, SNDCTL_DSP_SETTRIGGER, &value);
+	value = PCM_ENABLE_OUTPUT;
+	if ( ioctl(audio_fd, SNDCTL_DSP_SETTRIGGER, &value) < 0 ) {
+		SDL_SetError("Couldn't trigger audio output");
+		return(-1);
+	}
+
+	/* Get the parent process id (we're the parent of the audio thread) */
+	parent = getpid();
+
+	/* We're ready to rock and roll. :-) */
+	return(0);
+}

src/dep/src/SDL/audio/dma/SDL_dmaaudio.h

@@ -0,0 +1,59 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2006 Sam Lantinga
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+    Sam Lantinga
+    slouken@libsdl.org
+*/
+#include "SDL_config.h"
+
+#ifndef _SDL_dspaudio_h
+#define _SDL_dspaudio_h
+
+#include "../SDL_sysaudio.h"
+
+/* Hidden "this" pointer for the video functions */
+#define _THIS	SDL_AudioDevice *this
+
+struct SDL_PrivateAudioData {
+	/* The file descriptor for the audio device */
+	int audio_fd;
+
+	/* The parent process id, to detect when application quits */
+	pid_t parent;
+
+	/* Raw mixing buffer */
+	Uint8 *dma_buf;
+	int    dma_len;
+	int num_buffers;
+
+	/* Support for audio timing using a timer, in addition to select() */
+	float frame_ticks;
+	float next_frame;
+};
+#define FUDGE_TICKS	10	/* The scheduler overhead ticks per frame */
+
+/* Old variable names */
+#define audio_fd		(this->hidden->audio_fd)
+#define parent			(this->hidden->parent)
+#define dma_buf			(this->hidden->dma_buf)
+#define dma_len			(this->hidden->dma_len)
+#define num_buffers		(this->hidden->num_buffers)
+#define frame_ticks		(this->hidden->frame_ticks)
+#define next_frame		(this->hidden->next_frame)
+
+#endif /* _SDL_dspaudio_h */

src/dep/src/SDL/audio/dmedia/SDL_irixaudio.c

@@ -0,0 +1,216 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2006 Sam Lantinga
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+    Sam Lantinga
+    slouken@libsdl.org
+*/
+#include "SDL_config.h"
+
+/* Allow access to a raw mixing buffer (For IRIX 6.5 and higher) */
+/* patch for IRIX 5 by Georg Schwarz 18/07/2004 */
+
+#include "SDL_timer.h"
+#include "SDL_audio.h"
+#include "../SDL_audiomem.h"
+#include "../SDL_audio_c.h"
+#include "SDL_irixaudio.h"
+
+
+#ifndef AL_RESOURCE /* as a test whether we use the old IRIX audio libraries */
+#define OLD_IRIX_AUDIO
+#define alClosePort(x) ALcloseport(x)
+#define alFreeConfig(x) ALfreeconfig(x)
+#define alGetFillable(x) ALgetfillable(x)
+#define alNewConfig() ALnewconfig()
+#define alOpenPort(x,y,z) ALopenport(x,y,z)
+#define alSetChannels(x,y) ALsetchannels(x,y)
+#define alSetQueueSize(x,y) ALsetqueuesize(x,y)
+#define alSetSampFmt(x,y) ALsetsampfmt(x,y)
+#define alSetWidth(x,y) ALsetwidth(x,y)
+#endif
+
+/* Audio driver functions */
+static int AL_OpenAudio(_THIS, SDL_AudioSpec *spec);
+static void AL_WaitAudio(_THIS);
+static void AL_PlayAudio(_THIS);
+static Uint8 *AL_GetAudioBuf(_THIS);
+static void AL_CloseAudio(_THIS);
+
+/* Audio driver bootstrap functions */
+
+static int Audio_Available(void)
+{
+	return 1;
+}
+
+static void Audio_DeleteDevice(SDL_AudioDevice *device)
+{
+	SDL_free(device->hidden);
+	SDL_free(device);
+}
+
+static SDL_AudioDevice *Audio_CreateDevice(int devindex)
+{
+	SDL_AudioDevice *this;
+
+	/* Initialize all variables that we clean on shutdown */
+	this = (SDL_AudioDevice *)SDL_malloc(sizeof(SDL_AudioDevice));
+	if ( this ) {
+		SDL_memset(this, 0, (sizeof *this));
+		this->hidden = (struct SDL_PrivateAudioData *)
+				SDL_malloc((sizeof *this->hidden));
+	}
+	if ( (this == NULL) || (this->hidden == NULL) ) {
+		SDL_OutOfMemory();
+		if ( this ) {
+			SDL_free(this);
+		}
+		return(0);
+	}
+	SDL_memset(this->hidden, 0, (sizeof *this->hidden));
+
+	/* Set the function pointers */
+	this->OpenAudio = AL_OpenAudio;
+	this->WaitAudio = AL_WaitAudio;
+	this->PlayAudio = AL_PlayAudio;
+	this->GetAudioBuf = AL_GetAudioBuf;
+	this->CloseAudio = AL_CloseAudio;
+
+	this->free = Audio_DeleteDevice;
+
+	return this;
+}
+
+AudioBootStrap DMEDIA_bootstrap = {
+	"AL", "IRIX DMedia audio",
+	Audio_Available, Audio_CreateDevice
+};
+
+
+void static AL_WaitAudio(_THIS)
+{
+	Sint32 timeleft;
+
+	timeleft = this->spec.samples - alGetFillable(audio_port);
+	if ( timeleft > 0 ) {
+		timeleft /= (this->spec.freq/1000);
+		SDL_Delay((Uint32)timeleft);
+	}
+}
+
+static void AL_PlayAudio(_THIS)
+{
+	/* Write the audio data out */
+	if ( alWriteFrames(audio_port, mixbuf, this->spec.samples) < 0 ) {
+		/* Assume fatal error, for now */
+		this->enabled = 0;
+	}
+}
+
+static Uint8 *AL_GetAudioBuf(_THIS)
+{
+	return(mixbuf);
+}
+
+static void AL_CloseAudio(_THIS)
+{
+	if ( mixbuf != NULL ) {
+		SDL_FreeAudioMem(mixbuf);
+		mixbuf = NULL;
+	}
+	if ( audio_port != NULL ) {
+		alClosePort(audio_port);
+		audio_port = NULL;
+	}
+}
+
+static int AL_OpenAudio(_THIS, SDL_AudioSpec *spec)
+{
+	ALconfig audio_config;
+#ifdef OLD_IRIX_AUDIO
+	long audio_param[2];
+#else
+	ALpv audio_param;
+#endif
+	int width;
+
+	/* Determine the audio parameters from the AudioSpec */
+	switch ( spec->format & 0xFF ) {
+
+		case 8: { /* Signed 8 bit audio data */
+			spec->format = AUDIO_S8;
+			width = AL_SAMPLE_8;
+		}
+		break;
+
+		case 16: { /* Signed 16 bit audio data */
+			spec->format = AUDIO_S16MSB;
+			width = AL_SAMPLE_16;
+		}
+		break;
+
+		default: {
+			SDL_SetError("Unsupported audio format");
+			return(-1);
+		}
+	}
+
+	/* Update the fragment size as size in bytes */
+	SDL_CalculateAudioSpec(spec);
+
+	/* Set output frequency */
+#ifdef OLD_IRIX_AUDIO
+	audio_param[0] = AL_OUTPUT_RATE;
+	audio_param[1] = spec->freq;
+	if( ALsetparams(AL_DEFAULT_DEVICE, audio_param, 2) < 0 ) {
+#else
+	audio_param.param = AL_RATE;
+	audio_param.value.i = spec->freq;
+	if( alSetParams(AL_DEFAULT_OUTPUT, &audio_param, 1) < 0 ) {
+#endif
+		SDL_SetError("alSetParams failed");
+		return(-1);
+	}
+
+	/* Open the audio port with the requested frequency */
+	audio_port = NULL;
+	audio_config = alNewConfig();
+	if ( audio_config &&
+	     (alSetSampFmt(audio_config, AL_SAMPFMT_TWOSCOMP) >= 0) &&
+	     (alSetWidth(audio_config, width) >= 0) &&
+	     (alSetQueueSize(audio_config, spec->samples*2) >= 0) &&
+	     (alSetChannels(audio_config, spec->channels) >= 0) ) {
+		audio_port = alOpenPort("SDL audio", "w", audio_config);
+	}
+	alFreeConfig(audio_config);
+	if( audio_port == NULL ) {
+		SDL_SetError("Unable to open audio port");
+		return(-1);
+	}
+
+	/* Allocate mixing buffer */
+	mixbuf = (Uint8 *)SDL_AllocAudioMem(spec->size);
+	if ( mixbuf == NULL ) {
+		SDL_OutOfMemory();
+		return(-1);
+	}
+	SDL_memset(mixbuf, spec->silence, spec->size);
+
+	/* We're ready to rock and roll. :-) */
+	return(0);
+}

src/dep/src/SDL/audio/dmedia/SDL_irixaudio.h

@@ -0,0 +1,45 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2006 Sam Lantinga
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+    Sam Lantinga
+    slouken@libsdl.org
+*/
+#include "SDL_config.h"
+
+#ifndef _SDL_lowaudio_h
+#define _SDL_lowaudio_h
+
+#include <dmedia/audio.h>
+
+#include "../SDL_sysaudio.h"
+
+/* Hidden "this" pointer for the audio functions */
+#define _THIS	SDL_AudioDevice *this
+
+struct SDL_PrivateAudioData {
+	/* The handle for the audio device */
+	ALport audio_port;
+
+	Uint8 *mixbuf;           /* The app mixing buffer */
+};
+
+/* Old variable names */
+#define audio_port		(this->hidden->audio_port)
+#define mixbuf			(this->hidden->mixbuf)
+
+#endif /* _SDL_lowaudio_h */

src/dep/src/SDL/audio/dsp/SDL_dspaudio.c

@@ -0,0 +1,331 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2006 Sam Lantinga
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+    Sam Lantinga
+    slouken@libsdl.org
+
+    Modified in Oct 2004 by Hannu Savolainen 
+    hannu@opensound.com
+*/
+#include "SDL_config.h"
+
+/* Allow access to a raw mixing buffer */
+
+#include <stdio.h>	/* For perror() */
+#include <string.h>	/* For strerror() */
+#include <errno.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <signal.h>
+#include <sys/time.h>
+#include <sys/ioctl.h>
+#include <sys/stat.h>
+
+#if SDL_AUDIO_DRIVER_OSS_SOUNDCARD_H
+/* This is installed on some systems */
+#include <soundcard.h>
+#else
+/* This is recommended by OSS */
+#include <sys/soundcard.h>
+#endif
+
+#include "SDL_timer.h"
+#include "SDL_audio.h"
+#include "../SDL_audiomem.h"
+#include "../SDL_audio_c.h"
+#include "../SDL_audiodev_c.h"
+#include "SDL_dspaudio.h"
+
+/* The tag name used by DSP audio */
+#define DSP_DRIVER_NAME         "dsp"
+
+/* Open the audio device for playback, and don't block if busy */
+#define OPEN_FLAGS	(O_WRONLY|O_NONBLOCK)
+
+/* Audio driver functions */
+static int DSP_OpenAudio(_THIS, SDL_AudioSpec *spec);
+static void DSP_WaitAudio(_THIS);
+static void DSP_PlayAudio(_THIS);
+static Uint8 *DSP_GetAudioBuf(_THIS);
+static void DSP_CloseAudio(_THIS);
+
+/* Audio driver bootstrap functions */
+
+static int Audio_Available(void)
+{
+	int fd;
+	int available;
+
+	available = 0;
+	fd = SDL_OpenAudioPath(NULL, 0, OPEN_FLAGS, 0);
+	if ( fd >= 0 ) {
+		available = 1;
+		close(fd);
+	}
+	return(available);
+}
+
+static void Audio_DeleteDevice(SDL_AudioDevice *device)
+{
+	SDL_free(device->hidden);
+	SDL_free(device);
+}
+
+static SDL_AudioDevice *Audio_CreateDevice(int devindex)
+{
+	SDL_AudioDevice *this;
+
+	/* Initialize all variables that we clean on shutdown */
+	this = (SDL_AudioDevice *)SDL_malloc(sizeof(SDL_AudioDevice));
+	if ( this ) {
+		SDL_memset(this, 0, (sizeof *this));
+		this->hidden = (struct SDL_PrivateAudioData *)
+				SDL_malloc((sizeof *this->hidden));
+	}
+	if ( (this == NULL) || (this->hidden == NULL) ) {
+		SDL_OutOfMemory();
+		if ( this ) {
+			SDL_free(this);
+		}
+		return(0);
+	}
+	SDL_memset(this->hidden, 0, (sizeof *this->hidden));
+	audio_fd = -1;
+
+	/* Set the function pointers */
+	this->OpenAudio = DSP_OpenAudio;
+	this->WaitAudio = DSP_WaitAudio;
+	this->PlayAudio = DSP_PlayAudio;
+	this->GetAudioBuf = DSP_GetAudioBuf;
+	this->CloseAudio = DSP_CloseAudio;
+
+	this->free = Audio_DeleteDevice;
+
+	return this;
+}
+
+AudioBootStrap DSP_bootstrap = {
+	DSP_DRIVER_NAME, "OSS /dev/dsp standard audio",
+	Audio_Available, Audio_CreateDevice
+};
+
+/* This function waits until it is possible to write a full sound buffer */
+static void DSP_WaitAudio(_THIS)
+{
+	/* Not needed at all since OSS handles waiting automagically */
+}
+
+static void DSP_PlayAudio(_THIS)
+{
+	if (write(audio_fd, mixbuf, mixlen)==-1)
+	{
+		perror("Audio write");
+		this->enabled = 0;
+	}
+
+#ifdef DEBUG_AUDIO
+	fprintf(stderr, "Wrote %d bytes of audio data\n", mixlen);
+#endif
+}
+
+static Uint8 *DSP_GetAudioBuf(_THIS)
+{
+	return(mixbuf);
+}
+
+static void DSP_CloseAudio(_THIS)
+{
+	if ( mixbuf != NULL ) {
+		SDL_FreeAudioMem(mixbuf);
+		mixbuf = NULL;
+	}
+	if ( audio_fd >= 0 ) {
+		close(audio_fd);
+		audio_fd = -1;
+	}
+}
+
+static int DSP_OpenAudio(_THIS, SDL_AudioSpec *spec)
+{
+	char audiodev[1024];
+	int format;
+	int value;
+	int frag_spec;
+	Uint16 test_format;
+
+	/* Open the audio device */
+	audio_fd = SDL_OpenAudioPath(audiodev, sizeof(audiodev), OPEN_FLAGS, 0);
+	if ( audio_fd < 0 ) {
+		SDL_SetError("Couldn't open %s: %s", audiodev, strerror(errno));
+		return(-1);
+	}
+	mixbuf = NULL;
+
+	/* Make the file descriptor use blocking writes with fcntl() */
+	{ long flags;
+		flags = fcntl(audio_fd, F_GETFL);
+		flags &= ~O_NONBLOCK;
+		if ( fcntl(audio_fd, F_SETFL, flags) < 0 ) {
+			SDL_SetError("Couldn't set audio blocking mode");
+			DSP_CloseAudio(this);
+			return(-1);
+		}
+	}
+
+	/* Get a list of supported hardware formats */
+	if ( ioctl(audio_fd, SNDCTL_DSP_GETFMTS, &value) < 0 ) {
+		perror("SNDCTL_DSP_GETFMTS");
+		SDL_SetError("Couldn't get audio format list");
+		DSP_CloseAudio(this);
+		return(-1);
+	}
+
+	/* Try for a closest match on audio format */
+	format = 0;
+	for ( test_format = SDL_FirstAudioFormat(spec->format);
+						! format && test_format; ) {
+#ifdef DEBUG_AUDIO
+		fprintf(stderr, "Trying format 0x%4.4x\n", test_format);
+#endif
+		switch ( test_format ) {
+			case AUDIO_U8:
+				if ( value & AFMT_U8 ) {
+					format = AFMT_U8;
+				}
+				break;
+			case AUDIO_S16LSB:
+				if ( value & AFMT_S16_LE ) {
+					format = AFMT_S16_LE;
+				}
+				break;
+			case AUDIO_S16MSB:
+				if ( value & AFMT_S16_BE ) {
+					format = AFMT_S16_BE;
+				}
+				break;
+#if 0
+/*
+ * These formats are not used by any real life systems so they are not 
+ * needed here.
+ */
+			case AUDIO_S8:
+				if ( value & AFMT_S8 ) {
+					format = AFMT_S8;
+				}
+				break;
+			case AUDIO_U16LSB:
+				if ( value & AFMT_U16_LE ) {
+					format = AFMT_U16_LE;
+				}
+				break;
+			case AUDIO_U16MSB:
+				if ( value & AFMT_U16_BE ) {
+					format = AFMT_U16_BE;
+				}
+				break;
+#endif
+			default:
+				format = 0;
+				break;
+		}
+		if ( ! format ) {
+			test_format = SDL_NextAudioFormat();
+		}
+	}
+	if ( format == 0 ) {
+		SDL_SetError("Couldn't find any hardware audio formats");
+		DSP_CloseAudio(this);
+		return(-1);
+	}
+	spec->format = test_format;
+
+	/* Set the audio format */
+	value = format;
+	if ( (ioctl(audio_fd, SNDCTL_DSP_SETFMT, &value) < 0) ||
+						(value != format) ) {
+		perror("SNDCTL_DSP_SETFMT");
+		SDL_SetError("Couldn't set audio format");
+		DSP_CloseAudio(this);
+		return(-1);
+	}
+
+	/* Set the number of channels of output */
+	value = spec->channels;
+	if ( ioctl(audio_fd, SNDCTL_DSP_CHANNELS, &value) < 0 ) {
+		perror("SNDCTL_DSP_CHANNELS");
+		SDL_SetError("Cannot set the number of channels");
+		DSP_CloseAudio(this);
+		return(-1);
+	}
+	spec->channels = value;
+
+	/* Set the DSP frequency */
+	value = spec->freq;
+	if ( ioctl(audio_fd, SNDCTL_DSP_SPEED, &value) < 0 ) {
+		perror("SNDCTL_DSP_SPEED");
+		SDL_SetError("Couldn't set audio frequency");
+		DSP_CloseAudio(this);
+		return(-1);
+	}
+	spec->freq = value;
+
+	/* Calculate the final parameters for this audio specification */
+	SDL_CalculateAudioSpec(spec);
+
+	/* Determine the power of two of the fragment size */
+	for ( frag_spec = 0; (0x01U<<frag_spec) < spec->size; ++frag_spec );
+	if ( (0x01U<<frag_spec) != spec->size ) {
+		SDL_SetError("Fragment size must be a power of two");
+		DSP_CloseAudio(this);
+		return(-1);
+	}
+	frag_spec |= 0x00020000;	/* two fragments, for low latency */
+
+	/* Set the audio buffering parameters */
+#ifdef DEBUG_AUDIO
+	fprintf(stderr, "Requesting %d fragments of size %d\n",
+		(frag_spec >> 16), 1<<(frag_spec&0xFFFF));
+#endif
+	if ( ioctl(audio_fd, SNDCTL_DSP_SETFRAGMENT, &frag_spec) < 0 ) {
+		perror("SNDCTL_DSP_SETFRAGMENT");
+	}
+#ifdef DEBUG_AUDIO
+	{ audio_buf_info info;
+	  ioctl(audio_fd, SNDCTL_DSP_GETOSPACE, &info);
+	  fprintf(stderr, "fragments = %d\n", info.fragments);
+	  fprintf(stderr, "fragstotal = %d\n", info.fragstotal);
+	  fprintf(stderr, "fragsize = %d\n", info.fragsize);
+	  fprintf(stderr, "bytes = %d\n", info.bytes);
+	}
+#endif
+
+	/* Allocate mixing buffer */
+	mixlen = spec->size;
+	mixbuf = (Uint8 *)SDL_AllocAudioMem(mixlen);
+	if ( mixbuf == NULL ) {
+		DSP_CloseAudio(this);
+		return(-1);
+	}
+	SDL_memset(mixbuf, spec->silence, spec->size);
+
+	/* Get the parent process id (we're the parent of the audio thread) */
+	parent = getpid();
+
+	/* We're ready to rock and roll. :-) */
+	return(0);
+}

src/dep/src/SDL/audio/dsp/SDL_dspaudio.h

@@ -0,0 +1,53 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2006 Sam Lantinga
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+    Sam Lantinga
+    slouken@libsdl.org
+*/
+#include "SDL_config.h"
+
+#ifndef _SDL_dspaudio_h
+#define _SDL_dspaudio_h
+
+#include "../SDL_sysaudio.h"
+
+/* Hidden "this" pointer for the video functions */
+#define _THIS	SDL_AudioDevice *this
+
+struct SDL_PrivateAudioData {
+	/* The file descriptor for the audio device */
+	int audio_fd;
+
+	/* The parent process id, to detect when application quits */
+	pid_t parent;
+
+	/* Raw mixing buffer */
+	Uint8 *mixbuf;
+	int    mixlen;
+};
+#define FUDGE_TICKS	10	/* The scheduler overhead ticks per frame */
+
+/* Old variable names */
+#define audio_fd		(this->hidden->audio_fd)
+#define parent			(this->hidden->parent)
+#define mixbuf			(this->hidden->mixbuf)
+#define mixlen			(this->hidden->mixlen)
+#define frame_ticks		(this->hidden->frame_ticks)
+#define next_frame		(this->hidden->next_frame)
+
+#endif /* _SDL_dspaudio_h */

src/dep/src/SDL/audio/dummy/SDL_dummyaudio.c

@@ -0,0 +1,156 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2006 Sam Lantinga
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+    Sam Lantinga
+    slouken@libsdl.org
+
+    This file written by Ryan C. Gordon (icculus@icculus.org)
+*/
+#include "SDL_config.h"
+
+/* Output audio to nowhere... */
+
+#include "SDL_rwops.h"
+#include "SDL_timer.h"
+#include "SDL_audio.h"
+#include "../SDL_audiomem.h"
+#include "../SDL_audio_c.h"
+#include "../SDL_audiodev_c.h"
+#include "SDL_dummyaudio.h"
+
+/* The tag name used by DUMMY audio */
+#define DUMMYAUD_DRIVER_NAME         "dummy"
+
+/* Audio driver functions */
+static int DUMMYAUD_OpenAudio(_THIS, SDL_AudioSpec *spec);
+static void DUMMYAUD_WaitAudio(_THIS);
+static void DUMMYAUD_PlayAudio(_THIS);
+static Uint8 *DUMMYAUD_GetAudioBuf(_THIS);
+static void DUMMYAUD_CloseAudio(_THIS);
+
+/* Audio driver bootstrap functions */
+static int DUMMYAUD_Available(void)
+{
+	const char *envr = SDL_getenv("SDL_AUDIODRIVER");
+	if (envr && (SDL_strcmp(envr, DUMMYAUD_DRIVER_NAME) == 0)) {
+		return(1);
+	}
+	return(0);
+}
+
+static void DUMMYAUD_DeleteDevice(SDL_AudioDevice *device)
+{
+	SDL_free(device->hidden);
+	SDL_free(device);
+}
+
+static SDL_AudioDevice *DUMMYAUD_CreateDevice(int devindex)
+{
+	SDL_AudioDevice *this;
+
+	/* Initialize all variables that we clean on shutdown */
+	this = (SDL_AudioDevice *)SDL_malloc(sizeof(SDL_AudioDevice));
+	if ( this ) {
+		SDL_memset(this, 0, (sizeof *this));
+		this->hidden = (struct SDL_PrivateAudioData *)
+				SDL_malloc((sizeof *this->hidden));
+	}
+	if ( (this == NULL) || (this->hidden == NULL) ) {
+		SDL_OutOfMemory();
+		if ( this ) {
+			SDL_free(this);
+		}
+		return(0);
+	}
+	SDL_memset(this->hidden, 0, (sizeof *this->hidden));
+
+	/* Set the function pointers */
+	this->OpenAudio = DUMMYAUD_OpenAudio;
+	this->WaitAudio = DUMMYAUD_WaitAudio;
+	this->PlayAudio = DUMMYAUD_PlayAudio;
+	this->GetAudioBuf = DUMMYAUD_GetAudioBuf;
+	this->CloseAudio = DUMMYAUD_CloseAudio;
+
+	this->free = DUMMYAUD_DeleteDevice;
+
+	return this;
+}
+
+AudioBootStrap DUMMYAUD_bootstrap = {
+	DUMMYAUD_DRIVER_NAME, "SDL dummy audio driver",
+	DUMMYAUD_Available, DUMMYAUD_CreateDevice
+};
+
+/* This function waits until it is possible to write a full sound buffer */
+static void DUMMYAUD_WaitAudio(_THIS)
+{
+	/* Don't block on first calls to simulate initial fragment filling. */
+	if (this->hidden->initial_calls)
+		this->hidden->initial_calls--;
+	else
+		SDL_Delay(this->hidden->write_delay);
+}
+
+static void DUMMYAUD_PlayAudio(_THIS)
+{
+	/* no-op...this is a null driver. */
+}
+
+static Uint8 *DUMMYAUD_GetAudioBuf(_THIS)
+{
+	return(this->hidden->mixbuf);
+}
+
+static void DUMMYAUD_CloseAudio(_THIS)
+{
+	if ( this->hidden->mixbuf != NULL ) {
+		SDL_FreeAudioMem(this->hidden->mixbuf);
+		this->hidden->mixbuf = NULL;
+	}
+}
+
+static int DUMMYAUD_OpenAudio(_THIS, SDL_AudioSpec *spec)
+{
+	float bytes_per_sec = 0.0f;
+
+	/* Allocate mixing buffer */
+	this->hidden->mixlen = spec->size;
+	this->hidden->mixbuf = (Uint8 *) SDL_AllocAudioMem(this->hidden->mixlen);
+	if ( this->hidden->mixbuf == NULL ) {
+		return(-1);
+	}
+	SDL_memset(this->hidden->mixbuf, spec->silence, spec->size);
+
+	bytes_per_sec = (float) (((spec->format & 0xFF) / 8) *
+	                   spec->channels * spec->freq);
+
+	/*
+	 * We try to make this request more audio at the correct rate for
+	 *  a given audio spec, so timing stays fairly faithful.
+	 * Also, we have it not block at all for the first two calls, so
+	 *  it seems like we're filling two audio fragments right out of the
+	 *  gate, like other SDL drivers tend to do.
+	 */
+	this->hidden->initial_calls = 2;
+	this->hidden->write_delay =
+	               (Uint32) ((((float) spec->size) / bytes_per_sec) * 1000.0f);
+
+	/* We're ready to rock and roll. :-) */
+	return(0);
+}
+