gosu 0.15.2 → 1.0.0.pre1

data/src/AudioFile.hpp

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

data/src/AudioFileAudioToolbox.cpp

@@ -0,0 +1,237 @@
+#include <Gosu/Platform.hpp>
+
+// The reason for having this implementation in addition to SDL_sound is that we don't currently
+// use SDL at all on iOS. The duplication between this file and SDL_sound_coreaudio.c is pretty
+// painful to watch, though. TODO: See if we can use parts of SDL on iOS as well?
+
+#ifdef GOSU_IS_IPHONE
+
+#include "AudioFile.hpp"
+#include "AudioImpl.hpp"
+#include <Gosu/Utility.hpp>
+
+#import <AudioToolbox/AudioToolbox.h>
+#import <AudioToolbox/AudioConverter.h>
+#import <AudioToolbox/ExtendedAudioFile.h>
+#import <CoreFoundation/CoreFoundation.h>
+#import <Foundation/Foundation.h>
+
+#include <algorithm>
+#include <arpa/inet.h>
+#include <stdexcept>
+#include <vector>
+
+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)
+
+struct Gosu::AudioFile::Impl
+{
+    Buffer buffer;
+    AudioFileID file_id;
+    ExtAudioFileRef file;
+    SInt64 position;
+    SInt64 seek_offset;
+    
+    ALenum format;
+    ALuint sample_rate;
+    UInt32 bytes_per_frame;
+    bool big_endian;
+
+    std::vector<char> data;
+    
+    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));
+        }
+    }
+};
+
+Gosu::AudioFile::AudioFile(const std::string& filename)
+: pimpl(new Impl)
+{
+    NSURL* URL = [NSURL fileURLWithPath:[NSString stringWithUTF8String:filename.c_str()]];
+    CHECK_OS(ExtAudioFileOpenURL((__bridge CFURLRef) URL, &pimpl->file));
+    
+    pimpl->file_id = 0;
+    
+    pimpl->init();
+}
+
+Gosu::AudioFile::AudioFile(Reader reader)
+: pimpl(new Impl)
+{
+    pimpl->buffer.resize(reader.resource().size() - reader.position());
+    reader.read(pimpl->buffer.data(), pimpl->buffer.size());
+    
+    void* client_data = &pimpl->buffer;
+    CHECK_OS(AudioFileOpenWithCallbacks(client_data, Impl::AudioFile_ReadProc, nullptr,
+                                        Impl::AudioFile_GetSizeProc, nullptr, 0, &pimpl->file_id));
+    CHECK_OS(ExtAudioFileWrapAudioFileID(pimpl->file_id, false, &pimpl->file));
+    
+    pimpl->init();
+}
+
+Gosu::AudioFile::~AudioFile()
+{
+    ExtAudioFileDispose(pimpl->file);
+
+    if (pimpl->file_id) {
+        AudioFileClose(pimpl->file_id);
+    }
+}
+
+ALenum Gosu::AudioFile::format() const
+{
+    return pimpl->format;
+}
+
+ALuint Gosu::AudioFile::sample_rate() const
+{
+    return pimpl->sample_rate;
+}
+
+void Gosu::AudioFile::rewind()
+{
+    CHECK_OS(ExtAudioFileSeek(pimpl->file, 0 + pimpl->seek_offset));
+}
+
+std::size_t Gosu::AudioFile::read_data(void* dest, size_t length)
+{
+    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(pimpl->file, &numFrames, &abl));
+    return abl.mBuffers[0].mDataByteSize;
+}
+
+const std::vector<char>& Gosu::AudioFile::decoded_data()
+{
+   if (!pimpl->data.empty()) {
+       return pimpl->data;
+   }
+
+   static const std::size_t INCREMENT = 512 * 1024;
+
+   for (;;) {
+       pimpl->data.resize(pimpl->data.size() + INCREMENT);
+
+       auto read_bytes = read_data(&pimpl->data[pimpl->data.size() - INCREMENT], INCREMENT);
+
+       if (read_bytes < INCREMENT) {
+           pimpl->data.resize(pimpl->data.size() - INCREMENT + read_bytes);
+           break;
+       }
+   }
+
+   return pimpl->data;
+}
+
+#endif

data/src/AudioFileSDLSound.cpp

