gosu 0.10.9.pre1 → 0.11.0

data/src/AudioFile.hpp

@@ -0,0 +1,57 @@
+#pragma once
+
+#include <Gosu/Platform.hpp>
+#include <vector>
+#ifdef GOSU_IS_MAC
+#include <OpenAL/al.h>
+#else
+#include <AL/al.h>
+#endif
+
+namespace Gosu
+{
+    class AudioFile
+    {
+        AudioFile(const AudioFile&) = delete;
+        AudioFile& operator=(const AudioFile&) = delete;
+        AudioFile(AudioFile&&) = delete;
+        AudioFile& operator=(AudioFile&&) = delete;
+        
+        std::vector<char> data_;
+        
+    public:
+        AudioFile() {}
+        
+        virtual ~AudioFile() {}
+        
+        virtual ALenum format() const = 0;
+        
+        virtual ALuint sample_rate() const = 0;
+        
+        virtual std::size_t read_data(void* dest, std::size_t length) = 0;
+        
+        virtual void rewind() = 0;
+        
+        const std::vector<char>& decoded_data()
+        {
+            static const unsigned INCREMENT = 512 * 1024;
+            
+            if (!data_.empty()) {
+                return data_;
+            }
+            
+            for (;;) {
+                data_.resize(data_.size() + INCREMENT);
+                
+                int read_bytes = read_data(&data_[data_.size() - INCREMENT], INCREMENT);
+                
+                if (read_bytes < INCREMENT) {
+                    data_.resize(data_.size() - INCREMENT + read_bytes);
+                    break;
+                }
+            }
+            
+            return data_;
+        }
+    };
+}

data/src/AudioToolboxFile.hpp

