gosu 0.12.1 → 0.13.0

data/src/AudioImpl.cpp

@@ -0,0 +1,94 @@
+#include "AudioImpl.hpp"
+#include <stdexcept>
+#include <string>
+using namespace std;
+
+// Per-platform limit for playing OpenAL sources: https://stackoverflow.com/a/3203888
+#ifdef GOSU_IS_IPHONE
+static const unsigned CHANNELS = 32;
+#else
+static const unsigned CHANNELS = 255;
+#endif
+
+static ALCdevice* _device;
+static ALCcontext* _context;
+static ALuint _sources[CHANNELS];
+static int _tokens[CHANNELS];
+
+void Gosu::al_initialize()
+{
+    if (_device) return;
+
+    _device = alcOpenDevice(nullptr);
+    _context = alcCreateContext(_device, nullptr);
+    alcMakeContextCurrent(_context);
+    alGenSources(CHANNELS, _sources);
+}
+
+bool Gosu::al_initialized()
+{
+    return _device != nullptr;
+}
+
+void Gosu::al_shutdown()
+{
+    if (_device == nullptr) return;
+    
+    alDeleteSources(CHANNELS, _sources);
+    alcMakeContextCurrent(nullptr);
+    alcDestroyContext(_context);
+    _context = nullptr;
+    alcCloseDevice(_device);
+    _device = nullptr;
+}
+
+ALCdevice* Gosu::al_device()
+{
+    al_initialize();
+    
+    return _device;
+}
+
+ALCcontext* Gosu::al_context()
+{
+    al_initialize();
+    
+    return _context;
+}
+
+Gosu::Channel Gosu::allocate_channel()
+{
+    al_initialize();
+
+    // Start looking at index 1 to keep one free channel for songs.
+    for (int i = 1; i < CHANNELS; ++i) {
+        // Do not interrupt any playing or paused samples.
+        ALint state;
+        alGetSourcei(_sources[i], AL_SOURCE_STATE, &state);
+        if (state == AL_PLAYING || state == AL_PAUSED) continue;
+        
+        // Increase the token to invalidate the last playing Channel with this index.
+        return Channel(i, ++_tokens[i]);
+    }
+
+    // No free channel, return an object that is immediately expired.
+    return Channel(NO_CHANNEL, 0);
+}
+
+bool Gosu::channel_expired(int channel, int token)
+{
+    return channel < 0 || channel >= CHANNELS || _tokens[channel] != token;
+}
+
+ALuint Gosu::al_source_for_channel(int channel)
+{
+    if (channel <= 0 || channel >= CHANNELS) {
+        throw invalid_argument("No such channel: " + to_string(channel));
+    }
+    return _sources[channel];
+}
+
+ALuint Gosu::al_source_for_songs()
+{
+    return _sources[0];
+}

data/src/AudioImpl.hpp

@@ -0,0 +1,33 @@
+#pragma once
+
+#include <Gosu/Audio.hpp>
+#include <Gosu/Platform.hpp>
+#ifdef GOSU_IS_MAC
+#include <OpenAL/al.h>
+#include <OpenAL/alc.h>
+#else
+#include <AL/al.h>
+#include <AL/alc.h>
+#endif
+
+namespace Gosu
+{
+    void al_initialize();
+    bool al_initialized();
+    void al_shutdown();
+    
+    // Will initialize OpenAL if necessary.
+    ALCdevice* al_device();
+    // Will initialize OpenAL if necessary.
+    ALCcontext* al_context();
+    
+    const int NO_CHANNEL = -1;
+    
+    // Returns an expired Channel if no channel is free.
+    // Will initialize OpenAL if necessary.
+    Channel allocate_channel();
+    
+    bool channel_expired(int channel, int token);
+    ALuint al_source_for_channel(int channel);
+    ALuint al_source_for_songs();
+}

data/src/AudioToolboxFile.hpp

