gosu 0.10.9.pre1 → 0.11.0

data/src/{Audio/Audio.cpp → Audio.cpp}

@@ -1,12 +1,10 @@
 #include "ALChannelManagement.hpp"
 #include "OggFile.hpp"
-
 #include <Gosu/Audio.hpp>
 #include <Gosu/Math.hpp>
 #include <Gosu/IO.hpp>
-#include <Gosu/Utility.hpp>
 #include <Gosu/Platform.hpp>
-
+#include <Gosu/Utility.hpp>
 #include <cassert>
 #include <cstdlib>
 #include <algorithm>
@@ -35,39 +33,35 @@ using namespace std;
 
 namespace
 {
-    using namespace Gosu;
-    
-    bool isOggFile(Gosu::Reader reader)
+    bool is_ogg_file(Gosu::Reader reader)
     {
-        char magicBytes[4];
-        reader.read(magicBytes, 4);
-        return magicBytes[0] == 'O' && magicBytes[1] == 'g' &&
-               magicBytes[2] == 'g' && magicBytes[3] == 'S';
+        char magic_bytes[4];
+        reader.read(magic_bytes, 4);
+        return magic_bytes[0] == 'O' && magic_bytes[1] == 'g' &&
+               magic_bytes[2] == 'g' && magic_bytes[3] == 'S';
     }
 
-    bool isOggFile(const wstring& filename)
+    bool is_ogg_file(const string& filename)
     {
         Gosu::File file(filename);
-        return isOggFile(file.frontReader());
+        return is_ogg_file(file.front_reader());
     }
     
-    Song* curSong = 0;
-    bool curSongLooping;
+    Gosu::Song* cur_song = nullptr;
+    bool cur_song_looping;
 }
 
-// TODO: What is this NSAutoreleasePool good for?
 #ifdef GOSU_IS_MAC
-#include "../AppleUtility.hpp"
     #define CONSTRUCTOR_BEGIN \
         @autoreleasepool { \
-        if (!alChannelManagement.get()) \
-            alChannelManagement.reset(new ALChannelManagement)
+        if (!al_channel_management.get()) \
+            al_channel_management.reset(new ALChannelManagement)
     #define CONSTRUCTOR_END \
         }
 #else
     #define CONSTRUCTOR_BEGIN \
-        if (!alChannelManagement.get()) \
-            alChannelManagement.reset(new ALChannelManagement)
+        if (!al_channel_management.get()) \
+            al_channel_management.reset(new ALChannelManagement)
     #define CONSTRUCTOR_END
 #endif
 
