CUWAVDecoder.h

//
//  CUWAVDecoder.h
//  Cornell University Game Library (CUGL)
//
//  This is class for decoding WAV files. It supports PCM, IEEE Float, and
//  ADPCM encoding (both MS and IMA).  However, it does not support MP3 data
//  stored in a WAV file.  MP3 data should be stored in an MP3 file.
//
//  This code is heavily adapted from SDL_wave.c in SDL 2.0.5 by Sam Lantinga.
//  That implementation does not allow WAV files to be streamed.  In addition,
//  it required the audio thread to be initialized before loading assets.  This
//  implementation decouples the decoding process, removing these concerns.
//
//  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.
//
//  Authors: Sam Lantinga, Walker White
//  Version: 6/29/17
//
#ifndef __CU_WAV_DECODER_H__
#define __CU_WAV_DECODER_H__
#include "CUAudioDecoder.h"
#include <SDL/SDL.h>

namespace cugl {
    namespace audio {
        
#pragma mark WAV Header

typedef struct WaveFMT {
    Uint16 encoding;
    Uint16 channels;
    /* The sample rate (11025, 22050, or 44100 Hz) */
    Uint32 frequency;
    /* The average bytes per second */
    Uint32 byterate;
    /* The number of bytes per sample block */
    Uint16 blockalign;
    /* One of 8, 12, 16, or 4 for ADPCM */
    Uint16 bitspersample;
} WaveFMT;


#pragma mark -
#pragma mark ADPCM Decoder

class ADPCMDecoder {
protected:
    WaveFMT _wavefmt;
    Uint8*  _blkbuffer;
    Uint16  _blocksize;
    
public:
#pragma mark Constructors

    ADPCMDecoder() : _blocksize(0), _blkbuffer(nullptr) {}
    
    virtual ~ADPCMDecoder();
    
    virtual bool init(WaveFMT* format);

#pragma mark Decoding

    Uint64 getFrames(Uint64 bytes) const {
        return (_blocksize*bytes)/_wavefmt.blockalign;
    }

    Uint32 getBlockSize() const {
        return _blocksize;
    }
    
    virtual Sint32 read(SDL_RWops* source, Uint8* buffer) = 0;
};
   

#pragma mark -
#pragma mark WAV Decoder

class WAVDecoder : public AudioDecoder {
public:
    enum class Type : int {
        PCM_DATA   = 0,
        IEEE_FLOAT = 1,
        MS_ADPCM   = 2,
        IMA_ADPCM  = 3,
        MP3_DATA   = 4,
        UNKNOWN    = 5
    };
    
protected:
    SDL_RWops* _source;
    Uint8* _chunker;
    Type   _datatype;

    Uint32 _sampbits;
    Uint32 _sampsize;
    Sint64 _datamark;
    
    std::shared_ptr<ADPCMDecoder> _adpcm;
    
public:
#pragma mark Constructors

    WAVDecoder();
    
    ~WAVDecoder();
    
    bool init(const char* file) override {
        return init(std::string(file));
    }
    
    bool init(const std::string& file) override;
    
    void dispose() override;
    
#pragma mark Static Constructors

    static std::shared_ptr<AudioDecoder> alloc(const char* file) {
        return alloc(std::string(file));
    }
    
    static std::shared_ptr<AudioDecoder> alloc(const std::string& file);
    
    
#pragma mark Decoding

    Type getType() const { return _datatype; }
    
    virtual Sint32 pagein(float* buffer) override;
    
    void setPage(Uint64 page) override;

private:
    bool isADPCM() const { return _datatype == Type::MS_ADPCM || _datatype == Type::IMA_ADPCM; }

    bool bootstrap(const std::string& file);
    
};
    }
}

#endif /* __CU_WAV_DECODER_H__ */