Merge remote branch 'werdanith/soundmanagerrefactor'

apps/openmw/engine.cpp

@@ -118,8 +118,7 @@ bool OMW::Engine::frameRenderingQueued (const Ogre::FrameEvent& evt)
         // sound
         if (mUseSound)
         {
-            if (!mEnvironment.mSoundManager->isMusicPlaying())
+            mEnvironment.mSoundManager->playPlaylist();
-                mEnvironment.mSoundManager->startRandomTitle();
 
             mEnvironment.mSoundManager->update (evt.timeSinceLastFrame);
         }
@@ -341,7 +340,6 @@ void OMW::Engine::go()
     // Create sound system
     mEnvironment.mSoundManager = new MWSound::SoundManager(mOgre->getRoot(),
                                                            mOgre->getCamera(),
-                                                           mEnvironment.mWorld->getStore(),
                                                            mDataDirs,
                                                            mUseSound, mFSStrict, mEnvironment);
 
@@ -390,7 +388,7 @@ void OMW::Engine::go()
     mOgre->getRoot()->addFrameListener (this);
 
     // Play some good 'ol tunes
-    mEnvironment.mSoundManager->startRandomTitle();
+    mEnvironment.mSoundManager->playPlaylist(std::string("Explore"));
 
     // scripts
     if (mCompileAll)

apps/openmw/mwsound/soundmanager.cpp

@@ -10,10 +10,8 @@
 #include <mangle/sound/clients/ogre_listener_mover.hpp>
 #include <mangle/sound/clients/ogre_output_updater.hpp>
 
-#include <components/file_finder/file_finder.hpp>
 #include <components/esm_store/store.hpp>
 
-
 #include "../mwworld/environment.hpp"
 #include "../mwworld/world.hpp"
 #include "../mwworld/player.hpp"
@@ -45,7 +43,6 @@
 
 using namespace Mangle::Sound;
 typedef OEngine::Sound::SoundManager OEManager;
-typedef OEngine::Sound::SoundManagerPtr OEManagerPtr;
 
 // Set the position on a sound based on a Ptr.
 static void setPos(SoundPtr &snd, const MWWorld::Ptr ref)
@@ -60,175 +57,65 @@ static void setPos(SoundPtr &snd, const MWWorld::Ptr ref)
 
 namespace MWSound
 {
-  struct SoundManager::SoundImpl
-  {
-    /* This is the sound manager. It loades, stores and deletes
-       sounds based on the sound factory it is given.
-    */
-    OEManagerPtr mgr;
-    SoundPtr music;
 
-    /* This class calls update() on the sound manager each frame
+    SoundManager::SoundManager(Ogre::Root *root, Ogre::Camera *camera,
-       using and Ogre::FrameListener
+        const Files::PathContainer& dataDirs,
-    */
+        bool useSound, bool fsstrict, MWWorld::Environment& environment)
-    Mangle::Sound::OgreOutputUpdater updater;
+        : mFSStrict(fsstrict)
-
+        , mEnvironment(environment)
-    /* This class tracks the movement of an Ogre::Camera and moves
+        , mgr(new OEManager(SoundFactoryPtr(new SOUND_FACTORY)))
-       a sound listener automatically to follow it.
+        , updater(mgr)
-    */
+        , cameraTracker(mgr)
-    Mangle::Sound::OgreListenerMover cameraTracker;
+        , mCurrentPlaylist(NULL)
-
-    const ESMS::ESMStore &store;
-
-    typedef std::map<std::string,Mangle::Sound::WSoundPtr> IDMap;
-    typedef std::map<MWWorld::Ptr,IDMap> PtrMap;
-    PtrMap sounds;
-
-    // This is used for case insensitive and slash-type agnostic file
-    // finding. It takes DOS paths (any case, \\ slashes or / slashes)
-    // relative to the sound dir, and translates them into full paths
-    // of existing files in the filesystem, if they exist.
-    bool FSstrict;
-    FileFinder::LessTreeFileFinder files;
-    FileFinder::StrictTreeFileFinder strict;
-    FileFinder::LessTreeFileFinder musicpath;
-    FileFinder::StrictTreeFileFinder musicpathStrict;
-
-    SoundImpl(Ogre::Root *root, Ogre::Camera *camera, const ESMS::ESMStore &str,
-        const Files::PathContainer& soundDir,
-        const Files::PathContainer& musicDir,
-        bool fsstrict)
-      : mgr(new OEManager(SoundFactoryPtr(new SOUND_FACTORY)))
-      , updater(mgr)
-      , cameraTracker(mgr)
-      , store(str)
-      , FSstrict(fsstrict)
-      , files(soundDir)
-      , strict(soundDir)
-      , musicpath(musicDir)
-      , musicpathStrict(musicDir)
     {
+        if(useSound)
+        {
+            // The music library will accept these filetypes
+            // If none is given then it will accept all filetypes
+            std::vector<std::string> acceptableExtensions;
+            acceptableExtensions.push_back(".mp3");
+            acceptableExtensions.push_back(".wav");
+            acceptableExtensions.push_back(".ogg");
+            acceptableExtensions.push_back(".flac");
 
-      std::cout << "Sound output:  " << SOUND_OUT << std::endl;
+            // Makes a list of all sound files, searches in reverse for priority reasons
-      std::cout << "Sound decoder: " << SOUND_IN << std::endl;
+            for (Files::PathContainer::const_reverse_iterator it = dataDirs.rbegin(); it != dataDirs.rend(); ++it)
-      // Attach the camera to the camera tracker
+            {
-      cameraTracker.followCamera(camera);
+                Files::FileLister(*it / std::string("Sound"), mSoundFiles, true);
+            }
 
-      // Tell Ogre to update the sound system each frame
+            // Makes a FileLibrary of all music files, searches in reverse for priority reasons
-      root->addFrameListener(&updater);
+            for (Files::PathContainer::const_reverse_iterator it = dataDirs.rbegin(); it != dataDirs.rend(); ++it)
-    }
+            {
+                mMusicLibrary.add(*it / std::string("Music"), true, mFSStrict, acceptableExtensions);
+            }
 
-    ~SoundImpl()
+            std::string anything = "anything";      // anything is better that a segfault
+            mCurrentPlaylist = mMusicLibrary.section(anything, mFSStrict); // now points to an empty path
+
+            std::cout << "Sound output:  " << SOUND_OUT << std::endl;
+            std::cout << "Sound decoder: " << SOUND_IN << std::endl;
+            // Attach the camera to the camera tracker
+            cameraTracker.followCamera(camera);
+
+            // Tell Ogre to update the sound system each frame
+            root->addFrameListener(&updater);
+        }
+      }
+
+    SoundManager::~SoundManager()
     {
         Ogre::Root::getSingleton().removeFrameListener(&updater);
         cameraTracker.unfollowCamera();
     }
 