@@ -78,9 +72,9 @@ Gosu::SampleInstance::SampleInstance(int handle, int extra)
 
 bool Gosu::SampleInstance::playing() const
 {
-    ALuint source = alChannelManagement->sourceIfStillPlaying(handle, extra);
-    if (source == ALChannelManagement::NO_SOURCE)
-        return false;
+    ALuint source = al_channel_management->source_if_still_playing(handle, extra);
+    if (source == ALChannelManagement::NO_SOURCE) return false;
+    
     ALint state;
     alGetSourcei(source, AL_SOURCE_STATE, &state);
     return state == AL_PLAYING;
@@ -88,9 +82,9 @@ bool Gosu::SampleInstance::playing() const
 
 bool Gosu::SampleInstance::paused() const
 {
-    ALuint source = alChannelManagement->sourceIfStillPlaying(handle, extra);
-    if (source == ALChannelManagement::NO_SOURCE)
-        return false;
+    ALuint source = al_channel_management->source_if_still_playing(handle, extra);
+    if (source == ALChannelManagement::NO_SOURCE) return false;
+    
     ALint state;
     alGetSourcei(source, AL_SOURCE_STATE, &state);
     return state == AL_PAUSED;
@@ -98,52 +92,53 @@ bool Gosu::SampleInstance::paused() const
 
 void Gosu::SampleInstance::pause()
 {
-    ALuint source = alChannelManagement->sourceIfStillPlaying(handle, extra);
-    if (source == ALChannelManagement::NO_SOURCE)
-        return;
+    ALuint source = al_channel_management->source_if_still_playing(handle, extra);
+    if (source == ALChannelManagement::NO_SOURCE) return;
+    
     alSourcePause(source);
 }
 
 void Gosu::SampleInstance::resume()
 {
-    ALuint source = alChannelManagement->sourceIfStillPlaying(handle, extra);
-    if (source == ALChannelManagement::NO_SOURCE)
-        return;
+    ALuint source = al_channel_management->source_if_still_playing(handle, extra);
+    if (source == ALChannelManagement::NO_SOURCE) return;
+    
     ALint state;
     alGetSourcei(source, AL_SOURCE_STATE, &state);
-    if (state == AL_PAUSED)
+    if (state == AL_PAUSED) {
         alSourcePlay(source);
+    }
 }
 
 void Gosu::SampleInstance::stop()
 {
-    ALuint source = alChannelManagement->sourceIfStillPlaying(handle, extra);
-    if (source == ALChannelManagement::NO_SOURCE)
-        return;
+    ALuint source = al_channel_management->source_if_still_playing(handle, extra);
+    if (source == ALChannelManagement::NO_SOURCE) return;
+    
     alSourceStop(source);
 }
 
-void Gosu::SampleInstance::changeVolume(double volume)
+void Gosu::SampleInstance::change_volume(double volume)
 {
-    ALuint source = alChannelManagement->sourceIfStillPlaying(handle, extra);
-    if (source == ALChannelManagement::NO_SOURCE)
-        return;
+    ALuint source = al_channel_management->source_if_still_playing(handle, extra);
+    if (source == ALChannelManagement::NO_SOURCE) return;
+    
     alSourcef(source, AL_GAIN, volume);
 }
 
-void Gosu::SampleInstance::changePan(double pan)
+void Gosu::SampleInstance::change_pan(double pan)
 {
-    ALuint source = alChannelManagement->sourceIfStillPlaying(handle, extra);
-    if (source == ALChannelManagement::NO_SOURCE)
-        return;
+    ALuint source = al_channel_management->source_if_still_playing(handle, extra);
+    if (source == ALChannelManagement::NO_SOURCE) return;
+    
     alSource3f(source, AL_POSITION, pan * 10, 0, 0);
 }
 
-void Gosu::SampleInstance::changeSpeed(double speed)
+void Gosu::SampleInstance::change_speed(double speed)
 {
-    ALuint source = alChannelManagement->sourceIfStillPlaying(handle, extra);
-    if (source == ALChannelManagement::NO_SOURCE)
-        return;
+    ALuint source = al_channel_management->source_if_still_playing(handle, extra);
+    if (source == ALChannelManagement::NO_SOURCE) return;
+    
     alSourcef(source, AL_PITCH, speed);
 }
 
@@ -151,23 +146,22 @@ struct Gosu::Sample::SampleData
 {
     ALuint buffer, source;
 
-    SampleData(AudioFile& audioFile)
+    SampleData(AudioFile& audio_file)
     {
         alGenBuffers(1, &buffer);
-        alBufferData(buffer,
-                     audioFile.format(),
-                     &audioFile.decodedData().front(),
-                     (ALsizei)audioFile.decodedData().size(),
-                     audioFile.sampleRate());
+        alBufferData(buffer, audio_file.format(), &audio_file.decoded_data().front(),
+                     static_cast<ALsizei>(audio_file.decoded_data().size()),
+                     audio_file.sample_rate());
     }
     
     ~SampleData()
     {
         // It's hard to free things in the right order in Ruby/Gosu.
         // Make sure buffer isn't deleted after the context/device are shut down.
-        if (!alChannelManagement.get())
+        if (!al_channel_management.get()) {
             return;
-            
+        }
+
         alDeleteBuffers(1, &buffer);
     }
 
@@ -176,60 +170,56 @@ private:
     SampleData& operator=(const SampleData&);
 };
 
-Gosu::Sample::Sample(const std::wstring& filename)
+Gosu::Sample::Sample(const std::string& filename)
 {
     CONSTRUCTOR_BEGIN;
 
-    if (isOggFile(filename))
-    {
+    if (is_ogg_file(filename)) {
         Gosu::Buffer buffer;
-        Gosu::loadFile(buffer, filename);
-        OggFile oggFile(buffer.frontReader());
-        data.reset(new SampleData(oggFile));
+        Gosu::load_file(buffer, filename);
+        OggFile ogg_file(buffer.front_reader());
+        data.reset(new SampleData(ogg_file));
     }
-    else
-    {
-        WAVE_FILE audioFile(filename);
-        data.reset(new SampleData(audioFile));
+    else {
+        WAVE_FILE audio_file(filename);
+        data.reset(new SampleData(audio_file));
     }
     
-    CONSTRUCTOR_END
+    CONSTRUCTOR_END;
 }
 
 Gosu::Sample::Sample(Reader reader)
 {
     CONSTRUCTOR_BEGIN;
 
-    if (isOggFile(reader))
-    {
-        OggFile oggFile(reader);
-        data.reset(new SampleData(oggFile));
+    if (is_ogg_file(reader)) {
+        OggFile ogg_file(reader);
+        data.reset(new SampleData(ogg_file));
     }
-    else
-    {
-        WAVE_FILE audioFile(reader);
-        data.reset(new SampleData(audioFile));
+    else {
+        WAVE_FILE audio_file(reader);
+        data.reset(new SampleData(audio_file));
     }
     
-    CONSTRUCTOR_END
+    CONSTRUCTOR_END;
 }
 
-Gosu::SampleInstance Gosu::Sample::play(double volume, double speed,
-    bool looping) const
+Gosu::SampleInstance Gosu::Sample::play(double volume, double speed, bool looping) const
 {
-    return playPan(0, volume, speed, looping);
+    return play_pan(0, volume, speed, looping);
 }
 
-Gosu::SampleInstance Gosu::Sample::playPan(double pan, double volume,
-    double speed, bool looping) const
+Gosu::SampleInstance Gosu::Sample::play_pan(double pan, double volume, double speed,
+    bool looping) const
 {
-    std::pair<int, int> channelAndToken = alChannelManagement->reserveChannel();
-    if (channelAndToken.first == ALChannelManagement::NO_FREE_CHANNEL)
-        return Gosu::SampleInstance(channelAndToken.first, channelAndToken.second);
+    std::pair<int, int> channel_and_token = al_channel_management->reserve_channel();
+    if (channel_and_token.first == ALChannelManagement::NO_FREE_CHANNEL) {
+        return Gosu::SampleInstance(channel_and_token.first, channel_and_token.second);
+    }
     
-    ALuint source = alChannelManagement->sourceIfStillPlaying(channelAndToken.first,
-                                                                  channelAndToken.second);
-    assert(source != ALChannelManagement::NO_SOURCE);
+    ALuint source = al_channel_management->source_if_still_playing(channel_and_token.first,
+                                                                   channel_and_token.second);
+    assert (source != ALChannelManagement::NO_SOURCE);
     alSourcei(source, AL_BUFFER, data->buffer);
     // TODO: This is not the old panning behavior!
     alSource3f(source, AL_POSITION, pan * 10, 0, 0);
@@ -238,7 +228,7 @@ Gosu::SampleInstance Gosu::Sample::playPan(double pan, double volume,
     alSourcei(source, AL_LOOPING, looping ? AL_TRUE : AL_FALSE);
     alSourcePlay(source);
 
-    return Gosu::SampleInstance(channelAndToken.first, channelAndToken.second);
+    return Gosu::SampleInstance(channel_and_token.first, channel_and_token.second);
 }
 
 class Gosu::Song::BaseData
@@ -250,17 +240,15 @@ class Gosu::Song::BaseData
 
 protected:
     BaseData() : volume_(1) {}
-    virtual void applyVolume() = 0;
+    virtual void apply_volume() = 0;
 
 public:
     virtual ~BaseData() {}
-    
     virtual void play(bool looping) = 0;
     virtual void pause() = 0;
     virtual void resume() = 0;
     virtual bool paused() const = 0;
     virtual void stop() = 0;
-    
     virtual void update() = 0;
     
     double volume() const
@@ -268,10 +256,10 @@ public:
         return volume_;
     }
     
-    void changeVolume(double volume)
+    void change_volume(double volume)
     {
         volume_ = clamp(volume, 0.0, 1.0);
-        applyVolume();
+        apply_volume();
     }
 };
 
@@ -279,19 +267,18 @@ public:
 // AVAudioPlayer impl
 class Gosu::Song::ModuleData : public BaseData
 {
-    AVAudioPlayer *player;
+    AVAudioPlayer* player;
     
-    void applyVolume()
+    void apply_volume()
     {
         player.volume = volume();
     }
     
 public:
-    ModuleData(const std::wstring& filename)
+    ModuleData(const std::string& filename)
     {
-        std::string utf8Filename = Gosu::wstringToUTF8(filename);
-        NSURL *URL = [NSURL fileURLWithPath:[NSString stringWithUTF8String:utf8Filename.c_str()]];
-        player = [[AVAudioPlayer alloc] initWithContentsOfURL:URL error:NULL];
+        NSURL* URL = [NSURL fileURLWithPath:[NSString stringWithUTF8String:filename.c_str()]];
+        player = [[AVAudioPlayer alloc] initWithContentsOfURL:URL error:nil];
     }
     
     void play(bool looping)
@@ -333,77 +320,80 @@ public:
 // AudioFile impl
 class Gosu::Song::StreamData : public BaseData
 {
-    GOSU_UNIQUE_PTR<AudioFile> file;
+    std::unique_ptr<AudioFile> file;
     ALuint buffers[2];
     
-    void applyVolume()
+    void apply_volume()
     {
-        int source = lookupSource();
-        if (source != ALChannelManagement::NO_SOURCE)
+        int source = lookup_source();
+        if (source != ALChannelManagement::NO_SOURCE) {
             alSourcef(source, AL_GAIN, volume());
+        }
     }
     
-    int lookupSource() const
+    int lookup_source() const
     {
-        return alChannelManagement->sourceForSongs();
+        return al_channel_management->source_for_songs();
     }
     
-    bool streamToBuffer(ALuint buffer)
+    bool stream_to_buffer(ALuint buffer)
     {
         #ifdef GOSU_IS_IPHONE
         static const unsigned BUFFER_SIZE = 4096 * 4;
         #else
         static const unsigned BUFFER_SIZE = 4096 * 8;
         #endif
-        char audioData[BUFFER_SIZE];
-        std::size_t readBytes = file->readData(audioData, BUFFER_SIZE);
-        if (readBytes > 0)
-            alBufferData(buffer, file->format(), audioData, (ALsizei)readBytes, file->sampleRate());
-        return readBytes > 0;
+        char audio_data[BUFFER_SIZE];
+        std::size_t read_bytes = file->read_data(audio_data, BUFFER_SIZE);
+        if (read_bytes > 0) {
+            alBufferData(buffer, file->format(), audio_data,
+                         static_cast<ALsizei>(read_bytes), file->sample_rate());
+        }
+        return read_bytes > 0;
     }
     
 public:
-    StreamData(const std::wstring& filename)
+    StreamData(const std::string& filename)
     {
-        if (isOggFile(filename))
-        {
-            Gosu::File sourceFile(filename);
-            file.reset(new OggFile(sourceFile.frontReader()));
+        if (is_ogg_file(filename)) {
+            Gosu::File source_file(filename);
+            file.reset(new OggFile(source_file.front_reader()));
         }
-        else
+        else {
             file.reset(new WAVE_FILE(filename));
+        }
         alGenBuffers(2, buffers);
     }
 
     StreamData(Reader reader)
     {
-        if (isOggFile(reader))
+        if (is_ogg_file(reader)) {
             file.reset(new OggFile(reader));
-        else
+        }
+        else {
             file.reset(new WAVE_FILE(reader));
+        }
         alGenBuffers(2, buffers);
     }
     
     ~StreamData()
     {
-        if (alChannelManagement.get())
-        {
+        if (al_channel_management.get()) {
             alDeleteBuffers(2, buffers);
         }
     }
     
     void play(bool looping)
     {
-        int source = lookupSource();
-        if (source != ALChannelManagement::NO_SOURCE)
-        {
+        int source = lookup_source();
+        if (source != ALChannelManagement::NO_SOURCE) {
             alSource3f(source, AL_POSITION, 0, 0, 0);
             alSourcef(source, AL_GAIN, volume());
             alSourcef(source, AL_PITCH, 1);
             alSourcei(source, AL_LOOPING, AL_FALSE); // need to implement this manually...
 
-            streamToBuffer(buffers[0]);
-            streamToBuffer(buffers[1]);
+            stream_to_buffer(buffers[0]);
+            stream_to_buffer(buffers[1]);
             
             // TODO: Not good for songs with less than two buffers full of data.
             
@@ -414,9 +404,8 @@ public:
 
     void stop()
     {
-        int source = lookupSource();
-        if (source != ALChannelManagement::NO_SOURCE)
-        {
+        int source = lookup_source();
+        if (source != ALChannelManagement::NO_SOURCE) {
             alSourceStop(source);
 
             ALuint buffer;
@@ -426,36 +415,35 @@ public:
             
             int queued;
             alGetSourcei(source, AL_BUFFERS_QUEUED, &queued);
-            while (queued--)
+            while (queued--) {
                 alSourceUnqueueBuffers(source, 1, &buffer);
-
-            //int processed;
-            //alGetSourcei(source, AL_BUFFERS_PROCESSED, &processed);
-            //while (processed--)
-            //    alSourceUnqueueBuffers(source, 1, &buffer);
+            }
         }
         file->rewind();
     }
     
     void pause()
     {
-        int source = lookupSource();
-        if (source != ALChannelManagement::NO_SOURCE)
+        int source = lookup_source();
+        if (source != ALChannelManagement::NO_SOURCE) {
             alSourcePause(source);
+        }
     }
     
     void resume()
     {
-        int source = lookupSource();
-        if (source != ALChannelManagement::NO_SOURCE)
+        int source = lookup_source();
+        if (source != ALChannelManagement::NO_SOURCE) {
             alSourcePlay(source);
+        }
     }
     
     bool paused() const
     {
-        int source = lookupSource();
-        if (source == ALChannelManagement::NO_SOURCE)
+        int source = lookup_source();
+        if (source == ALChannelManagement::NO_SOURCE) {
             return false;
+        }
         ALint state;
         alGetSourcei(source, AL_SOURCE_STATE, &state);
         return state == AL_PAUSED;
@@ -463,68 +451,66 @@ public:
     
     void update()
     {
-        int source = lookupSource();
+        int source = lookup_source();
 
         ALuint buffer;
         int processed;
         bool active = true;
         
         alGetSourcei(source, AL_BUFFERS_PROCESSED, &processed);
-        for (int i = 0; i < processed; ++i)
-        {
+        for (int i = 0; i < processed; ++i) {
             alSourceUnqueueBuffers(source, 1, &buffer);
-            active = streamToBuffer(buffer);
-            if (active)
+            active = stream_to_buffer(buffer);
+            if (active) {
                 alSourceQueueBuffers(source, 1, &buffer);
+            }
         }
         
         ALint state;
         alGetSourcei(source, AL_SOURCE_STATE, &state);
-        if (active && state != AL_PLAYING && state != AL_PAUSED)
-        {
+        if (active && state != AL_PLAYING && state != AL_PAUSED) {
             // We seemingly got starved.
             alSourcePlay(source);
         }
-        else if (!active)
-        {
-            // We got starved and there is nothing to play left.
-            // In any case, shut down the playback logic for a moment.
+        else if (!active) {
+            // We got starved and there is nothing left to play.
             stop();
 
-            if (curSongLooping)
+            if (cur_song_looping) {
                 // Start anew.
                 play(true);
-            else
+            }
+            else {
                 // Let the world know we're finished.
-                curSong = 0;
+                cur_song = nullptr;
+            }
         }
     }
 };
 
-// TODO: Move into proper internal header
-namespace Gosu { bool isExtension(const wchar_t* str, const wchar_t* ext); }
-
-Gosu::Song::Song(const std::wstring& filename)
+Gosu::Song::Song(const std::string& filename)
 {
 #ifdef GOSU_IS_IPHONE
-    if (isExtension(filename.c_str(), L".mp3") ||
-        isExtension(filename.c_str(), L".aac") ||
-        isExtension(filename.c_str(), L".m4a"))
-        data.reset(new ModuleData(filename));
-    else
-#endif
-    {
+    if (has_extension(filename, ".mp3") ||
+            has_extension(filename, ".aac") ||
+            has_extension(filename, ".m4a")) {
         CONSTRUCTOR_BEGIN;
-        data.reset(new StreamData(filename));
-        CONSTRUCTOR_END
+        data.reset(new ModuleData(filename));
+        CONSTRUCTOR_END;
+        return;
     }
+#endif
+
+    CONSTRUCTOR_BEGIN;
+    data.reset(new StreamData(filename));
+    CONSTRUCTOR_END;
 }
 
 Gosu::Song::Song(Reader reader)
 {
     CONSTRUCTOR_BEGIN;
     data.reset(new StreamData(reader));
-    CONSTRUCTOR_END
+    CONSTRUCTOR_END;
 }
 
 Gosu::Song::~Song()
@@ -532,52 +518,53 @@ Gosu::Song::~Song()
     stop();
 }
 
-Gosu::Song* Gosu::Song::currentSong()
+Gosu::Song* Gosu::Song::current_song()
 {
-    return curSong;
+    return cur_song;
 }
 
 void Gosu::Song::play(bool looping)
 {
-    if (paused())
+    if (paused()) {
         data->resume();
+    }
     
-    if (curSong && curSong != this)
-    {
-        curSong->stop();
-        assert(curSong == 0);
+    if (cur_song && cur_song != this) {
+        cur_song->stop();
+        assert (cur_song == nullptr);
     }
     
-    if (curSong == 0)
+    if (cur_song == nullptr) {
         data->play(looping);
+    }
     
-    curSong = this;
-    curSongLooping = looping;
+    cur_song = this;
+    cur_song_looping = looping;
 }
 
 void Gosu::Song::pause()
 {
-    if (curSong == this)
+    if (cur_song == this) {
         data->pause(); // may be redundant
+    }
 }
 
 bool Gosu::Song::paused() const
 {
-    return curSong == this && data->paused();
+    return cur_song == this && data->paused();
 }
 
 void Gosu::Song::stop()
 {
-    if (curSong == this)
-    {
+    if (cur_song == this) {
         data->stop();
-        curSong = 0;
+        cur_song = nullptr;
     }
 }
 
 bool Gosu::Song::playing() const
 {
-    return curSong == this && !data->paused();
+    return cur_song == this && !data->paused();
 }
 
 double Gosu::Song::volume() const
@@ -585,35 +572,14 @@ double Gosu::Song::volume() const
     return data->volume();
 }
 
-void Gosu::Song::changeVolume(double volume)
+void Gosu::Song::change_volume(double volume)
 {
-    data->changeVolume(volume);
+    data->change_volume(volume);
 }
 
 void Gosu::Song::update()
 {
-    if (currentSong())
-        currentSong()->data->update();
-}
-
-// Deprecated constructors.
-
-Gosu::Sample::Sample(Audio& audio, const std::wstring& filename)
-{
-    Sample(filename).data.swap(data);
-}
-
-Gosu::Sample::Sample(Audio& audio, Reader reader)
-{
-    Sample(reader).data.swap(data);
-}
-
-Gosu::Song::Song(Audio& audio, const std::wstring& filename)
-{
-    data = Song(filename).data;
-}
-
-Gosu::Song::Song(Audio& audio, Type type, Reader reader)
-{
-    data = Song(reader).data;
+    if (current_song()) {
+        current_song()->data->update();
+    }
 }