CUMusic.h

//
//  CUMusic.h
//  Cornell University Game Library (CUGL)
//
//  This module provides a stream music asset. While we support a wide range of
//  formats, only WAV, MP3, OGG are guaranteed to be supported on all CUGL
//  platforms (Android and iOS have very little overlap here).  MP3 files are
//  under patent until April 2017.  OGG is a popular alternative in games, but
//  it is still a lossy encoding. WAV files are extremely large and are not
//  suitable for streaming. If anything, you want want to create platform
//  specific assets and differentiate them in your asset directory.
//
//  We have factored out the platform-dependent code and have hidden it
//  behind this class as an abstraction.
//
//  This class uses our standard shared-pointer architecture.
//
//  1. The constructor does not perform any initialization; it just sets all
//     attributes to their defaults.
//
//  2. All initialization takes place via init methods, which can fail if an
//     object is initialized more than once.
//
//  3. All allocation takes place via static constructors which return a shared
//     pointer.
//
//
//  CUGL zlib License:
//      This software is provided 'as-is', without any express or implied
//      warranty.  In no event will the authors be held liable for any damages
//      arising from the use of this software.
//
//      Permission is granted to anyone to use this software for any purpose,
//      including commercial applications, and to alter it and redistribute it
//      freely, subject to the following restrictions:
//
//      1. The origin of this software must not be misrepresented; you must not
//      claim that you wrote the original software. If you use this software
//      in a product, an acknowledgment in the product documentation would be
//      appreciated but is not required.
//
//      2. Altered source versions must be plainly marked as such, and must not
//      be misrepresented as being the original software.
//
//      3. This notice may not be removed or altered from any source distribution.
//
//  Author: Walker White
//  Version: 12/10/16
//
#ifndef __CU_MUSIC_H__
#define __CU_MUSIC_H__
#include <cugl/base/CUBase.h>

namespace cugl {

// We use the impl namespace for platform-dependent data.
namespace impl {
    struct AudioStream;
}
    
class Music {
private:
    CU_DISALLOW_COPY_AND_ASSIGN(Music);
    
    std::string    _source;
    impl::AudioStream* _buffer;
    float _volume;
    
public:
    enum class Type : int {
        WAV = 0,
        MP3 = 1,
        AAC = 2,
        OGG = 3,
        M4A = 4,
        FLAC = 5,
        UNSUPPORTED = 6
    };
    
    
#pragma mark -
#pragma mark Constructors

    Music() : _source(""), _buffer(nullptr) {}
    
    ~Music() { dispose(); }
    
    void dispose();
    
    bool init(const std::string& source);
    
    bool init(const char* source) {
        return init(std::string(source));
    }
    
#pragma mark -
#pragma mark Static Constructors

    static std::shared_ptr<Music> alloc(const std::string& source) {
        std::shared_ptr<Music> result = std::make_shared<Music>();
        return (result->init(source) ? result : nullptr);
    }
    
    static std::shared_ptr<Music> alloc(const char* source) {
        std::shared_ptr<Music> result = std::make_shared<Music>();
        return (result->init(source) ? result : nullptr);
    }
    
#pragma mark Attributes

    const std::string& getSource() const { return _source; }
    
    std::string getSuffix() const {
        size_t pos = _source.rfind(".");
        return (pos == std::string::npos ? "" : _source.substr(pos));
    }
    
    double getDuration() const;
    
    Type getType() const;
    
    float getVolume() const { return _volume; }
    
    void setVolume(float volume);

    friend class MusicQueue;
};

}

#endif /* __CU_MUSIC_H__ */