-
-
-    static std::string toMp3(std::string str)
-    {
-      std::string::size_type i = str.rfind('.');
-      if(str.find('/', i) == std::string::npos &&
-         str.find('\\', i) == std::string::npos)
-        str = str.substr(0, i) + ".mp3";
-      else
-        str += ".mp3";
-      return str;
-    }
-
-    bool hasFile(const std::string &str, bool music = false)
-    {
-        bool found = false;
-        if(!FSstrict)
-        {
-            if(music)
-            {
-                found = musicpath.has(str);
-                // Not found? Try with .mp3
-                if (!found)
-                {
-                    found = musicpath.has(toMp3(str));
-                }
-            }
-            else
-            {
-                found = files.has(str);
-                if (!found)
-                {
-                    found = files.has(toMp3(str));
-                }
-            }
-        }
-        else
-        {
-            if(music)
-            {
-                found = musicpathStrict.has(str);
-                // Not found? Try with .mp3
-                if (!found)
-                {
-                    found = musicpathStrict.has(toMp3(str));
-                }
-            }
-            else
-            {
-                found = strict.has(str);
-                if (!found)
-                {
-                    found = strict.has(toMp3(str));
-                }
-            }
-        }
-
-        return found;
-    }
-
-    // Convert a Morrowind sound path (eg. Fx\funny.wav) to full path
-    // with proper slash conversion (eg. datadir/Sound/Fx/funny.wav)
-    std::string convertPath(const std::string &str, bool music = false)
-    {
-        if(FSstrict == false)
-        {
-            // Search and return
-            if(music && musicpath.has(str))
-                return musicpath.lookup(str);
-            else if(files.has(str))
-                return files.lookup(str);
-
-            // Try mp3 if the wav wasn't found
-            std::string mp3 = toMp3(str);
-            if(music && musicpath.has(mp3))
-                return musicpath.lookup(mp3);
-            else if(files.has(mp3))
-                return files.lookup(mp3);
-        }
-        else
-        {
-            if(music && musicpathStrict.has(str))
-                return musicpathStrict.lookup(str);
-            else if(strict.has(str))
-                return strict.lookup(str);
-
-            // Try mp3 if the wav wasn't found
-            std::string mp3 = toMp3(str);
-            if(music && musicpathStrict.has(mp3))
-                return musicpathStrict.lookup(mp3);
-            else if(strict.has(str))
-                return strict.lookup(mp3);
-        }
-
-        // Give up
-        return "";
-    }
-
     // Convert a soundId to file name, and modify the volume
     // according to the sounds local volume setting, minRange and
     // maxRange.
