gosu 0.15.1 → 1.1.0.pre1

data/lib/gosu/zen.rb

@@ -1,89 +0,0 @@
-require 'gosu/preview'
-
-module Gosu
-  module Zen
-    
-    @@window_args = [800, 600, {}]
-    @@options = {}
-    
-    def window width, height, options = nil
-      if $window.nil?
-        @@window_args[0] = width
-        @@window_args[1] = height
-        @@window_args[2].merge! options if options
-      else
-        raise "window size can only be set before the window is created"
-      end
-    end
-    
-    def set what, value
-      if $window.nil?
-        @@options[what.to_sym] = value
-      else
-        $window.send "#{what}=", value
-      end
-    end
-    
-    def init &body
-      ZenWindow.send :define_method, :init, &body
-    end
-    
-    def button_down id = nil, &body
-      m = id ? "button_down_#{id}" : :button_down_other
-      ZenWindow.send :define_method, m, &body
-    end
-    
-    def button_up id = nil, &body
-      m = id ? "button_up_#{id}" : :button_up_other
-      ZenWindow.send :define_method, m, &body
-    end
-    
-    def update &body
-      ZenWindow.send :define_method, :update, &body
-    end
-    
-    def draw &body
-      ZenWindow.send :define_method, :draw, &body
-    end
-    
-    def run!
-      window = ZenWindow.new *@@window_args
-      @@options.each do |opt, value|
-        window.send "#{opt}=", value
-      end
-      window.show
-    end
-    
-    def Zen.included mod
-      at_exit { run! unless $! }
-    end
-    
-  end
-  
-  class ZenWindow < Window
-    def initialize *args
-      super
-      init
-    end
-    
-    def init
-    end
-    
-    def button_down id
-      m = :"button_down_#{id}"
-      respond_to?(m) ? send(m) : button_down_other(id)
-    end
-    
-    def button_up id
-      m = :"button_up_#{id}"
-      respond_to?(m) ? send(m) : button_up_other(id)
-    end
-    
-    def button_down_other id
-    end
-    
-    def button_up_other id
-    end
-    
-  end
-end

data/src/AudioToolboxFile.hpp

@@ -1,210 +0,0 @@
-#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
-    {
-        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,
-                                             static_cast<UInt32>(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 && desc.mBitsPerChannel == 16) {
-                format_ = AL_FORMAT_MONO16;
-            }
-            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
-                    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(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() override
-        {
-            ExtAudioFileDispose(file_);
-
-            if (file_id_) {
-                AudioFileClose(file_id_);
-            }
-        }
-        
-        ALenum format() const override
-        {
-            return format_;
-        }
-        
-        ALuint sample_rate() const override
-        {
-            return sample_rate_;
-        }
-        
-        void rewind() override
-        {
-            CHECK_OS(ExtAudioFileSeek(file_, 0 + seek_offset_));
-        }
-        
-        std::size_t read_data(void* dest, size_t length) override
-        {
-            AudioBufferList abl;
-            abl.mNumberBuffers = 1;
-            abl.mBuffers[0].mNumberChannels = 1;
-            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));
-            return abl.mBuffers[0].mDataByteSize;
-        }
-    };
-}

data/src/MPEGFile.hpp