@@ -0,0 +1,214 @@
+#pragma once
+
+#import "AudioFile.hpp"
+#import <AudioToolbox/AudioToolbox.h>
+#import <AudioToolbox/AudioConverter.h>
+#import <AudioToolbox/ExtendedAudioFile.h>
+#import <CoreFoundation/CoreFoundation.h>
+#import <Foundation/Foundation.h>
+#import <Gosu/IO.hpp>
+#import <Gosu/Platform.hpp>
+#import <Gosu/Utility.hpp>
+#import <OpenAL/al.h>
+#import <algorithm>
+#import <arpa/inet.h>
+#import <stdexcept>
+#import <vector>
+
+inline static void throw_os_error(OSStatus status, unsigned line)
+{
+    std::string what;
+    @autoreleasepool {
+        NSError* error = [NSError errorWithDomain:NSOSStatusErrorDomain code:status userInfo:nil];
+        NSString* message = [NSString stringWithFormat:@"Error 0x%x on line %u: %@", line, status,
+                                      error.localizedDescription];
+        what = message.UTF8String;
+    }
+    throw std::runtime_error(what);
+}
+
+#define CHECK_OS(status) do { if (status) throw_os_error(status, __LINE__); } while (0)
+
+namespace Gosu
+{
+    class AudioToolboxFile : public AudioFile
+    {
+        Gosu::Buffer buffer_;
+        AudioFileID file_id_;
+        ExtAudioFileRef file_;
+        SInt64 position_;
+        SInt64 seek_offset_;
+        
+        ALenum format_;
+        ALuint sample_rate_;
+        UInt32 bytes_per_frame_;
+        bool big_endian_;
+        
+        static OSStatus AudioFile_ReadProc(void* in_client_data, SInt64 in_position,
+            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);
+            res.read(in_position, *actual_count, buffer);
+            return noErr;
+        }
+        
+        static SInt64 AudioFile_GetSizeProc(void* in_client_data)
+        {
+            const Resource& res = *static_cast<Resource*>(in_client_data);
+            return res.size();
+        }
+        
+        void init_seek_offset()
+        {
+            AudioConverterRef ac_ref;
+            UInt32 acr_size = sizeof ac_ref;
+            CHECK_OS(ExtAudioFileGetProperty(file_, kExtAudioFileProperty_AudioConverter,
+                                             &acr_size, &ac_ref));
+            
+            AudioConverterPrimeInfo prime_info;
+            UInt32 pi_size = sizeof prime_info;
+            OSStatus result = AudioConverterGetProperty(ac_ref, kAudioConverterPrimeInfo,
+                                                        &pi_size, &prime_info);
+            if (result != kAudioConverterErr_PropertyNotSupported) {
+                CHECK_OS(result);
+                seek_offset_ = prime_info.leadingFrames;
+            }
+        }
+        
+        void init_client_format_based_on(const AudioStreamBasicDescription& base)
+        {
+            AudioStreamBasicDescription client_data = { 0 };
+            sample_rate_ = client_data.mSampleRate = 22050;
+            client_data.mFormatID = kAudioFormatLinearPCM;
+            client_data.mFormatFlags = kAudioFormatFlagIsSignedInteger | kAudioFormatFlagsNativeEndian | kAudioFormatFlagIsPacked;
+            client_data.mBitsPerChannel = 16;
+            client_data.mChannelsPerFrame = base.mChannelsPerFrame;
+            client_data.mFramesPerPacket = 1;
+            client_data.mBytesPerPacket =
+                client_data.mBytesPerFrame =
+                    client_data.mChannelsPerFrame * client_data.mBitsPerChannel / 8;
+            CHECK_OS(ExtAudioFileSetProperty(file_, kExtAudioFileProperty_ClientDataFormat,
+                                             sizeof client_data, &client_data));
+            
+            init_seek_offset();
+
+            format_ = client_data.mChannelsPerFrame == 1 ? AL_FORMAT_MONO16 : AL_FORMAT_STEREO16;
+        }
+        
+        void init()
+        {
+            // Streaming starts at beginning
+            position_ = 0;
+            
+            // Unless overridden later, assume that the index into seek() is 0-based
+            seek_offset_ = 0;
+            
+            AudioStreamBasicDescription desc;
+            UInt32 size_of_property = sizeof desc;
+            CHECK_OS(ExtAudioFileGetProperty(file_, kExtAudioFileProperty_FileDataFormat,
+                                             &size_of_property, &desc));
+
+            // Sample rate for OpenAL
+            sample_rate_ = desc.mSampleRate;
+            
+            // Sanity checks
+            if (desc.mFormatFlags & kAudioFormatFlagIsNonInterleaved) {
+                throw std::runtime_error("Non-interleaved formats are unsupported");
+            }
+            
+            // 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;
+            }
+            else if (desc.mChannelsPerFrame == 2) {
+                /*if (desc.mBitsPerChannel == 8)
+                    format_ = AL_FORMAT_STEREO8;
+                else */if (desc.mBitsPerChannel == 16)
+                    format_ = AL_FORMAT_STEREO16;
+            }
+            
+            if (format_ == 0 ||
+                    // If format not native for OpenAL, set client data format
+                    // to enable conversion
+                    desc.mFormatFlags & kAudioFormatFlagIsBigEndian ||
+                    desc.mFormatFlags & kAudioFormatFlagIsFloat ||
+                    !(desc.mFormatFlags & kAudioFormatFlagIsSignedInteger)) {
+                init_client_format_based_on(desc);
+            }
+            else {
+                // Just set the old format as the client format so
+                // ExtAudioFileSeek will work for us.
+                CHECK_OS(ExtAudioFileSetProperty(file_, kExtAudioFileProperty_ClientDataFormat,
+                                                 sizeof desc, &desc));
+            }
+        }
+        
+    public:
+        AudioToolboxFile(const std::string& filename)
+        {
+            NSURL* URL = [NSURL fileURLWithPath:[NSString stringWithUTF8String:filename.c_str()]];
+            CHECK_OS(ExtAudioFileOpenURL((__bridge CFURLRef) URL, &file_));
+            
+            file_id_ = 0;
+            
+            init();
+        }
+        
+        AudioToolboxFile(Gosu::Reader reader)
+        {
+            buffer_.resize(reader.resource().size() - reader.position());
+            reader.read(buffer_.data(), buffer_.size());
+            
+            // TODO: This fails on iOS with MP3 files.
+            // TODO: ^ Is the comment above still true on non-ancient iOS versions?
+            
+            void* client_data = &buffer_;
+            CHECK_OS(AudioFileOpenWithCallbacks(client_data, AudioFile_ReadProc, 0,
+                                                AudioFile_GetSizeProc, 0, 0, &file_id_));
+            CHECK_OS(ExtAudioFileWrapAudioFileID(file_id_, false, &file_));
+            
+            init();
+        }
+        
+        ~AudioToolboxFile()
+        {
+            ExtAudioFileDispose(file_);
+
+            if (file_id_) {
+                AudioFileClose(file_id_);
+            }
+        }
+        
+        ALenum format() const
+        {
+            return format_;
+        }
+        
+        ALuint sample_rate() const
+        {
+            return sample_rate_;
+        }
+        
+        void rewind()
+        {
+            CHECK_OS(ExtAudioFileSeek(file_, 0 + seek_offset_));
+        }
+        
+        std::size_t read_data(void* dest, size_t length)
+        {
+            AudioBufferList abl;
+            abl.mNumberBuffers = 1;
+            abl.mBuffers[0].mNumberChannels = 1;
+            abl.mBuffers[0].mDataByteSize = 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));
+            return abl.mBuffers[0].mDataByteSize;
+        }
+    };
+}

