CUAudioDecoder.h

//
//  CUAudioDecoder.h
//  Cornell University Game Library (CUGL)
//
//  This is the base class for an audio decoder.  An audio decoder converts a
//  a binary file into a pageable PCM data stream.  This unifies the API for
//  all of the supported audio codes (WAV, MP3, OGG, FLAC)
//
//  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: 8/20/18
//
#ifndef __CU_AUDIO_DECODER_H__
#define __CU_AUDIO_DECODER_H__
#include <SDL/SDL.h>
#include <string>

namespace cugl {
    namespace audio {

class AudioDecoder {
protected:
    Uint8  _channels;
    
    Uint32 _rate;
    
    Uint64 _frames;
    
    std::string _file;

    Uint32 _pagesize;
    
    Uint64 _currpage;
    Uint64 _lastpage;
    
public:
    AudioDecoder();
    
    ~AudioDecoder() {}
    
    virtual bool init(const char* file) {
        return init(std::string(file));
    }

    virtual bool init(const std::string& file) = 0;

    virtual void dispose() = 0;

    
#pragma mark Attributes

    double getDuration() const { return (double)_frames/(double)_rate; }
    
    Uint32 getSampleRate() const { return _rate; }
    
    Uint64 getLength() const { return _frames; }
    
    Uint32 getChannels() const { return _channels; }
    
    std::string getFile() const { return _file; }

    Uint32 getPageSize() const { return _pagesize; }

    
#pragma mark Decoding

    bool ready() {
        return (_currpage < getPageCount());
    }
    
    virtual Sint32 pagein(float* buffer) = 0;

    Uint64 getPage() const { return _currpage; }

    virtual void setPage(Uint64 page) = 0;
    
    Uint64 getPageCount() const {
        return _frames % _pagesize == 0 ? _lastpage : _lastpage+1;
    }
    
    void rewind() { setPage(0); }
    
    Sint32 decode(float* buffer);

};
    }
}


#endif /* __CU_AUDIO_DECODER_H__ */