CUAudioSample.h

//
//  CUAudioSample.h
//  Cornell University Game Library (CUGL)
//
//  This module provides the base class for representing an audio sample, or
//  a file with prerecorded audio. An audio sample is not a node in the audio
//  graph.  Instead, a sample is provided to an AudioPlayer for playback.
//  Multiple AudioPlayers can share the same sample, allowing copies of the
//  sound to be played simultaneously
//
//  This module provides support for both in-memory audio samples and streaming
//  audio. The former is ideal for sound effects, but not long-playing music.
//  The latter introduces some latency and is only ideal for long-playing music.
//
//  CUGL MIT 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: 11/20/18
//
#ifndef __CU_AUDIO_SAMPLE_H__
#define __CU_AUDIO_SAMPLE_H__
#include <SDL/SDL.h>
#include <cugl/assets/CUJsonValue.h>
#include "CUSound.h"
#include <string>
#include <atomic>
 
namespace  cugl {
    namespace audio {
        class AudioDecoder;
    }
    
class AudioSample : public Sound {
public:
#pragma mark File Types
 
    enum class Type : int {
        UNKNOWN   = -1,
        WAV_FILE  = 0,
        MP3_FILE  = 1,
        OGG_FILE  = 2,
        FLAC_FILE = 3,
        IN_MEMORY = 4
    };
 
protected:
    Uint64 _frames;
    
    Type _type;
        
    bool _stream;
 
    float* _buffer;
    
public:
#pragma mark Constructors
 
    AudioSample();
    
    ~AudioSample() { dispose(); }
    
    bool init(const char* file, bool stream=false);
    
    bool init(const std::string& file, bool stream=false) {
        return init(file.c_str(),stream);
    }
    
    bool init(Uint8 channels, Uint32 rate, Uint32 frames);
    
    virtual void dispose() override;
 
    static Type guessType(const char* file);
 
    static Type guessType(const std::string& file) {
        return guessType(file.c_str());
    }
    
#pragma mark Static Constructors
 
    static std::shared_ptr<AudioSample> alloc(const char* file, bool stream=false) {
        std::shared_ptr<AudioSample> result = std::make_shared<AudioSample>();
        return (result->init(file,stream) ? result : nullptr);
    }
    
    static std::shared_ptr<AudioSample> alloc(const std::string& file, bool stream=false) {
        return alloc(file.c_str(), stream);
    }
    
    static std::shared_ptr<AudioSample> alloc(Uint8 channels, Uint32 rate, Uint32 frames) {
        std::shared_ptr<AudioSample> result = std::make_shared<AudioSample>();
        return (result->init(channels,rate,frames) ? result : nullptr);
    }
    
    static std::shared_ptr<AudioSample> allocWithData(const std::shared_ptr<JsonValue>& data);
 
        
#pragma mark Attributes
 
    bool isStreamed() const { return _stream; }
 
    Type getType() const { return _type; }
    
    virtual Sint64 getLength() const override { return _frames; }
    
    virtual double getDuration() const override { return (double)_frames/(double)_rate; }
    
#pragma mark Playback Support
 
    float* getBuffer() { return _buffer; }
        
    std::shared_ptr<audio::AudioDecoder> getDecoder();
    
    virtual std::shared_ptr<audio::AudioNode> createNode() override;
};
    
}
 
 
#endif /* __CU_AUDIO_SAMPLE_H__ */