248 lines
11 KiB
C++
248 lines
11 KiB
C++
#ifndef WRAPPER_H
|
|
#define WRAPPER_H
|
|
|
|
#include <emscripten/bind.h>
|
|
#include <emscripten/val.h>
|
|
|
|
#include "mad.h"
|
|
#include "decoder.h"
|
|
|
|
using namespace emscripten;
|
|
|
|
class MadHeader : public mad_header {
|
|
public:
|
|
mad_layer getLayer() const {return layer;}
|
|
void setLayer(mad_layer lay) {layer = lay;}
|
|
|
|
int getMode_extension() const {return mode_extension;}
|
|
void setMode_extension(int ext) {mode_extension = ext;}
|
|
|
|
mad_mode getMode() const {return mode;}
|
|
void setMode(mad_mode value) {mode = value;}
|
|
|
|
mad_emphasis getEmphasis() const {return emphasis;}
|
|
void setEmphasis(mad_emphasis value) {emphasis = value;}
|
|
|
|
long unsigned int getBitrate() const {return bitrate;}
|
|
void setBitrate(long unsigned int value) {bitrate = value;}
|
|
|
|
unsigned int getSamplerate() const {return samplerate;}
|
|
void setSamplerate(unsigned int value) {samplerate = value;}
|
|
|
|
short unsigned int getCrc_check() const {return crc_check;}
|
|
void setCrc_check(short unsigned int value) {crc_check = value;}
|
|
|
|
short unsigned int getCrc_target() const {return crc_target;}
|
|
void setCrc_target(unsigned long int value) {crc_target = value;}
|
|
|
|
int getFlags() const {return flags;}
|
|
void setFlags(int ext) {flags = ext;}
|
|
|
|
int getPrivate_bits() const {return private_bits;}
|
|
void setPrivate_bits(int ext) {private_bits = ext;}
|
|
|
|
mad_timer_t getDuration() const {return duration;}
|
|
void setDuration(mad_timer_t ext) {duration = ext;}
|
|
};
|
|
MadHeader* mad_header_create();
|
|
|
|
class MadFrame : public mad_frame {
|
|
public:
|
|
int getOptions() const {return options;}
|
|
void setOptions(int lay) {options = lay;}
|
|
|
|
val getSbsample() const;
|
|
val getOverlap() const;
|
|
|
|
int decode(mad_stream* stream);
|
|
const MadHeader* header() const {return static_cast<const MadHeader*>(&(mad_frame::header));}
|
|
};
|
|
MadFrame* mad_frame_create();
|
|
|
|
class MadStream : public mad_stream {
|
|
//unsigned char const *buffer; /* input bitstream buffer */
|
|
//unsigned char const *bufend; /* end of buffer */
|
|
//unsigned long skiplen; /* bytes to skip before next frame */
|
|
|
|
//unsigned char const *this_frame; /* start of current frame */
|
|
//unsigned char const *next_frame; /* start of next frame */
|
|
//struct mad_bitptr ptr; /* current processing bit pointer */
|
|
|
|
//struct mad_bitptr anc_ptr; /* ancillary bits pointer */
|
|
//unsigned int anc_bitlen; /* number of ancillary bits */
|
|
|
|
public:
|
|
int getSync() const {return sync;}
|
|
void setSync(int value) {sync = value;}
|
|
|
|
unsigned long getFreeRate() const {return freerate;}
|
|
void setFreeRate(unsigned long value) {freerate = value;}
|
|
|
|
int getOptions() const {return options;}
|
|
void setOptions(int value) {options = value;}
|
|
|
|
mad_error getError() const {return error;}
|
|
void setError(mad_error value) {error = value;}
|
|
|
|
val mainData();
|
|
unsigned int getMdLen() const {return md_len;}
|
|
void setMdLen(unsigned int value) {md_len = value;}
|
|
|
|
void setBuffer(intptr_t bufferPtr, unsigned long length);
|
|
};
|
|
MadStream* mad_stream_create();
|
|
|
|
class MadPCM : public mad_pcm {
|
|
public:
|
|
unsigned int getSamplerate() const {return samplerate;}
|
|
void setSamplerate(unsigned int value) {samplerate = value;}
|
|
|
|
unsigned short getChannels() const {return channels;}
|
|
void setChannels(unsigned short value) {channels = value;}
|
|
|
|
unsigned short getLength() const {return length;}
|
|
void setLength(unsigned short value) {length = value;}
|
|
|
|
val samples() const;
|
|
};
|
|
|
|
MadPCM* mad_pcm_create();
|
|
|
|
class MadSynth : public mad_synth {
|
|
public:
|
|
unsigned int getPhase() const {return phase;}
|
|
void setPhase(unsigned int value) {phase = value;}
|
|
|
|
const MadPCM* pcm() const {return static_cast<const MadPCM*>(&(mad_synth::pcm));}
|
|
void frame(mad_frame const * frame);
|
|
};
|
|
|
|
MadSynth* mad_synth_create();
|
|
|
|
|
|
|
|
EMSCRIPTEN_BINDINGS(jsmad) {
|
|
enum_<mad_layer>("mad_layer")
|
|
.value("MAD_LAYER_I", MAD_LAYER_I)
|
|
.value("MAD_LAYER_II", MAD_LAYER_II)
|
|
.value("MAD_LAYER_III", MAD_LAYER_III);
|
|
|
|
enum_<mad_mode>("mad_mode")
|
|
.value("MAD_MODE_DUAL_CHANNEL", MAD_MODE_DUAL_CHANNEL)
|
|
.value("MAD_MODE_JOINT_STEREO", MAD_MODE_JOINT_STEREO)
|
|
.value("MAD_MODE_SINGLE_CHANNEL", MAD_MODE_SINGLE_CHANNEL)
|
|
.value("MAD_MODE_STEREO", MAD_MODE_STEREO);
|
|
|
|
enum_<mad_emphasis>("mad_emphasis")
|
|
.value("MAD_EMPHASIS_50_15_US", MAD_EMPHASIS_50_15_US)
|
|
.value("MAD_EMPHASIS_CCITT_J_17", MAD_EMPHASIS_CCITT_J_17)
|
|
.value("MAD_EMPHASIS_NONE", MAD_EMPHASIS_NONE)
|
|
.value("MAD_EMPHASIS_RESERVED", MAD_EMPHASIS_RESERVED);
|
|
|
|
enum_<mad_error>("mad_error")
|
|
.value("MAD_ERROR_NONE", MAD_ERROR_NONE) /* no error */
|
|
|
|
.value("MAD_ERROR_BUFLEN", MAD_ERROR_BUFLEN) /* input buffer too small (or EOF) */
|
|
.value("MAD_ERROR_BUFPTR", MAD_ERROR_BUFPTR) /* invalid (null) buffer pointer */
|
|
|
|
.value("MAD_ERROR_NOMEM", MAD_ERROR_NOMEM) /* not enough memory */
|
|
|
|
.value("MAD_ERROR_LOSTSYNC", MAD_ERROR_LOSTSYNC) /* lost synchronization */
|
|
.value("MAD_ERROR_BADLAYER", MAD_ERROR_BADLAYER) /* reserved header layer value */
|
|
.value("MAD_ERROR_BADBITRATE", MAD_ERROR_BADBITRATE) /* forbidden bitrate value */
|
|
.value("MAD_ERROR_BADSAMPLERATE", MAD_ERROR_BADSAMPLERATE) /* reserved sample frequency value */
|
|
.value("MAD_ERROR_BADEMPHASIS", MAD_ERROR_BADEMPHASIS) /* reserved emphasis value */
|
|
|
|
.value("MAD_ERROR_BADCRC", MAD_ERROR_BADCRC) /* CRC check failed */
|
|
.value("MAD_ERROR_BADBITALLOC", MAD_ERROR_BADBITALLOC) /* forbidden bit allocation value */
|
|
.value("MAD_ERROR_BADSCALEFACTOR", MAD_ERROR_BADSCALEFACTOR)/* bad scalefactor index */
|
|
.value("MAD_ERROR_BADMODE", MAD_ERROR_BADMODE) /* bad bitrate/mode combination */
|
|
.value("MAD_ERROR_BADFRAMELEN", MAD_ERROR_BADFRAMELEN) /* bad frame length */
|
|
.value("MAD_ERROR_BADBIGVALUES", MAD_ERROR_BADBIGVALUES) /* bad big_values count */
|
|
.value("MAD_ERROR_BADBLOCKTYPE", MAD_ERROR_BADBLOCKTYPE) /* reserved block_type */
|
|
.value("MAD_ERROR_BADSCFSI", MAD_ERROR_BADSCFSI) /* bad scalefactor selection info */
|
|
.value("MAD_ERROR_BADDATAPTR", MAD_ERROR_BADDATAPTR) /* bad main_data_begin pointer */
|
|
.value("MAD_ERROR_BADPART3LEN", MAD_ERROR_BADPART3LEN) /* bad audio data length */
|
|
.value("MAD_ERROR_BADHUFFTABLE", MAD_ERROR_BADHUFFTABLE) /* bad Huffman table select */
|
|
.value("MAD_ERROR_BADHUFFDATA", MAD_ERROR_BADHUFFDATA) /* Huffman data overrun */
|
|
.value("MAD_ERROR_BADSTEREO", MAD_ERROR_BADSTEREO); /* incompatible block_type for JS */
|
|
|
|
class_<mad_header>("mad_header");
|
|
class_<MadHeader, base<mad_header>>("MadHeader")
|
|
.constructor(&mad_header_create, allow_raw_pointers())
|
|
.property("layer", &MadHeader::getLayer, &MadHeader::setLayer)
|
|
.property("mode_extension", &MadHeader::getMode_extension, &MadHeader::setMode_extension)
|
|
.property("mode", &MadHeader::getMode, &MadHeader::setMode)
|
|
.property("emphasis", &MadHeader::getEmphasis, &MadHeader::setEmphasis)
|
|
.property("bitrate", &MadHeader::getBitrate, &MadHeader::setBitrate)
|
|
.property("samplerate", &MadHeader::getSamplerate, &MadHeader::setSamplerate)
|
|
.property("crc_check", &MadHeader::getCrc_check, &MadHeader::setCrc_check)
|
|
.property("crc_target", &MadHeader::getCrc_target, &MadHeader::setCrc_target)
|
|
.property("flags", &MadHeader::getFlags, &MadHeader::setFlags)
|
|
.property("private_bits", &MadHeader::getPrivate_bits, &MadHeader::setPrivate_bits)
|
|
.property("duration", &MadHeader::getDuration, &MadHeader::setDuration);
|
|
|
|
function("mad_header_init", &mad_header_init, allow_raw_pointers());
|
|
|
|
class_<mad_frame>("mad_frame");
|
|
class_<MadFrame, base<mad_frame>>("MadFrame")
|
|
.constructor(&mad_frame_create, allow_raw_pointers())
|
|
.property("options", &MadFrame::getOptions, &MadFrame::setOptions)
|
|
.function("header", &MadFrame::header, allow_raw_pointers())
|
|
.function("sbsample", &MadFrame::getSbsample)
|
|
.function("overlap", &MadFrame::getOverlap)
|
|
.function("decode", &MadFrame::decode, allow_raw_pointers());
|
|
|
|
value_object<mad_timer_t>("mad_timer_t")
|
|
.field("seconds", &mad_timer_t::seconds)
|
|
.field("fraction", &mad_timer_t::fraction);
|
|
|
|
function("mad_frame_init", &mad_frame_init, allow_raw_pointers());
|
|
function("mad_frame_finish", &mad_frame_finish, allow_raw_pointers());
|
|
|
|
class_<mad_bitptr>("mad_bitptr");
|
|
|
|
class_<mad_stream>("mad_stream");
|
|
class_<MadStream, base<mad_stream>>("MadStream")
|
|
.constructor(&mad_stream_create, allow_raw_pointers())
|
|
.property("sync", &MadStream::getSync, &MadStream::setSync)
|
|
.property("freerate", &MadStream::getFreeRate, &MadStream::setFreeRate)
|
|
.property("options", &MadStream::getOptions, &MadStream::setOptions)
|
|
.property("error", &MadStream::getError, &MadStream::setError)
|
|
.property("mdLen", &MadStream::getMdLen, &MadStream::setMdLen)
|
|
.function("mainData", &MadStream::mainData)
|
|
.function("setBuffer", &MadStream::setBuffer, allow_raw_pointers());
|
|
|
|
function("mad_stream_init", &mad_stream_init, allow_raw_pointers());
|
|
function("mad_stream_finish", &mad_stream_finish, allow_raw_pointers());
|
|
function("mad_stream_buffer", &mad_stream_buffer, allow_raw_pointers());
|
|
function("mad_stream_sync", &mad_stream_sync, allow_raw_pointers());
|
|
|
|
class_<mad_pcm>("mad_pcm");
|
|
class_<MadPCM, base<mad_pcm>>("MadPCM")
|
|
.constructor(&mad_pcm_create, allow_raw_pointers())
|
|
.property("samplerate", &MadPCM::getSamplerate, &MadPCM::setSamplerate)
|
|
.property("channels", &MadPCM::getChannels, &MadPCM::setChannels)
|
|
.property("length", &MadPCM::getLength, &MadPCM::setLength)
|
|
.function("samples", &MadPCM::samples, allow_raw_pointers());
|
|
|
|
function("mad_synth_init", &mad_synth_init, allow_raw_pointers());
|
|
function("mad_synth_frame", &mad_synth_frame, allow_raw_pointers());
|
|
|
|
class_<mad_synth>("mad_synth");
|
|
class_<MadSynth, base<mad_synth>>("MadSynth")
|
|
.constructor(&mad_synth_create, allow_raw_pointers())
|
|
.property("phase", &MadSynth::getPhase, &MadSynth::setPhase)
|
|
.function("pcm", &MadSynth::pcm, allow_raw_pointers())
|
|
.function("frame", &MadSynth::frame, allow_raw_pointers());
|
|
|
|
class_<Decoder>("Decoder")
|
|
.constructor<>()
|
|
.function("addFragment", &Decoder::addFragment)
|
|
.function("hasMore", &Decoder::hasMore)
|
|
.function("framesLeft", &Decoder::framesLeft)
|
|
.function("decode", &Decoder::decode);
|
|
}
|
|
|
|
#endif // WRAPPER_H
|