data/src/Bitmap.cpp

@@ -0,0 +1,159 @@
+#include <Gosu/Bitmap.hpp>
+#include <cassert>
+#include <algorithm>
+#include <vector>
+
+void Gosu::Bitmap::swap(Bitmap& other)
+{
+    std::swap(pixels, other.pixels);
+    std::swap(w, other.w);
+    std::swap(h, other.h);
+}
+
+void Gosu::Bitmap::resize(unsigned width, unsigned height, Color c)
+{
+    if (width == w && height == h)
+        return;
+
+    Bitmap temp(width, height, c);
+    temp.insert(*this, 0, 0);
+    swap(temp);
+}
+
+void Gosu::Bitmap::insert(const Bitmap& source, int x, int y)
+{
+    insert(source, x, y, 0, 0, source.width(), source.height());
+}
+
+void Gosu::Bitmap::insert(const Bitmap& source, int x, int y, unsigned src_x, unsigned src_y,
+    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;
+
+        src_x += clip_left;
+        src_width -= clip_left;
+        x = 0;
+    }
+
+    if (y < 0) {
+        unsigned clip_top = -y;
+
+        if (clip_top >= src_height)
+            return;
+
+        src_y += clip_top;
+        src_height -= clip_top;
+        y = 0;
+    }
+
+    if (x + src_width > w) {
+        if (static_cast<unsigned>(x) >= w)
+            return;
+
+        src_width = w - x;
+    }
+
+    if (y + src_height > h) {
+        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));
+}
+
+void Gosu::apply_color_key(Bitmap& bitmap, Color key)
+{
+    std::vector<Color> surrounding_colors;
+    surrounding_colors.reserve(4);
+
+    for (unsigned y = 0; y < bitmap.height(); ++y)
+        for (unsigned x = 0; x < bitmap.width(); ++x)
+            if (bitmap.get_pixel(x, y) == key) {
+                surrounding_colors.clear();
+                if (x > 0 && bitmap.get_pixel(x - 1, y) != key)
+                    surrounding_colors.push_back(bitmap.get_pixel(x - 1, y));
+                if (x < bitmap.width() - 1 && bitmap.get_pixel(x + 1, y) != key)
+                    surrounding_colors.push_back(bitmap.get_pixel(x + 1, y));
+                if (y > 0 && bitmap.get_pixel(x, y - 1) != key)
+                    surrounding_colors.push_back(bitmap.get_pixel(x, y - 1));
+                if (y < bitmap.height() - 1 && bitmap.get_pixel(x, y + 1) != key)
+                    surrounding_colors.push_back(bitmap.get_pixel(x, y + 1));
+
+                if (surrounding_colors.empty()) {
+                    bitmap.set_pixel(x, y, Color::NONE);
+                    continue;
+                }
+
+                unsigned red = 0, green = 0, blue = 0;
+                for (auto& color : surrounding_colors) {
+                    red += color.red();
+                    green += color.green();
+                    blue += color.blue();
+                }
+                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);
+}
+
+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)
+{
+    // Backwards compatibility: This used to be 'bool tileable'.
+    if (image_flags == 1)
+        image_flags = IF_TILEABLE;
+
+    dest.resize(src_width + 2, src_height + 2);
+
+    // The borders are made "harder" by duplicating the original bitmap's
+    // borders.
+
+    // Top.
+    if (image_flags & IF_TILEABLE_TOP)
+        dest.insert(source, 1, 0, src_x, src_y, src_width, 1);
+    // Bottom.
+    if (image_flags & IF_TILEABLE_BOTTOM)
+        dest.insert(source, 1, dest.height() - 1, src_x, src_y + src_height - 1, src_width, 1);
+    // Left.
+    if (image_flags & IF_TILEABLE_LEFT)
+        dest.insert(source, 0, 1, src_x, src_y, 1, src_height);
+    // Right.
+    if (image_flags & IF_TILEABLE_RIGHT)
+        dest.insert(source, dest.width() - 1, 1, src_x + src_width - 1, src_y, 1, src_height);
+
+    // 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));
+    // 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));
+    // 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));
+    // 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));
+
+    // 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

@@ -0,0 +1,141 @@
+#include <Gosu/Bitmap.hpp>
+#include <Gosu/IO.hpp>
+#include <Gosu/Platform.hpp>
+#include <Gosu/Utility.hpp>
+#include <cstring>
+#include <stdexcept>
+
+#define STB_IMAGE_IMPLEMENTATION
+#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"
+
+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);
+        reader->read(data, actual_size);
+        return actual_size;
+    }
+
+    void skip_callback(void* user, int n)
+    {
+        Gosu::Reader* reader = static_cast<Gosu::Reader*>(user);
+        reader->set_position(reader->position() + n);
+    }
+
+    int eof_callback(void* user)
+    {
+        Gosu::Reader* reader = static_cast<Gosu::Reader*>(user);
+        return reader->position() == reader->resource().size();
+    }
+
+    bool is_bmp(Gosu::Reader reader)
+    {
+        std::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)
+{
+    Buffer buffer;
+    load_file(buffer, filename);
+    load_image_file(bitmap, buffer.front_reader());
+}
+
+void Gosu::load_image_file(Gosu::Bitmap& bitmap, Reader input)
+{
+    bool needs_color_key = is_bmp(input);
+    
+    stbi_io_callbacks callbacks;
+    callbacks.read = read_callback;
+    callbacks.skip = skip_callback;
+    callbacks.eof = eof_callback;
+    int x, y, n;
+    stbi_uc* bytes = stbi_load_from_callbacks(&callbacks, &input, &x, &y, &n, STBI_rgb_alpha);
+
+    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()));
+    }
+
+    bitmap.resize(x, y);
+    std::memcpy(bitmap.data(), bytes, x * y * sizeof(Gosu::Color));
+
+    stbi_image_free(bytes);
+    
+    if (needs_color_key) {
+        apply_color_key(bitmap, Gosu::Color::FUCHSIA);
+    }
+}
+
+#define STB_IMAGE_WRITE_IMPLEMENTATION
+#include "stb_image_write.h"
+
+void Gosu::save_image_file(const Gosu::Bitmap& bitmap, const std::string& filename)
+{
+    int ok;
+    
+    if (has_extension(filename, "bmp")) {
+        ok = stbi_write_bmp(filename.c_str(), bitmap.width(), bitmap.height(), 4, bitmap.data());
+    }
+    else if (has_extension(filename, "tga")) {
+        ok = stbi_write_tga(filename.c_str(), bitmap.width(), bitmap.height(), 4, bitmap.data());
+    }
+    else {
+        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);
+    }
+}
+
+static void stbi_write_to_writer(void* context, void* data, int size)
+{
+    Gosu::Writer* writer = reinterpret_cast<Gosu::Writer*>(context);
+    writer->write(data, size);
+}
+
+void Gosu::save_image_file(const Gosu::Bitmap& bitmap, Gosu::Writer writer,
+                           const std::string& format_hint)
+{
+    int ok;
+    
+    if (has_extension(format_hint, "bmp")) {
+        ok = stbi_write_bmp_to_func(stbi_write_to_writer, &writer, bitmap.width(), bitmap.height(),
+                                    4, bitmap.data());
+    }
+    else if (has_extension(format_hint, "tga")) {
+        stbi_write_tga_with_rle = 0;
+        ok = stbi_write_tga_to_func(stbi_write_to_writer, &writer, bitmap.width(), bitmap.height(),
+                                    4, bitmap.data());
+    }
+    else {
+        ok = stbi_write_png_to_func(stbi_write_to_writer, &writer, bitmap.width(), bitmap.height(),
+                                    4, bitmap.data(), 0);
+    }
+    
+    if (ok == 0) {
+        throw std::runtime_error("Could not save image data to memory (format hint = '" +
+                                 format_hint + "'");
+    }
+}