-    std::string lookup(const std::string &soundId,
+    std::string SoundManager::lookup(const std::string &soundId,
                        float &volume, float &min, float &max)
     {
-      const ESM::Sound *snd = store.sounds.search(soundId);
+      const ESM::Sound *snd = mEnvironment.mWorld->getStore().sounds.search(soundId);
       if(snd == NULL) return "";
 
       if(snd->data.volume == 0)
@@ -249,11 +136,11 @@ namespace MWSound
         max = std::max(min, max);
       }
 
-      return convertPath(snd->sound);
+      return Files::FileListLocator(mSoundFiles, snd->sound, mFSStrict);
     }
 
     // Add a sound to the list and play it
-    void add(const std::string &file,
+    void SoundManager::add(const std::string &file,
              MWWorld::Ptr ptr,
              const std::string &id,
              float volume, float pitch,
@@ -280,7 +167,7 @@ namespace MWSound
 
     // Clears all the sub-elements of a given iterator, and then
     // removes it from 'sounds'.
-    void clearAll(PtrMap::iterator& it)
+    void SoundManager::clearAll(PtrMap::iterator& it)
     {
       IDMap::iterator sit = it->second.begin();
 
@@ -301,7 +188,7 @@ namespace MWSound
 
     // Stop a sound and remove it from the list. If id="" then
     // remove the entire object and stop all its sounds.
-    void remove(MWWorld::Ptr ptr, const std::string &id = "")
+    void SoundManager::remove(MWWorld::Ptr ptr, const std::string &id)
     {
       PtrMap::iterator it = sounds.find(ptr);
       if(it != sounds.end())
@@ -324,7 +211,7 @@ namespace MWSound
         }
     }
 
-    bool isPlaying(MWWorld::Ptr ptr, const std::string &id) const
+    bool SoundManager::isPlaying(MWWorld::Ptr ptr, const std::string &id) const
     {
       PtrMap::const_iterator it = sounds.find(ptr);
       if(it != sounds.end())
@@ -348,7 +235,7 @@ namespace MWSound
     }
 
     // Remove all references to objects belonging to a given cell
-    void removeCell(const MWWorld::Ptr::CellStore *cell)
+    void SoundManager::removeCell(const MWWorld::Ptr::CellStore *cell)
     {
       PtrMap::iterator it2, it = sounds.begin();
       while(it != sounds.end())
@@ -360,7 +247,7 @@ namespace MWSound
         }
     }
 
-    void updatePositions(MWWorld::Ptr ptr)
+    void SoundManager::updatePositions(MWWorld::Ptr ptr)
     {
       // Find the reference (if any)
       PtrMap::iterator it = sounds.find(ptr);
@@ -378,85 +265,45 @@ namespace MWSound
             }
         }
     }
-  }; /* SoundImpl */
+
+    void SoundManager::stopMusic()
+    {
+        if (music)
+            music->stop();
+        setPlaylist();
+    }
+
 
   void SoundManager::streamMusicFull(const std::string& filename)
   {
-    if(!mData) return;
-
     // Play the sound and tell it to stream, if possible. TODO:
     // Store the reference, the jukebox will need to check status,
     // control volume etc.
-    if (mData->music)
+    if (music)
-        mData->music->stop();
+        music->stop();
-    mData->music = mData->mgr->load(filename);
+    music = mgr->load(filename);
-    mData->music->setStreaming(true);
+    music->setStreaming(true);
-    mData->music->setVolume(0.4);
+    music->setVolume(0.4);
-    mData->music->play();
+    music->play();
 
   }
 
-  SoundManager::SoundManager(Ogre::Root *root, Ogre::Camera *camera,
-    const ESMS::ESMStore &store, const Files::PathContainer& dataDirs,
-    bool useSound, bool fsstrict, MWWorld::Environment& environment)
-    : mData(NULL)
-    , fsStrict(fsstrict)
-    , mEnvironment(environment)
-  {
-    for (Files::PathContainer::const_iterator it = dataDirs.begin(); it != dataDirs.end(); ++it)
-    {
-        MP3Lookup((*it) / "Music/Explore/");
-    }
-
-    if(useSound)
-    {
-        Files::PathContainer soundDirs;;
-        for (Files::PathContainer::const_iterator it = dataDirs.begin(); it != dataDirs.end(); ++it)
-        {
-            soundDirs.push_back( *it / std::string("Sound"));
-        }
-        mData = new SoundImpl(root, camera, store, soundDirs /* Sound */, dataDirs /* Music */, fsstrict);
-    }
-
-    test.name = "";
-    total = 0;
-  }
-
-  SoundManager::~SoundManager()
-  {
-    if(mData)
-      delete mData;
-  }
-
     void SoundManager::streamMusic(const std::string& filename)
     {
-        if(mData->hasFile(filename, true))
+        std::string filePath = mMusicLibrary.locate(filename, mFSStrict).string();
+        if(!filePath.empty())
         {
-            streamMusicFull(mData->convertPath(filename, true));
+            streamMusicFull(filePath);
         }
     }
 