@@ -1,90 +0,0 @@
-#pragma once
-
-#include "AudioFile.hpp"
-#include <Gosu/IO.hpp>
-#include <algorithm>
-#include <stdexcept>
-#include <string>
-
-#include <mpg123.h>
-
-namespace Gosu
-{
-    class MPEGFile : public AudioFile
-    {
-        Gosu::Buffer contents_;
-        off_t position_ = 0;
-        mpg123_handle* handle_;
-        
-        enum {
-            SAMPLE_RATE = 44100,
-            INPUT_SIZE = 16384
-        };
-        
-    public:
-        MPEGFile(Gosu::Reader reader)
-        {
-            contents_.resize(reader.resource().size() - reader.position());
-            reader.read(contents_.data(), contents_.size());
-
-            static int init_error = mpg123_init();
-            if (init_error != MPG123_OK) {
-                throw std::runtime_error("Cannot initialize mpg123: " +
-                                         std::string(mpg123_plain_strerror(init_error)));
-            }
-
-            int new_error;
-            handle_ = mpg123_new(nullptr, &new_error);
-            if (handle_ == nullptr) {
-                throw std::runtime_error("Cannot initialize mpg123 decoder: " +
-                                         std::string(mpg123_plain_strerror(new_error)));
-            }
-            
-            mpg123_param(handle_, MPG123_FORCE_RATE, SAMPLE_RATE, 0);
-            mpg123_param(handle_, MPG123_FLAGS, MPG123_FORCE_STEREO, 0);
-            
-            mpg123_open_feed(handle_);
-        }
-        
-        ~MPEGFile() override
-        {
-            mpg123_delete(handle_);
-        }
-        
-        ALenum format() const override
-        {
-            return AL_FORMAT_STEREO16;
-        }
-        
-        ALuint sample_rate() const override
-        {
-            return SAMPLE_RATE;
-        }
-        
-        std::size_t read_data(void* dest, std::size_t length) override
-        {
-            std::size_t written = 0;
-            int error = 0;
-            
-            error = mpg123_read(handle_, static_cast<unsigned char*>(dest), length, &written);
-            while (written == 0
-                   && (error == MPG123_NEED_MORE || error == MPG123_NEW_FORMAT)
-                   && position_ != contents_.size()) {
-                auto bytes = std::min<std::size_t>(contents_.size() - position_, INPUT_SIZE);
-                // (Not sure what to do about the return value of mpg123_feed here.)
-                mpg123_feed(handle_, static_cast<unsigned char*>(contents_.data()) + position_,
-                            bytes);
-                position_ += bytes;
-                error = mpg123_read(handle_, static_cast<unsigned char*>(dest), length, &written);
-            }
-            
-            return written;
-        }
-        
-        void rewind() override
-        {
-            mpg123_feedseek(handle_, 0, SEEK_SET, &position_);
-            assert (position_ >= 0 && position_ <= contents_.size());
-        }
-    };
-}

data/src/OggFile.hpp

@@ -1,92 +0,0 @@
-#pragma once
-
-#include "AudioFile.hpp"
-#include <Gosu/IO.hpp>
-#include <stdexcept>
-#include <string>
-
-// Disable comma warnings in stb headers.
-#ifdef __GNUC__
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wcomma"
-#endif
-
-#define STB_VORBIS_HEADER_ONLY
-#include "stb_vorbis.c"
-
-#ifdef __GNUC__
-#pragma GCC diagnostic pop
-#endif
-
-namespace Gosu
-{
-    class OggFile : public AudioFile
-    {
-        Gosu::Buffer contents_;
-        int channels_;
-        ALenum sample_rate_;
-        stb_vorbis* stream_;
-
-    public:
-        OggFile(Gosu::Reader reader)
-        {
-            contents_.resize(reader.resource().size() - reader.position());
-            reader.read(contents_.data(), contents_.size());
-            
-            int error = 0;
-            
-            auto data = static_cast<const unsigned char*>(contents_.data());
-            auto size = static_cast<int>(contents_.size());
-            stream_ = stb_vorbis_open_memory(data, size, &error, 0);
-            
-            if (stream_ == nullptr) {
-                throw std::runtime_error("Cannot open Ogg Vorbis file, error code: " +
-                                         std::to_string(error));
-            }
-            
-            stb_vorbis_info info = stb_vorbis_get_info(stream_);
-            channels_ = info.channels;
-            sample_rate_ = info.sample_rate;
-        }
-        
-        ~OggFile() override
-        {
-            stb_vorbis_close(stream_);
-            stream_ = nullptr;
-        }
-        
-        ALenum format() const override
-        {
-            return (channels_ == 1 ? AL_FORMAT_MONO16 : AL_FORMAT_STEREO16);
-        }
-        
-        ALuint sample_rate() const override
-        {
-            return sample_rate_;
-        }
-        
-        std::size_t read_data(void* dest, std::size_t length) override
-        {
-            int samples = 0;
-            int max_samples = static_cast<int>(length / sizeof(short));
-            
-            while (samples < max_samples) {
-                int samples_per_channel =
-                    stb_vorbis_get_samples_short_interleaved(stream_, channels_,
-                                                             static_cast<short*>(dest) + samples,
-                                                             max_samples - samples);
-                
-                if (samples_per_channel == 0) break;
-                
-                samples += samples_per_channel * channels_;
-            }
-            
-            return samples * sizeof(short);
-        }
-        
-        void rewind() override
-        {
-            stb_vorbis_seek_start(stream_);
-        }
-    };
-}