@@ -0,0 +1,147 @@
+#include <Gosu/Platform.hpp>
+
+#ifndef GOSU_IS_IPHONE
+
+#include "AudioFile.hpp"
+#include "AudioImpl.hpp"
+
+#include <SDL_sound.h>
+
+#include <cstdlib>
+#include <cstring>
+#include <algorithm>
+#include <memory>
+#include <mutex>
+#include <vector>
+
+struct Gosu::AudioFile::Impl
+{
+    Buffer buffer;
+
+    std::shared_ptr<Sound_Sample> sample;
+
+    std::vector<char> data;
+
+    Impl()
+    {
+        static std::once_flag initialized;
+        std::call_once(initialized, Sound_Init);
+        // Don't bother calling Sound_Quit(); it's hard to know when to clean up within the scope
+        // of a Ruby C extension. Let the operating system clean up after us.
+    }
+};
+
+Gosu::AudioFile::AudioFile(const std::string& filename)
+: pimpl(new Impl)
+{
+    // We need to set a "desired" audio format, otherwise we may encounter data formats such as
+    // floating-point samples that Apple's OpenAL implementation does not support.
+    Sound_AudioInfo desired;
+    // Prefer 16-bit signed data which is supported by all versions of OpenAL.
+    desired.format = AUDIO_S16;
+    // 0 means "use whatever we have" (see SDL_sound.c, init_sample).
+    desired.channels = 0;
+    desired.rate = 0;
+
+    pimpl->sample.reset(Sound_NewSampleFromFile(filename.c_str(), &desired, 4096),
+                        Sound_FreeSample);
+    if (!pimpl->sample) {
+        std::string message = "Could not parse audio file " + filename;
+        if (const char* error = Sound_GetError()) {
+            message += ": ";
+            message += error;
+        }
+        throw std::runtime_error(message);
+    }
+}
+
+Gosu::AudioFile::AudioFile(Reader reader)
+: pimpl(new Impl)
+{
+    pimpl->buffer.resize(reader.resource().size() - reader.position());
+    reader.read(pimpl->buffer.data(), pimpl->buffer.size());
+    pimpl->sample.reset(Sound_NewSampleFromMem(reinterpret_cast<Uint8*>(pimpl->buffer.data()),
+                                               static_cast<Uint32>(pimpl->buffer.size()),
+                                               "", nullptr, 4096),
+                        Sound_FreeSample);
+    if (!pimpl->sample) {
+        std::string message = "Could not parse audio file";
+        if (const char* error = Sound_GetError()) {
+            message += ": ";
+            message += error;
+        }
+        throw std::runtime_error(message);
+    }
+}
+
+Gosu::AudioFile::~AudioFile()
+{
+}
+
+ALenum Gosu::AudioFile::format() const
+{
+    auto channels = pimpl->sample->desired.channels;
+    auto format = pimpl->sample->desired.format;
+
+    if (channels == 1 && SDL_AUDIO_ISINT(format)) {
+        if (SDL_AUDIO_BITSIZE(format) == 8) return AL_FORMAT_MONO8;
+        if (SDL_AUDIO_BITSIZE(format) == 16) return AL_FORMAT_MONO16;
+    }
+    if (channels == 2 && SDL_AUDIO_ISINT(format)) {
+        if (SDL_AUDIO_BITSIZE(format) == 8) return AL_FORMAT_STEREO8;
+        if (SDL_AUDIO_BITSIZE(format) == 16) return AL_FORMAT_STEREO16;
+    }
+
+    throw std::runtime_error("Unsupported number of channels: " + std::to_string(channels) +
+                             " and format: " + std::to_string(format));
+}
+
+ALuint Gosu::AudioFile::sample_rate() const
+{
+    return pimpl->sample->actual.rate;
+}
+
+void Gosu::AudioFile::rewind()
+{
+    Sound_Rewind(pimpl->sample.get());
+}
+
+std::size_t Gosu::AudioFile::read_data(void* dest, size_t length)
+{
+    std::size_t read = 0;
+    while (length > 0) {
+        // TODO offset magic
+        auto result = static_cast<std::size_t>(Sound_Decode(pimpl->sample.get()));
+        if (result == 0) break;
+        auto to_copy = std::min(length, result);
+        std::memcpy(dest, pimpl->sample->buffer, to_copy);
+        dest = static_cast<char*>(dest) + to_copy;
+        length -= to_copy;
+        read += to_copy;
+    }
+    return read;
+}
+
+const std::vector<char>& Gosu::AudioFile::decoded_data()
+{
+   if (!pimpl->data.empty()) {
+       return pimpl->data;
+   }
+
+   static const std::size_t INCREMENT = 512 * 1024;
+
+   for (;;) {
+       pimpl->data.resize(pimpl->data.size() + INCREMENT);
+
+       auto read_bytes = read_data(&pimpl->data[pimpl->data.size() - INCREMENT], INCREMENT);
+
+       if (read_bytes < INCREMENT) {
+           pimpl->data.resize(pimpl->data.size() - INCREMENT + read_bytes);
+           break;
+       }
+   }
+
+   return pimpl->data;
+}
+
+#endif