-  void SoundManager::MP3Lookup(const boost::filesystem::path& dir)
-  {
-    boost::filesystem::directory_iterator dir_iter(dir), dir_end;
-
-    std::string mp3extension = ".mp3";
-    for(;dir_iter != dir_end; dir_iter++)
-    {
-        if(boost::filesystem::extension(*dir_iter) == mp3extension)
-        {
-            files.push_back(*dir_iter);
-        }
-    }
-  }
-
   void SoundManager::startRandomTitle()
   {
-    if(!files.empty())
+    if(mCurrentPlaylist && !mCurrentPlaylist->empty())
     {
-        Files::PathContainer::iterator fileIter = files.begin();
+        Files::PathContainer::const_iterator fileIter = mCurrentPlaylist->begin();
         srand( time(NULL) );
-        int r = rand() % files.size() + 1;        //old random code
+        int r = rand() % mCurrentPlaylist->size() + 1;        //old random code
 
         std::advance(fileIter, r - 1);
         std::string music = fileIter->string();
@@ -476,105 +323,157 @@ namespace MWSound
     bool SoundManager::isMusicPlaying()
     {
         bool test = false;
-        if(mData && mData->music)
+        if(music)
         {
-            test = mData->music->isPlaying();
+            test = music->isPlaying();
         }
         return test;
     }
 
-  SoundManager::SoundImpl SoundManager::getMData()
+    bool SoundManager::setPlaylist(std::string playlist)
-  {
+    {
-     // bool test = mData->music->isPlaying();
+        const Files::PathContainer* previousPlaylist;
-      return *mData;
+        previousPlaylist = mCurrentPlaylist;
-  }
+        if (playlist == "")
+        {
+            mCurrentPlaylist = mMusicLibrary.section(playlist, mFSStrict);
+        }
+        else if(mMusicLibrary.containsSection(playlist, mFSStrict))
+        {
+            mCurrentPlaylist = mMusicLibrary.section(playlist, mFSStrict);
+        }
+        else
+        {
+            std::cout << "Warning: playlist named " << playlist << " does not exist.\n";
+        }
+        return previousPlaylist == mCurrentPlaylist;
+    }
+
+    void SoundManager::playPlaylist(std::string playlist)
+    {
+        if (playlist == "")
+        {
+            if(!isMusicPlaying())
+            {
+                startRandomTitle();
+            }
+            return;
+        }
+
+        if(!setPlaylist(playlist))
+        {
+            startRandomTitle();
+        }
+        else if (!isMusicPlaying())
+        {
+            startRandomTitle();
+        }
+    }
 
   void SoundManager::say (MWWorld::Ptr ptr, const std::string& filename)
   {
     // The range values are not tested
-    if(!mData) return;
+    std::string filePath = Files::FileListLocator(mSoundFiles, filename, mFSStrict);
-    if(mData->hasFile(filename))
+    if(!filePath.empty())
-      mData->add(mData->convertPath(filename), ptr, "_say_sound", 1, 1, 100, 20000, false);
+      add(filePath, ptr, "_say_sound", 1, 1, 100, 20000, false);
     else
       std::cout << "Sound file " << filename << " not found, skipping.\n";
   }
 
   bool SoundManager::sayDone (MWWorld::Ptr ptr) const
   {
-    if(!mData) return false;
+    return !isPlaying(ptr, "_say_sound");
-    return !mData->isPlaying(ptr, "_say_sound");
   }
 
 
-  void SoundManager::playSound(const std::string& soundId, float volume, float pitch)
+  void SoundManager::playSound(const std::string& soundId, float volume, float pitch, bool loop)
   {
-    if(!mData) return;
-    // Play and forget
     float min, max;
-    const std::string &file = mData->lookup(soundId, volume, min, max);
+    const std::string &file = lookup(soundId, volume, min, max);
     if (file != "")
     {
-        SoundPtr snd = mData->mgr->load(file);
+        SoundPtr snd = mgr->load(file);
+        snd->setRepeat(loop);
         snd->setVolume(volume);
         snd->setRange(min,max);
         snd->setPitch(pitch);
         snd->play();
+
+        if (loop)
+        {
+            // Only add the looping sound once
+            IDMap::iterator it = mLoopedSounds.find(soundId);
+            if(it == mLoopedSounds.end())
+            {
+                mLoopedSounds[soundId] = WSoundPtr(snd);
+            }
+        }
     }
   }
 
   void SoundManager::playSound3D (MWWorld::Ptr ptr, const std::string& soundId,
                                   float volume, float pitch, bool loop)
   {
-    if(!mData) return;
-
     // Look up the sound in the ESM data
     float min, max;
-    const std::string &file = mData->lookup(soundId, volume, min, max);
+    const std::string &file = lookup(soundId, volume, min, max);
     if (file != "")
-      mData->add(file, ptr, soundId, volume, pitch, min, max, loop);
+      add(file, ptr, soundId, volume, pitch, min, max, loop);
   }
 
   void SoundManager::stopSound3D (MWWorld::Ptr ptr, const std::string& soundId)
   {
-    if(!mData) return;
+    remove(ptr, soundId);
-    mData->remove(ptr, soundId);
   }
 
   void SoundManager::stopSound (MWWorld::Ptr::CellStore *cell)
   {
-    if(!mData) return;
+    removeCell(cell);
-    mData->removeCell(cell);
   }
 
+    void SoundManager::stopSound(const std::string& soundId)
+    {
+        IDMap::iterator it = mLoopedSounds.find(soundId);
+        if(it != mLoopedSounds.end())
+        {
+            SoundPtr snd = it->second.lock();
+            if(snd) snd->stop();
+            mLoopedSounds.erase(it);
+        }
+    }
+
   bool SoundManager::getSoundPlaying (MWWorld::Ptr ptr, const std::string& soundId) const
   {
     // Mark all sounds as playing, otherwise the scripts will just
     // keep trying to play them every frame.
-    if(!mData) return true;
 
-    return mData->isPlaying(ptr, soundId);
+    return isPlaying(ptr, soundId);
   }
 
   void SoundManager::updateObject(MWWorld::Ptr ptr)
   {
-    if (mData != NULL)
+    updatePositions(ptr);
-    {
-        mData->updatePositions(ptr);
-    }
   }
 
   void SoundManager::update (float duration)
   {
         MWWorld::Ptr::CellStore *current = mEnvironment.mWorld->getPlayer().getPlayer().getCell();
+        static int total = 0;
+        static std::string regionName = "";
+        static float timePassed = 0.0;
+        timePassed += duration;
 
         //If the region has changed
-        if(!(current->cell->data.flags & current->cell->Interior) && timer.elapsed() >= 10)
+        if(!(current->cell->data.flags & current->cell->Interior) && timePassed >= 10)
         {
-            timer.restart();
+
-            if (test.name != current->cell->region)
+            ESM::Region test = (ESM::Region) *(mEnvironment.mWorld->getStore().regions.find(current->cell->region));
+
+            timePassed = 0;
+            if (regionName != current->cell->region)
             {
+                regionName = current->cell->region;
                 total = 0;
-                test = (ESM::Region) *(mEnvironment.mWorld->getStore().regions.find(current->cell->region));
             }
 
             if(test.soundList.size() > 0)
@@ -598,15 +497,15 @@ namespace MWSound
                 soundIter = test.soundList.begin();
                 while (soundIter != test.soundList.end())
                 {
-                    const ESM::NAME32 go = soundIter->sound;
+                    const std::string go = soundIter->sound.toString();
                     int chance = (int) soundIter->chance;
                     //std::cout << "Sound: " << go.name <<" Chance:" <<  chance << "\n";
                     soundIter++;
                     if( r - pos < chance)
                     {
                         //play sound
-                        std::cout << "Sound: " << go.name <<" Chance:" <<  chance << "\n";
+                        std::cout << "Sound: " << go <<" Chance:" <<  chance << "\n";
-                        mEnvironment.mSoundManager->playSound(go.name, 20.0, 1.0);
+                        mEnvironment.mSoundManager->playSound(go, 20.0, 1.0);
 
                         break;
                     }
@@ -616,7 +515,7 @@ namespace MWSound
         }
         else if(current->cell->data.flags & current->cell->Interior)
         {
-            test.name = "";
+            regionName = "";
         }
 
   }

apps/openmw/mwsound/soundmanager.hpp

@@ -3,13 +3,14 @@
 
 #include <string>
 
-#include <boost/filesystem.hpp>
+#include <mangle/sound/clients/ogre_output_updater.hpp>
-#include <boost/timer.hpp>
+#include <mangle/sound/clients/ogre_listener_mover.hpp>
+
+#include <openengine/sound/sndmanager.hpp>
+
+#include <components/files/filelibrary.hpp>
 
 #include "../mwworld/ptr.hpp"
-#include <openengine/sound/sndmanager.hpp>
-#include <components/files/multidircollection.hpp>
-
 
 
 namespace Ogre
@@ -18,11 +19,16 @@ namespace Ogre
     class Camera;
 }
 
-namespace ESMS
+namespace Mangle
 {
-    struct ESMStore;
+    namespace Sound
+    {
+        typedef boost::shared_ptr<Sound> SoundPtr;
+    }
 }
 
+typedef OEngine::Sound::SoundManagerPtr OEManagerPtr;
+
 namespace MWWorld
 {
     struct Environment;
@@ -30,43 +36,94 @@ namespace MWWorld
 
 namespace MWSound
 {
-    //SoundPtr *music;
     class SoundManager
     {
-            // Hide implementation details - engine.cpp is compiling
-            // enough as it is.
-            struct SoundImpl;
 
-            SoundImpl *mData;
+            // This is used for case insensitive and slash-type agnostic file
-            Files::PathContainer files;
+            // finding. It takes DOS paths (any case, \\ slashes or / slashes)
-            bool fsStrict;
+            // relative to the sound dir, and translates them into full paths
+            // of existing files in the filesystem, if they exist.
+            bool mFSStrict;
+
             MWWorld::Environment& mEnvironment;
 
-            int total;
-            ESM::Region test;
-            boost::timer timer;
-
             void streamMusicFull (const std::string& filename);
             ///< Play a soundifle
             /// \param absolute filename
 
+            /* This is the sound manager. It loades, stores and deletes
+            sounds based on the sound factory it is given.
+            */
+            OEManagerPtr mgr;
+            Mangle::Sound::SoundPtr music;
+
+            /* This class calls update() on the sound manager each frame
+               using and Ogre::FrameListener
+            */
+            Mangle::Sound::OgreOutputUpdater updater;
+
+            /* This class tracks the movement of an Ogre::Camera and moves
+               a sound listener automatically to follow it.
+            */
+            Mangle::Sound::OgreListenerMover cameraTracker;
+
+            typedef std::map<std::string,Mangle::Sound::WSoundPtr> IDMap;
+            typedef std::map<MWWorld::Ptr,IDMap> PtrMap;
+            PtrMap sounds;
+
+            // A list of all sound files used to lookup paths
+            Files::PathContainer mSoundFiles;
+
+            // A library of all Music file paths stored by the folder they are contained in
+            Files::FileLibrary mMusicLibrary;
+
+            // Points to the current playlist of music files stored in the music library
+            const Files::PathContainer* mCurrentPlaylist;
+
+            IDMap mLoopedSounds;
+
+            std::string lookup(const std::string &soundId,
+                       float &volume, float &min, float &max);
+            void add(const std::string &file,
+                MWWorld::Ptr ptr, const std::string &id,
+                float volume, float pitch, float min, float max,
+                bool loop);
+            void clearAll(PtrMap::iterator& it);
+            void remove(MWWorld::Ptr ptr, const std::string &id = "");
+            bool isPlaying(MWWorld::Ptr ptr, const std::string &id) const;
+            void removeCell(const MWWorld::Ptr::CellStore *cell);
+            void updatePositions(MWWorld::Ptr ptr);
+
         public:
 
-            SoundManager(Ogre::Root*, Ogre::Camera*, const ESMS::ESMStore &store,
+            SoundManager(Ogre::Root*, Ogre::Camera*,
                    const Files::PathContainer& dataDir, bool useSound, bool fsstrict,
                    MWWorld::Environment& environment);
             ~SoundManager();
 
+            void stopMusic();
+            ///< Stops music if it's playing
+
             void streamMusic(const std::string& filename);
             ///< Play a soundifle
             /// \param filename name of a sound file in "Music/" in the data directory.
 
             void startRandomTitle();
-            void MP3Lookup(const boost::filesystem::path& dir);
+            ///< Starts a random track from the current playlist
 
             bool isMusicPlaying();
+            ///< Returns true if music is playing
 
-            SoundImpl getMData();
+            bool setPlaylist(std::string playlist="");
+            ///< Set the playlist to an existing folder
+            /// \param name of the folder that contains the playlist
+            /// if none is set then it is set to an empty playlist
+            /// \return Return true if the previous playlist was the same
+
+            void playPlaylist(std::string playlist="");
+            ///< Start playing music from the selected folder
+            /// \param name of the folder that contains the playlist
+            /// if none is set then it plays from the current playlist
 
             void say (MWWorld::Ptr reference, const std::string& filename);
             ///< Make an actor say some text.
@@ -75,7 +132,7 @@ namespace MWSound
             bool sayDone (MWWorld::Ptr reference) const;
             ///< Is actor not speaking?
 
-            void playSound (const std::string& soundId, float volume, float pitch);
+            void playSound (const std::string& soundId, float volume, float pitch, bool loop=false);
             ///< Play a sound, independently of 3D-position
 
             void playSound3D (MWWorld::Ptr reference, const std::string& soundId,
@@ -89,6 +146,9 @@ namespace MWSound
             void stopSound (MWWorld::Ptr::CellStore *cell);
             ///< Stop all sounds for the given cell.
 
+            void stopSound(const std::string& soundId);
+            ///< Stop a non-3d looping sound
+
             bool getSoundPlaying (MWWorld::Ptr reference, const std::string& soundId) const;
             ///< Is the given sound currently playing on the given object?
 

components/CMakeLists.txt

@@ -44,6 +44,7 @@ add_component_dir (misc
 
 add_component_dir (files
     linuxpath windowspath macospath fixedpath multidircollection collections fileops configurationmanager
+    filelibrary
     )
 
 add_component_dir (compiler

components/files/filelibrary.cpp

@@ -0,0 +1,120 @@
+#include "filelibrary.hpp"
+
+#include <iostream>
+
+#include <boost/filesystem.hpp>
+#include <boost/algorithm/string.hpp>
+
+namespace Files
+{
+    // Looks for a string in a vector of strings
+    bool containsVectorString(const StringVector& list, const std::string& str)
+    {
+        for (StringVector::const_iterator iter = list.begin();
+             iter != list.end(); iter++)
+        {
+            if (*iter == str)
+                return true;
+        }
+        return false;
+    }
+
+    // Searches a path and adds the results to the library
+    void FileLibrary::add(const boost::filesystem::path &root, bool recursive, bool strict,
+            const StringVector &acceptableExtensions)
+    {
+        if (!boost::filesystem::exists(root))
+        {
+            std::cout << "Warning " << root.string() << " does not exist.\n";
+            return;
+        }
+
+        std::string fileExtension;
+        std::string type;
+
+        // remember the last location of the priority list when listing new items
+        int length = mPriorityList.size();
+
+        // First makes a list of all candidate files
+        FileLister(root, mPriorityList, recursive);
+
+        // Then sort these files into sections according to the folder they belong to
+        for (PathContainer::iterator listIter = mPriorityList.begin() + length;
+            listIter != mPriorityList.end(); ++listIter)
+        {
+            if( !acceptableExtensions.empty() )
+            {
+                fileExtension = listIter->extension().string();
+                boost::algorithm::to_lower(fileExtension);
+                if(!containsVectorString(acceptableExtensions, fileExtension))
+                    continue;
+            }
+
+            type = listIter->parent_path().leaf().string();
+            if (!strict)
+                boost::algorithm::to_lower(type);
+
+            mMap[type].push_back(*listIter);
+            // std::cout << "Added path: " << listIter->string() << " in section "<< type <<std::endl;
+        }
+    }
+
+    // Returns true if the named section exists
+    bool FileLibrary::containsSection(std::string sectionName, bool strict)
+    {
+        if (!strict)
+            boost::algorithm::to_lower(sectionName);
+        StringPathContMap::const_iterator mapIter = mMap.find(sectionName);
+        if (mapIter == mMap.end())
+            return false;
+        else
+            return true;
+    }
+
+    // Returns a pointer to const for a section of the library
+    const PathContainer* FileLibrary::section(std::string sectionName, bool strict)
+    {
+        if (!strict)
+            boost::algorithm::to_lower(sectionName);
+        StringPathContMap::const_iterator mapIter = mMap.find(sectionName);
+        if (mapIter == mMap.end())
+        {
+            //std::cout << "Empty\n";
+            return &mEmptyPath;
+        }
+        else
+        {
+            return &(mapIter->second);
+        }
+    }
+
+    // Searches the library for an item and returns a boost path to it
+    boost::filesystem::path FileLibrary::locate(std::string item, bool strict, std::string sectionName)
+    {
+        boost::filesystem::path result("");
+        if (sectionName == "")
+        {
+            return FileListLocator(mPriorityList, boost::filesystem::path(item), strict);
+        }
+        else
+        {
+            if (!containsSection(sectionName, strict))
+            {
+                std::cout << "Warning: There is no section named " << sectionName << "\n";
+                return result;
+            }
+            result = FileListLocator(mMap[sectionName], boost::filesystem::path(item), strict);
+        }
+        return result;
+    }
+
+    // Prints all the available sections, used for debugging
+    void FileLibrary::printSections()
+    {
+        for(StringPathContMap::const_iterator mapIter = mMap.begin();
+             mapIter != mMap.end(); mapIter++)
+        {
+            std::cout << mapIter->first <<std::endl;
+        }
+    }
+}

components/files/filelibrary.hpp

@@ -0,0 +1,49 @@
+#ifndef COMPONENTS_FILES_FILELIBRARY_HPP
+#define COMPONENTS_FILES_FILELIBRARY_HPP
+
+#include <components/files/fileops.hpp>
+
+namespace Files
+{
+    typedef std::map<std::string, PathContainer> StringPathContMap;
+    typedef std::vector<std::string> StringVector;
+
+    /// Looks for a string in a vector of strings
+    bool containsVectorString(const StringVector& list, const std::string& str);
+
+    /// \brief Searches directories and makes lists of files according to folder name
+    class FileLibrary
+    {
+        private:
+            StringPathContMap mMap;
+            PathContainer mEmptyPath;
+            PathContainer mPriorityList;
+
+        public:
+            /// Searches a path and adds the results to the library
+            /// Recursive search and fs strict options are available
+            /// Takes a vector of acceptable files extensions, if none is given it lists everything.
+            void add(const boost::filesystem::path &root, bool recursive, bool strict,
+                     const StringVector &acceptableExtensions);
+
+            /// Returns true if the named section exists
+            /// You can run this check before running section()
+            bool containsSection(std::string sectionName, bool strict);
+
+            /// Returns a pointer to const for a section of the library
+            /// which is essentially a PathContainer.
+            /// If the section does not exists it returns a pointer to an empty path.
+            const PathContainer* section(std::string sectionName, bool strict);
+
+            /// Searches the library for an item and returns a boost path to it
+            /// Optionally you can provide a specific section
+            /// The result is the first that comes up according to alphabetical
+            /// section naming
+            boost::filesystem::path locate(std::string item, bool strict, std::string sectionName="");
+
+            /// Prints all the available sections, used for debugging
+            void printSections();
+    };
+}
+
+#endif

components/files/fileops.cpp

@@ -1,5 +1,6 @@
 #include "fileops.hpp"
 #include <boost/filesystem.hpp>
+#include <boost/algorithm/string.hpp>
 
 namespace Files
 {
@@ -9,4 +10,90 @@ bool isFile(const char *name)
     return boost::filesystem::exists(boost::filesystem::path(name));
 }
 
+    // Makes a list of files from a directory
+    void FileLister( boost::filesystem::path currentPath, Files::PathContainer& list, bool recursive)
+    {
+        if (!boost::filesystem::exists(currentPath))
+        {
+            std::cout << "WARNING: " << currentPath.string() << " does not exist.\n";
+            return ;
+        }
+        if (recursive)
+        {
+            for ( boost::filesystem::recursive_directory_iterator end, itr(currentPath.string());
+                itr != end; ++itr )
+            {
+                if ( boost::filesystem::is_regular_file(*itr))
+                    list.push_back(itr->path());
+            }
+        }
+        else
+        {
+            for ( boost::filesystem::directory_iterator end, itr(currentPath.string());
+                itr != end; ++itr )
+            {
+                if ( boost::filesystem::is_regular_file(*itr))
+                    list.push_back(itr->path());
+            }
+        }
+    }
+
+    // Locates path in path container
+    boost::filesystem::path FileListLocator (const Files::PathContainer& list, const boost::filesystem::path& toFind, bool strict)
+    {
+        boost::filesystem::path result("");
+        if (list.empty())
+            return result;
+
+        std::string toFindStr = toFind.string();
+
+        std::string fullPath;
+
+        // The filesystems slash sets the default slash
+        std::string slash;
+        std::string wrongslash;
+        if(list[0].string().find("\\") != std::string::npos)
+        {
+            slash = "\\";
+            wrongslash = "/";
+        }
+        else
+        {
+            slash = "/";
+            wrongslash = "\\";
+        }
+
+        // The file being looked for is converted to the new slash
+        if(toFindStr.find(wrongslash) != std::string::npos )
+        {
+            boost::replace_all(toFindStr, wrongslash, slash);
+        }
+
+        if (!strict)
+        {
+            boost::algorithm::to_lower(toFindStr);
+        }
+
+        for (Files::PathContainer::const_iterator it = list.begin(); it != list.end(); ++it)
+        {
+            fullPath = it->string();
+            if (!strict)
+            {
+                boost::algorithm::to_lower(fullPath);
+            }
+            if(fullPath.find(toFindStr) != std::string::npos)
+            {
+                result = *it;
+                break;
+            }
+        }
+        return result;
+    }
+
+    // Overloaded form of the locator that takes a string and returns a string
+    std::string FileListLocator (const Files::PathContainer& list,const std::string& toFind, bool strict)
+    {
+        return FileListLocator(list, boost::filesystem::path(toFind), strict).string();
+    }
+
 }

components/files/fileops.hpp

@@ -1,6 +1,12 @@
 #ifndef COMPONENTS_FILES_FILEOPS_HPP
 #define COMPONENTS_FILES_FILEOPS_HPP
 
+#include <map>
+#include <vector>
+#include <string>
+
+#include <boost/filesystem/path.hpp>
+
 namespace Files
 {
 
@@ -8,6 +14,24 @@ namespace Files
 ///\param [in] name - filename
 bool isFile(const char *name);
 
+    /// A vector of Boost Paths, very handy
+    typedef std::vector<boost::filesystem::path> PathContainer;
+
+    /// Makes a list of files from a directory by taking a boost
+    /// path and a Path Container and adds to the Path container
+    /// all files in the path. It has a recursive option.
+    void FileLister( boost::filesystem::path currentPath, Files::PathContainer& list, bool recursive);
+
+    /// Locates boost path in path container
+    /// returns the path from the container
+    /// that contains the searched path.
+    /// If it's not found it returns and empty path
+    /// Takes care of slashes, backslashes and it has a strict option.
+    boost::filesystem::path FileListLocator (const Files::PathContainer& list, const boost::filesystem::path& toFind, bool strict);
+
+    /// Overloaded form of the locator that takes a string and returns a string
+    std::string FileListLocator (const Files::PathContainer& list,const std::string& toFind, bool strict);
+
 }
 
 #endif /* COMPONENTS_FILES_FILEOPS_HPP */