@@ -33,7 +33,7 @@ namespace Gosu
 {
     class AudioToolboxFile : public AudioFile
     {
-        Gosu::Buffer buffer_;
+        Buffer buffer_;
         AudioFileID file_id_;
         ExtAudioFileRef file_;
         SInt64 position_;
@@ -45,10 +45,11 @@ namespace Gosu
         bool big_endian_;
         
         static OSStatus AudioFile_ReadProc(void* in_client_data, SInt64 in_position,
-            UInt32 request_count, void* buffer, UInt32* actual_count)
+                                           UInt32 request_count, void* buffer, UInt32* actual_count)
         {
             const Resource& res = *static_cast<Resource*>(in_client_data);
-            *actual_count = std::min<UInt32>(request_count, res.size() - in_position);
+            *actual_count = std::min<UInt32>(request_count,
+                                             static_cast<UInt32>(res.size() - in_position));
             res.read(in_position, *actual_count, buffer);
             return noErr;
         }
@@ -81,7 +82,9 @@ namespace Gosu
             AudioStreamBasicDescription client_data = { 0 };
             sample_rate_ = client_data.mSampleRate = 22050;
             client_data.mFormatID = kAudioFormatLinearPCM;
-            client_data.mFormatFlags = kAudioFormatFlagIsSignedInteger | kAudioFormatFlagsNativeEndian | kAudioFormatFlagIsPacked;
+            client_data.mFormatFlags = kAudioFormatFlagIsSignedInteger |
+                                       kAudioFormatFlagsNativeEndian |
+                                       kAudioFormatFlagIsPacked;
             client_data.mBitsPerChannel = 16;
             client_data.mChannelsPerFrame = base.mChannelsPerFrame;
             client_data.mFramesPerPacket = 1;
@@ -119,22 +122,15 @@ namespace Gosu
             
             // Easy formats
             format_ = 0;
-            if (desc.mChannelsPerFrame == 1) {
-                /*if (desc.mBitsPerChannel == 8)
-                    format_ = AL_FORMAT_MONO8;
-                else*/ if (desc.mBitsPerChannel == 16)
-                    format_ = AL_FORMAT_MONO16;
+            if (desc.mChannelsPerFrame == 1 && desc.mBitsPerChannel == 16) {
+                format_ = AL_FORMAT_MONO16;
             }
-            else if (desc.mChannelsPerFrame == 2) {
-                /*if (desc.mBitsPerChannel == 8)
-                    format_ = AL_FORMAT_STEREO8;
-                else */if (desc.mBitsPerChannel == 16)
-                    format_ = AL_FORMAT_STEREO16;
+            else if (desc.mChannelsPerFrame == 2 && desc.mBitsPerChannel == 16) {
+                format_ = AL_FORMAT_STEREO16;
             }
             
             if (format_ == 0 ||
-                    // If format not native for OpenAL, set client data format
-                    // to enable conversion
+                    // If format not native for OpenAL, set client data format to enable conversion
                     desc.mFormatFlags & kAudioFormatFlagIsBigEndian ||
                     desc.mFormatFlags & kAudioFormatFlagIsFloat ||
                     !(desc.mFormatFlags & kAudioFormatFlagIsSignedInteger)) {
@@ -159,7 +155,7 @@ namespace Gosu
             init();
         }
         
-        AudioToolboxFile(Gosu::Reader reader)
+        AudioToolboxFile(Reader reader)
         {
             buffer_.resize(reader.resource().size() - reader.position());
             reader.read(buffer_.data(), buffer_.size());
@@ -204,7 +200,7 @@ namespace Gosu
             AudioBufferList abl;
             abl.mNumberBuffers = 1;
             abl.mBuffers[0].mNumberChannels = 1;
-            abl.mBuffers[0].mDataByteSize = length;
+            abl.mBuffers[0].mDataByteSize = static_cast<UInt32>(length);
             abl.mBuffers[0].mData = dest;
             UInt32 numFrames = 0xffffffff; // give us as many frames as possible given our buffer
             CHECK_OS(ExtAudioFileRead(file_, &numFrames, &abl));

data/src/Bitmap.cpp

@@ -1,7 +1,8 @@
 #include <Gosu/Bitmap.hpp>
 #include <cassert>
 #include <algorithm>
-#include <vector>
+#include <vector>
+using namespace std;
 
 void Gosu::Bitmap::swap(Bitmap& other)
 {
@@ -26,15 +27,14 @@ void Gosu::Bitmap::insert(const Bitmap& source, int x, int y)
 }
 
 void Gosu::Bitmap::insert(const Bitmap& source, int x, int y, unsigned src_x, unsigned src_y,
-    unsigned src_width, unsigned src_height)
+                          unsigned src_width, unsigned src_height)
 {
     // TODO: This should use memcpy if possible (x == 0 && src_width == this->width())
 
     if (x < 0) {
         unsigned clip_left = -x;
 
-        if (clip_left >= src_width)
-            return;
+        if (clip_left >= src_width) return;
 
         src_x += clip_left;
         src_width -= clip_left;
@@ -44,8 +44,7 @@ void Gosu::Bitmap::insert(const Bitmap& source, int x, int y, unsigned src_x, un
     if (y < 0) {
         unsigned clip_top = -y;
 
-        if (clip_top >= src_height)
-            return;
+        if (clip_top >= src_height) return;
 
         src_y += clip_top;
         src_height -= clip_top;
@@ -53,27 +52,27 @@ void Gosu::Bitmap::insert(const Bitmap& source, int x, int y, unsigned src_x, un
     }
 
     if (x + src_width > w) {
-        if (static_cast<unsigned>(x) >= w)
-            return;
+        if (static_cast<unsigned>(x) >= w) return;
 
         src_width = w - x;
     }
 
     if (y + src_height > h) {
-        if (static_cast<unsigned>(y) >= h)
-            return;
+        if (static_cast<unsigned>(y) >= h) return;
 
         src_height = h - y;
     }
 
-    for (unsigned rel_y = 0; rel_y < src_height; ++rel_y)
-        for (unsigned rel_x = 0; rel_x < src_width; ++rel_x)
-            set_pixel(x + rel_x, y + rel_y, source.get_pixel(src_x + rel_x, src_y + rel_y));
+    for (unsigned rel_y = 0; rel_y < src_height; ++rel_y) {
+        for (unsigned rel_x = 0; rel_x < src_width; ++rel_x) {
+            set_pixel(x + rel_x, y + rel_y, source.get_pixel(src_x + rel_x, src_y + rel_y));
+        }
+    }
 }
 
 void Gosu::apply_color_key(Bitmap& bitmap, Color key)
 {
-    std::vector<Color> surrounding_colors;
+    vector<Color> surrounding_colors;
     surrounding_colors.reserve(4);
 
     for (unsigned y = 0; y < bitmap.height(); ++y)
@@ -96,31 +95,35 @@ void Gosu::apply_color_key(Bitmap& bitmap, Color key)
 
                 unsigned red = 0, green = 0, blue = 0;
                 for (auto& color : surrounding_colors) {
-                    red += color.red();
+                    red   += color.red();
                     green += color.green();
-                    blue += color.blue();
+                    blue  += color.blue();
                 }
-                bitmap.set_pixel(x, y, Color(0, red / surrounding_colors.size(),
-                    green / surrounding_colors.size(), blue / surrounding_colors.size()));
+                bitmap.set_pixel(x, y, Color(0,
+                                             red   / surrounding_colors.size(),
+                                             green / surrounding_colors.size(),
+                                             blue  / surrounding_colors.size()));
             }
 }
 
 void Gosu::unapply_color_key(Bitmap& bitmap, Color color)
 {
     Color* p = bitmap.data();
-    for (int i = bitmap.width() * bitmap.height(); i > 0; --i, ++p)
-        if (p->alpha() == 0)
-            *p = color;
-        else
-            p->set_alpha(255);
+    for (int i = bitmap.width() * bitmap.height(); i > 0; --i, ++p) {
+        if (p->alpha() == 0) {
+            *p = color;
+        }
+        else {
+            p->set_alpha(255);
+        }
+    }
 }
 
 void Gosu::apply_border_flags(Bitmap& dest, const Bitmap& source, unsigned src_x, unsigned src_y,
-    unsigned src_width, unsigned src_height, unsigned image_flags)
+                              unsigned src_width, unsigned src_height, unsigned image_flags)
 {
     // Backward compatibility: This used to be 'bool tileable'.
-    if (image_flags == 1)
-        image_flags = IF_TILEABLE;
+    if (image_flags == 1) image_flags = IF_TILEABLE;
 
     dest.resize(src_width + 2, src_height + 2);
 
@@ -142,17 +145,20 @@ void Gosu::apply_border_flags(Bitmap& dest, const Bitmap& source, unsigned src_x
 
     // Top left.
     if ((image_flags & IF_TILEABLE_TOP) && (image_flags & IF_TILEABLE_LEFT))
-        dest.set_pixel(0, 0, source.get_pixel(src_x, src_y));
+        dest.set_pixel(0, 0,
+                       source.get_pixel(src_x, src_y));
     // Top right.
     if ((image_flags & IF_TILEABLE_TOP) && (image_flags & IF_TILEABLE_RIGHT))
-        dest.set_pixel(dest.width() - 1, 0, source.get_pixel(src_x + src_width - 1, src_y));
+        dest.set_pixel(dest.width() - 1, 0,
+                       source.get_pixel(src_x + src_width - 1, src_y));
     // Bottom left.
     if ((image_flags & IF_TILEABLE_BOTTOM) && (image_flags & IF_TILEABLE_LEFT))
-        dest.set_pixel(0, dest.height() - 1, source.get_pixel(src_x, src_y + src_height - 1));
+        dest.set_pixel(0, dest.height() - 1,
+                       source.get_pixel(src_x, src_y + src_height - 1));
     // Bottom right.
     if ((image_flags & IF_TILEABLE_BOTTOM) && (image_flags & IF_TILEABLE_RIGHT))
         dest.set_pixel(dest.width() - 1, dest.height() - 1,
-            source.get_pixel(src_x + src_width - 1, src_y + src_height - 1));
+                       source.get_pixel(src_x + src_width - 1, src_y + src_height - 1));
 
     // Now put the final image into the prepared borders.
     dest.insert(source, 1, 1, src_x, src_y, src_width, src_height);

data/src/BitmapIO.cpp

@@ -9,21 +9,17 @@
 #define STBI_NO_STDIO
 #define STBI_NO_LINEAR
 
-// Work around this bug:
-// https://bugs.launchpad.net/ubuntu/+source/gcc-5/+bug/1568899
-#ifdef GOSU_IS_X
-#define STBI_NO_SIMD
-#endif
-
 #include "stb_image.h"
 
+using namespace std;
+
 namespace
 {
     int read_callback(void* user, char* data, int size)
     {
         Gosu::Reader* reader = static_cast<Gosu::Reader*>(user);
-        std::size_t remaining = reader->resource().size() - reader->position();
-        std::size_t actual_size = (size < remaining ? size : remaining);
+        size_t remaining = reader->resource().size() - reader->position();
+        size_t actual_size = (size < remaining ? size : remaining);
         reader->read(data, actual_size);
         return static_cast<int>(actual_size);
     }
@@ -42,18 +38,15 @@ namespace
 
     bool is_bmp(Gosu::Reader reader)
     {
-        std::size_t remaining = reader.resource().size() - reader.position();
-        if (remaining < 2) {
-            return false;
-        }
+        size_t remaining = reader.resource().size() - reader.position();
+        if (remaining < 2) return false;
         char magic_bytes[2];
         reader.read(magic_bytes, sizeof magic_bytes);
-        reader.seek(sizeof magic_bytes);
         return magic_bytes[0] == 'B' && magic_bytes[1] == 'M';
     }
 }
 
-void Gosu::load_image_file(Gosu::Bitmap& bitmap, const std::string& filename)
+void Gosu::load_image_file(Gosu::Bitmap& bitmap, const string& filename)
 {
     Buffer buffer;
     load_file(buffer, filename);
@@ -74,11 +67,11 @@ void Gosu::load_image_file(Gosu::Bitmap& bitmap, Reader input)
     if (bytes == nullptr) {
         // TODO - stbi_failure_reason is not thread safe. Everything here should be wrapped in a
         // mutex.
-        throw std::runtime_error("Cannot load image: " + std::string(stbi_failure_reason()));
+        throw runtime_error("Cannot load image: " + string(stbi_failure_reason()));
     }
 
     bitmap.resize(x, y);
-    std::memcpy(bitmap.data(), bytes, x * y * sizeof(Gosu::Color));
+    memcpy(bitmap.data(), bytes, x * y * sizeof(Gosu::Color));
 
     stbi_image_free(bytes);
     
@@ -90,7 +83,7 @@ void Gosu::load_image_file(Gosu::Bitmap& bitmap, Reader input)
 #define STB_IMAGE_WRITE_IMPLEMENTATION
 #include "stb_image_write.h"
 
-void Gosu::save_image_file(const Gosu::Bitmap& bitmap, const std::string& filename)
+void Gosu::save_image_file(const Gosu::Bitmap& bitmap, const string& filename)
 {
     int ok;
     
@@ -104,9 +97,7 @@ void Gosu::save_image_file(const Gosu::Bitmap& bitmap, const std::string& filena
         ok = stbi_write_png(filename.c_str(), bitmap.width(), bitmap.height(), 4, bitmap.data(), 0);
     }
     
-    if (ok == 0) {
-        throw std::runtime_error("Could not save image data to file: " + filename);
-    }
+    if (ok == 0) throw runtime_error("Could not save image data to file: " + filename);
 }
 
 static void stbi_write_to_writer(void* context, void* data, int size)
@@ -116,7 +107,7 @@ static void stbi_write_to_writer(void* context, void* data, int size)
 }
 
 void Gosu::save_image_file(const Gosu::Bitmap& bitmap, Gosu::Writer writer,
-                           const std::string& format_hint)
+                           const string& format_hint)
 {
     int ok;
     
@@ -135,7 +126,7 @@ void Gosu::save_image_file(const Gosu::Bitmap& bitmap, Gosu::Writer writer,
     }
     
     if (ok == 0) {
-        throw std::runtime_error("Could not save image data to memory (format hint = '" +
-                                 format_hint + "'");
+        throw runtime_error("Could not save image data to memory (format hint = '" +
+                            format_hint + "'");
     }
 }