diff options
Diffstat (limited to 'modules/chibi')
49 files changed, 12890 insertions, 0 deletions
diff --git a/modules/chibi/SCsub b/modules/chibi/SCsub new file mode 100644 index 0000000000..e39554977a --- /dev/null +++ b/modules/chibi/SCsub @@ -0,0 +1,7 @@ +Import('env') +Import('env_modules') + +env_chibi = env_modules.Clone() + +# Godot source files +env_chibi.add_source_files(env.modules_sources, "*.cpp") diff --git a/modules/chibi/config.py b/modules/chibi/config.py new file mode 100644 index 0000000000..368e97e152 --- /dev/null +++ b/modules/chibi/config.py @@ -0,0 +1,6 @@ + +def can_build(platform): + return True + +def configure(env): + pass diff --git a/modules/chibi/cp_config.h b/modules/chibi/cp_config.h new file mode 100644 index 0000000000..2ad704ace7 --- /dev/null +++ b/modules/chibi/cp_config.h @@ -0,0 +1,52 @@ +/*************************************************************************/ +/* cp_config.h */ +/*************************************************************************/ +/* This file is part of: */ +/* GODOT ENGINE */ +/* http://www.godotengine.org */ +/*************************************************************************/ +/* Copyright (c) 2007-2016 Juan Linietsky, Ariel Manzur. */ +/* */ +/* Permission is hereby granted, free of charge, to any person obtaining */ +/* a copy of this software and associated documentation files (the */ +/* "Software"), to deal in the Software without restriction, including */ +/* without limitation the rights to use, copy, modify, merge, publish, */ +/* distribute, sublicense, and/or sell copies of the Software, and to */ +/* permit persons to whom the Software is furnished to do so, subject to */ +/* the following conditions: */ +/* */ +/* The above copyright notice and this permission notice shall be */ +/* included in all copies or substantial portions of the Software. */ +/* */ +/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */ +/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */ +/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/ +/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */ +/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */ +/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */ +/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ +/*************************************************************************/ +#ifndef CP_CONFIG_H +#define CP_CONFIG_H + + +#include "typedefs.h" +#include "error_macros.h" +#include "math_funcs.h" +#include "os/memory.h" +#include "os/copymem.h" + +#define CP_PRINTERR(m_err) ERR_PRINT(m_err) +#define CP_ERR_COND(m_cond) ERR_FAIL_COND(m_cond) +#define CP_ERR_COND_V(m_cond,m_ret) ERR_FAIL_COND_V(m_cond,m_ret) +#define CP_FAIL_INDEX(m_index,m_size) ERR_FAIL_INDEX(m_index,m_size) +#define CP_FAIL_INDEX_V(m_index,m_size,m_ret) ERR_FAIL_INDEX_V(m_index,m_size,m_ret) +#define cp_intabs(m_val) ABS(m_val) + +#define CP_ALLOC(m_mem) memalloc(m_mem) +#define CP_REALLOC(m_mem,m_size) memrealloc(m_mem,m_size) +#define CP_FREE(m_mem) memfree(m_mem) + +#define cp_memzero(m_mem,m_size) zeromem(m_mem,m_size) + +#endif // CP_CONFIG_H diff --git a/modules/chibi/cp_envelope.cpp b/modules/chibi/cp_envelope.cpp new file mode 100644 index 0000000000..9892b6d4b0 --- /dev/null +++ b/modules/chibi/cp_envelope.cpp @@ -0,0 +1,369 @@ +/*************************************************************************/ +/* cp_envelope.cpp */ +/*************************************************************************/ +/* This file is part of: */ +/* GODOT ENGINE */ +/* http://www.godotengine.org */ +/*************************************************************************/ +/* Copyright (c) 2007-2016 Juan Linietsky, Ariel Manzur. */ +/* */ +/* Permission is hereby granted, free of charge, to any person obtaining */ +/* a copy of this software and associated documentation files (the */ +/* "Software"), to deal in the Software without restriction, including */ +/* without limitation the rights to use, copy, modify, merge, publish, */ +/* distribute, sublicense, and/or sell copies of the Software, and to */ +/* permit persons to whom the Software is furnished to do so, subject to */ +/* the following conditions: */ +/* */ +/* The above copyright notice and this permission notice shall be */ +/* included in all copies or substantial portions of the Software. */ +/* */ +/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */ +/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */ +/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/ +/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */ +/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */ +/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */ +/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ +/*************************************************************************/ +#include "cp_envelope.h" + + +CPEnvelope::CPEnvelope() { + + + reset(); +} + +void CPEnvelope::reset() { + + + + on=false; + carry=false; + loop_on=false; + loop_begin_node=0; + loop_end_node=0; + sustain_loop_on=false; + sustain_loop_begin_node=0; + sustain_loop_end_node=0; + node_count=0; + +} + +int CPEnvelope::get_height_at_pos(int pos) { + + if (node_count && pos>node[node_count-1].tick_offset) + return node[node_count-1].value; + + int begin_x,begin_y; + int end_x,end_y,xdif; + int count=0; + int limit=-1; + + if (node_count<2) return NO_POINT; + + while ((count<node_count) && (limit==-1)) { + + if (node[count].tick_offset>=pos) limit=count; + count++; + } + + if (pos==0) return node[0].value; + + if (limit==-1) return NO_POINT; + + begin_x=node[limit-1].tick_offset; + end_x=node[limit].tick_offset; + begin_y=node[limit-1].value; + end_y=node[limit].value; + + xdif=end_x-begin_x; + return begin_y+((pos-begin_x)*(end_y-begin_y))/(xdif?xdif:1); +} + +/* +int CPEnvelope::get_fx_height_at_pos(int pos) { + + if (node_count && pos>node[node_count-1].tick_offset) + return node[node_count-1].value<<FX_HEIGHT_BITS; + + int begin_x,begin_y; + int end_x,end_y,xdif; + int count=0; + int limit=-1; + + if (node_count<2) return NO_POINT; + + while ((count<node_count) && (limit==-1)) { + + if (node[count].tick_offset>=pos) limit=count; + count++; + } + + if (pos==0) return node[0].value<<FX_HEIGHT_BITS; + + if (limit==-1) return NO_POINT; + + begin_x=node[limit-1].tick_offset; + end_x=node[limit].tick_offset; + begin_y=node[limit-1].value; + end_y=node[limit].value; + + xdif=end_x-begin_x; + return (begin_y<<FX_HEIGHT_BITS)+((pos-begin_x)*(end_y-begin_y)*(int)(1<<FX_HEIGHT_BITS))/(xdif?xdif:1); +} +*/ + +float CPEnvelope::get_interp_height_at_pos(float pos) { + + if (node_count && pos>node[node_count-1].tick_offset) + return node[node_count-1].value; + + int begin_x,begin_y; + int end_x,end_y,xdif; + int count=0; + int limit=-1; + + if (node_count<2) return NO_POINT; + + while ((count<node_count) && (limit==-1)) { + + if (node[count].tick_offset>=pos) limit=count; + count++; + } + + if (pos==0) return node[0].value; + + if (limit==-1) return NO_POINT; + + begin_x=node[limit-1].tick_offset; + end_x=node[limit].tick_offset; + begin_y=node[limit-1].value; + end_y=node[limit].value; + + xdif=end_x-begin_x; + return begin_y+((pos-begin_x)*(end_y-begin_y))/(xdif?xdif:1); +} + +void CPEnvelope::set_position(int p_node,int p_x,int p_y) { + + if (p_node>=node_count) return; + + + + if (p_node==0) { + + p_x=0; + + } else if (p_x<=node[p_node-1].tick_offset) { + + p_x=node[p_node-1].tick_offset+1; + + } else if ((p_node<(node_count-1)) && (p_x>=node[p_node+1].tick_offset)) { + + p_x=node[p_node+1].tick_offset-1; + } + + if (p_x>=9999) p_x=9999; + + if (p_y>max_value) p_y=max_value; + if (p_y<min_value) p_y=min_value; + + + node[p_node].tick_offset=p_x; + node[p_node].value=p_y; + + + +} + +int CPEnvelope::add_position(int p_x,int p_y,bool p_move_loops) { + + if (node_count==MAX_POINTS) return -1; + + + int i,new_node; + + // if this is assigning an existing node, let's quit. + for (i=0;i<node_count;i++) if (p_x==node[i].tick_offset) return -1; + + + i=0; + while ((i<node_count) && (p_x>=node[i].tick_offset)) i++; + + new_node=i; + node_count++; + + if (p_move_loops) { + if (loop_begin_node>=new_node) loop_begin_node++; + if (loop_end_node>=new_node) loop_end_node++; + if (sustain_loop_begin_node>=new_node) sustain_loop_begin_node++; + if (sustain_loop_end_node>=new_node) sustain_loop_end_node++; + } + for (i=node_count-1;i>new_node;i--) node[i]=node[i-1]; + + + + set_position(new_node,p_x,p_y); + + + + return new_node; + +} + +void CPEnvelope::set_loop_begin(int pos) { + + if ((pos<0) || (pos>=node_count)) return; + + + + loop_begin_node=pos; + + if (loop_end_node<loop_begin_node) loop_end_node=loop_begin_node; + + + +} + +void CPEnvelope::set_loop_end(int pos) { + + if ((pos<0) || (pos>=node_count)) return; + + + + loop_end_node=pos; + + if (loop_end_node<loop_begin_node) loop_begin_node=loop_end_node; + + + + +} + + +void CPEnvelope::set_sustain_loop_begin(int pos) { + + if ((pos<0) || (pos>=node_count)) return; + + + + sustain_loop_begin_node=pos; + + if (sustain_loop_end_node<sustain_loop_begin_node) sustain_loop_end_node=sustain_loop_begin_node; + + + +} + +void CPEnvelope::set_sustain_loop_end(int pos) { + + if ((pos<0) || (pos>=node_count)) return; + + + + sustain_loop_end_node=pos; + + if (sustain_loop_end_node<sustain_loop_begin_node) sustain_loop_begin_node=sustain_loop_end_node; + + + +} + +void CPEnvelope::set_loop_enabled(bool p_enabled) { + + loop_on=p_enabled; +} +bool CPEnvelope::is_loop_enabled() { + + return loop_on; +} + + +void CPEnvelope::set_sustain_loop_enabled(bool p_enabled) { + + sustain_loop_on=p_enabled; +} +bool CPEnvelope::is_sustain_loop_enabled() { + + return sustain_loop_on; +} + +void CPEnvelope::del_position(int p_node) { + + if ((node_count<3) || (p_node<=0) || (p_node>=node_count)) return; + + + + int i; + + if (loop_begin_node>=p_node) loop_begin_node--; + if (loop_end_node>=p_node) loop_end_node--; + if (sustain_loop_begin_node>=p_node) sustain_loop_begin_node--; + if (sustain_loop_end_node>=p_node) sustain_loop_end_node--; + + for (i=p_node;i<node_count-1;i++) node[i]=node[i+1]; + + node_count--; + + + +} + +uint8_t CPEnvelope::get_loop_begin() { + + + return loop_begin_node; +} +uint8_t CPEnvelope::get_loop_end() { + + return loop_end_node; +} + +uint8_t CPEnvelope::get_sustain_loop_begin() { + + + return sustain_loop_begin_node; +} +uint8_t CPEnvelope::get_sustain_loop_end() { + + return sustain_loop_end_node; +} + + + +void CPEnvelope::set_enabled(bool p_enabled) { + + on=p_enabled; +} + +bool CPEnvelope::is_enabled() { + + return on; +} + +void CPEnvelope::set_carry_enabled(bool p_enabled) { + + carry=p_enabled; +} +bool CPEnvelope::is_carry_enabled() { + + return carry; +} + +uint8_t CPEnvelope::get_node_count() { + + return node_count; +} + +const CPEnvelope::Point& CPEnvelope::get_node(int p_idx) { + + if (p_idx<0 || p_idx>=node_count) + return node[node_count-1]; + + return node[p_idx]; + +} + + diff --git a/modules/chibi/cp_envelope.h b/modules/chibi/cp_envelope.h new file mode 100644 index 0000000000..d1ada53f7d --- /dev/null +++ b/modules/chibi/cp_envelope.h @@ -0,0 +1,129 @@ +/*************************************************************************/ +/* cp_envelope.h */ +/*************************************************************************/ +/* This file is part of: */ +/* GODOT ENGINE */ +/* http://www.godotengine.org */ +/*************************************************************************/ +/* Copyright (c) 2007-2016 Juan Linietsky, Ariel Manzur. */ +/* */ +/* Permission is hereby granted, free of charge, to any person obtaining */ +/* a copy of this software and associated documentation files (the */ +/* "Software"), to deal in the Software without restriction, including */ +/* without limitation the rights to use, copy, modify, merge, publish, */ +/* distribute, sublicense, and/or sell copies of the Software, and to */ +/* permit persons to whom the Software is furnished to do so, subject to */ +/* the following conditions: */ +/* */ +/* The above copyright notice and this permission notice shall be */ +/* included in all copies or substantial portions of the Software. */ +/* */ +/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */ +/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */ +/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/ +/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */ +/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */ +/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */ +/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ +/*************************************************************************/ + +#ifndef CP_ENVELOPE_H +#define CP_ENVELOPE_H + +#include "cp_config.h" + +/**envelope? + *@author Juan Linietsky + */ + +/****************************** + envelope.h + ---------- + +Proovides an envelope, and basic functions +for it that can be used for both player +and interface +********************************/ + + +class CPEnvelope { + enum { + + MAX_POINTS=25 + }; + + struct Point { + + uint16_t tick_offset; + int16_t value; + }; + + Point node[MAX_POINTS]; + + int8_t node_count; + + bool on; + bool carry; + + bool loop_on; + + uint8_t loop_begin_node; + uint8_t loop_end_node; + + bool sustain_loop_on; + uint8_t sustain_loop_begin_node; + uint8_t sustain_loop_end_node; + + + int8_t max_value; + int8_t min_value; + + +public: + enum { + + NO_POINT=-5000, + }; + + void set_max(int8_t p_max) { max_value=p_max; } + int8_t get_max() { return max_value; } + void set_min(int8_t p_min) { min_value=p_min; } + int8_t get_min() { return min_value; } + + uint8_t get_node_count(); + const Point& get_node(int p_idx); + + void set_position(int p_node,int p_x,int p_y); + int add_position(int p_x,int p_y,bool p_move_loops=true); + void del_position(int p_node); + + void set_loop_enabled(bool p_enabled); + bool is_loop_enabled(); + void set_loop_begin(int pos); + void set_loop_end(int pos); + uint8_t get_loop_begin(); + uint8_t get_loop_end(); + + void set_sustain_loop_enabled(bool p_enabled); + bool is_sustain_loop_enabled(); + void set_sustain_loop_begin(int pos); + void set_sustain_loop_end(int pos); + uint8_t get_sustain_loop_begin(); + uint8_t get_sustain_loop_end(); + + void set_enabled(bool p_enabled); + bool is_enabled(); + + void set_carry_enabled(bool p_enabled); + bool is_carry_enabled(); + + void reset(); + int get_height_at_pos(int pos); + float get_interp_height_at_pos(float pos); + + + CPEnvelope(); + +}; + +#endif diff --git a/modules/chibi/cp_file_access_wrapper.h b/modules/chibi/cp_file_access_wrapper.h new file mode 100644 index 0000000000..5b361c0ea8 --- /dev/null +++ b/modules/chibi/cp_file_access_wrapper.h @@ -0,0 +1,96 @@ +/*************************************************************************/ +/* cp_file_access_wrapper.h */ +/*************************************************************************/ +/* This file is part of: */ +/* GODOT ENGINE */ +/* http://www.godotengine.org */ +/*************************************************************************/ +/* Copyright (c) 2007-2016 Juan Linietsky, Ariel Manzur. */ +/* */ +/* Permission is hereby granted, free of charge, to any person obtaining */ +/* a copy of this software and associated documentation files (the */ +/* "Software"), to deal in the Software without restriction, including */ +/* without limitation the rights to use, copy, modify, merge, publish, */ +/* distribute, sublicense, and/or sell copies of the Software, and to */ +/* permit persons to whom the Software is furnished to do so, subject to */ +/* the following conditions: */ +/* */ +/* The above copyright notice and this permission notice shall be */ +/* included in all copies or substantial portions of the Software. */ +/* */ +/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */ +/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */ +/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/ +/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */ +/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */ +/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */ +/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ +/*************************************************************************/ +#ifndef CP_FILE_ACCESS_WRAPPER_H +#define CP_FILE_ACCESS_WRAPPER_H + +#include "cp_config.h" + +class CPFileAccessWrapper { +public: + + enum ModeFlags { + + READ=1, + WRITE=2, + READ_WRITE=3, + }; + + enum Error { + + OK, + ERROR_FILE_NOT_FOUND, + ERROR_FILE_BAD_DRIVE, + ERROR_FILE_BAD_PATH, + ERROR_FILE_NO_PERMISSION, + ERROR_ALREADY_IN_USE, + ERROR_INVALID_PARAMETERS, + ERROR_OPENING_FILE, + ERROR_READING_FILE, + ERROR_WRITING_FILE + }; + + virtual Error open(const char *p_filename, int p_mode_flags)=0; + virtual void close()=0; + + virtual void seek(uint32_t p_position)=0; + virtual void seek_end()=0; + virtual uint32_t get_pos()=0; + + virtual bool eof_reached()=0; + + virtual uint8_t get_byte()=0; + virtual void get_byte_array(uint8_t *p_dest,int p_elements)=0; + virtual void get_word_array(uint16_t *p_dest,int p_elements)=0; + + virtual uint16_t get_word()=0; + virtual uint32_t get_dword()=0; + + // use this for files WRITTEN in _big_ endian machines (ie, amiga/mac) + // It's not about the current CPU type but file formats. + // this flags get reset to false (little endian) on each open + virtual void set_endian_conversion(bool p_swap)=0; + virtual bool is_open()=0; + + virtual Error get_error()=0; + + virtual void store_byte(uint8_t p_dest)=0; + virtual void store_byte_array(const uint8_t *p_dest,int p_elements)=0; + + virtual void store_word(uint16_t p_dest)=0; + virtual void store_dword(uint32_t p_dest)=0; + + + + virtual ~CPFileAccessWrapper(){} + +}; + + + +#endif diff --git a/modules/chibi/cp_instrument.cpp b/modules/chibi/cp_instrument.cpp new file mode 100644 index 0000000000..7a732e33a4 --- /dev/null +++ b/modules/chibi/cp_instrument.cpp @@ -0,0 +1,344 @@ +/*************************************************************************/ +/* cp_instrument.cpp */ +/*************************************************************************/ +/* This file is part of: */ +/* GODOT ENGINE */ +/* http://www.godotengine.org */ +/*************************************************************************/ +/* Copyright (c) 2007-2016 Juan Linietsky, Ariel Manzur. */ +/* */ +/* Permission is hereby granted, free of charge, to any person obtaining */ +/* a copy of this software and associated documentation files (the */ +/* "Software"), to deal in the Software without restriction, including */ +/* without limitation the rights to use, copy, modify, merge, publish, */ +/* distribute, sublicense, and/or sell copies of the Software, and to */ +/* permit persons to whom the Software is furnished to do so, subject to */ +/* the following conditions: */ +/* */ +/* The above copyright notice and this permission notice shall be */ +/* included in all copies or substantial portions of the Software. */ +/* */ +/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */ +/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */ +/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/ +/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */ +/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */ +/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */ +/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ +/*************************************************************************/ +#include "cp_instrument.h" +#include "cp_song.h" +#include "cp_note.h" + + + +const char *CPInstrument::get_name() { + + return name; + +} +void CPInstrument::set_name(const char *p_name) { + + + if (p_name==NULL) { + name[0]=0; + return; + } + + + bool done=false; + for (int i=0;i<MAX_NAME_LEN;i++) { + + + name[i]=done?0:p_name[i]; + if (!done && p_name[i]==0) + done=true; + } + + name[MAX_NAME_LEN-1]=0; /* just in case */ + + +} + +void CPInstrument::set_sample_number(uint8_t p_note,uint8_t p_sample_id) { + + CP_ERR_COND(p_note>=CPNote::NOTES); + CP_ERR_COND(p_sample_id>CPSong::MAX_SAMPLES && p_sample_id!=CPNote::EMPTY); + data.sample_number[p_note]=p_sample_id; + + +} +uint8_t CPInstrument::get_sample_number(uint8_t p_note) { + + CP_ERR_COND_V(p_note>=CPNote::NOTES,0); + return data.sample_number[p_note]; +} + +void CPInstrument::set_note_number(uint8_t p_note,uint8_t p_note_id) { + + CP_ERR_COND(p_note>=CPNote::NOTES); + CP_ERR_COND(p_note_id>=CPNote::NOTES && p_note_id!=CPNote::EMPTY); + data.note_number[p_note]=p_note_id; + +} +uint8_t CPInstrument::get_note_number(uint8_t p_note) { + + CP_ERR_COND_V(p_note>=CPNote::NOTES,0); + return data.note_number[p_note]; + +} + +void CPInstrument::set_NNA_type(NNA_Type p_NNA_type) { + + data.NNA_type=p_NNA_type; +} +CPInstrument::NNA_Type CPInstrument::get_NNA_type() { + + return data.NNA_type; +} + +void CPInstrument::set_DC_type(DC_Type p_DC_type) { + + data.DC_type=p_DC_type; +} +CPInstrument::DC_Type CPInstrument::get_DC_type() { + + return data.DC_type; + +} + +void CPInstrument::set_DC_action(DC_Action p_DC_action) { + + data.DC_action=p_DC_action; +} +CPInstrument::DC_Action CPInstrument::get_DC_action() { + + return data.DC_action; +} + +/* Volume */ + +void CPInstrument::set_volume_global_amount(uint8_t p_amount) { + + CP_ERR_COND(p_amount>MAX_VOLUME); + data.volume.global_amount=p_amount; + +} +uint8_t CPInstrument::get_volume_global_amount() { + + return data.volume.global_amount; +} + +void CPInstrument::set_volume_fadeout(uint16_t p_amount) { + CP_ERR_COND(p_amount>MAX_FADEOUT); + data.volume.fadeout=p_amount; +} +uint16_t CPInstrument::get_volume_fadeout() { + + return data.volume.fadeout; +} +void CPInstrument::set_volume_random_variation(uint8_t p_amount) { + + CP_ERR_COND(p_amount>MAX_VOLUME_RANDOM); + data.volume.random_variation=p_amount; +} +uint8_t CPInstrument::get_volume_random_variation() { + + return data.volume.random_variation; +} + +/* Panning */ + +void CPInstrument::set_pan_default_amount(uint8_t p_amount) { + + CP_ERR_COND(p_amount>MAX_PAN); + data.pan.default_amount=p_amount; +} +uint8_t CPInstrument::get_pan_default_amount() { + + return data.pan.default_amount; +} + +void CPInstrument::set_pan_default_enabled(bool p_enabled) { + + data.pan.use_default=p_enabled; +} +bool CPInstrument::is_pan_default_enabled() { + + return data.pan.use_default; + +} + +void CPInstrument::set_pan_pitch_separation(int8_t p_amount) { + + CP_ERR_COND(p_amount<-32); + CP_ERR_COND(p_amount>32); + data.pan.pitch_separation=p_amount; +} +int8_t CPInstrument::get_pan_pitch_separation() { + + return data.pan.pitch_separation; +} + +void CPInstrument::set_pan_pitch_center(uint8_t p_amount) { + + CP_ERR_COND(p_amount>=CPNote::NOTES); + data.pan.pitch_center=p_amount; +} +uint8_t CPInstrument::get_pan_pitch_center() { + + return data.pan.pitch_center; +} + +void CPInstrument::set_pan_random_variation(uint8_t p_amount) { + + CP_ERR_COND(p_amount>MAX_PAN_RANDOM); + data.pan.random_variation=p_amount; +} +uint8_t CPInstrument::get_pan_random_variation() { + + return data.pan.random_variation; +} + +/* Pitch / Filter */ + +void CPInstrument::set_pitch_use_as_filter(bool p_enabled) { + + data.pitch.use_as_filter=p_enabled; +} +bool CPInstrument::is_pitch_use_as_filter() { + + return data.pitch.use_as_filter; +} + +void CPInstrument::set_filter_use_default_cutoff(bool p_enabled) { + + data.pitch.use_default_cutoff=p_enabled; + +} +bool CPInstrument::filter_use_default_cutoff() { + + return data.pitch.use_default_cutoff; +} + +void CPInstrument::set_filter_default_cutoff(uint8_t p_amount) { + + CP_ERR_COND(p_amount>MAX_FILTER_CUTOFF); + data.pitch.default_cutoff=p_amount; +} +uint8_t CPInstrument::get_filter_default_cutoff() { + + return data.pitch.default_cutoff; +} + +void CPInstrument::set_filter_use_default_resonance(bool p_enabled) { + + data.pitch.use_default_resonance=p_enabled; +} +bool CPInstrument::filter_use_default_resonance() { + + return data.pitch.use_default_resonance; +} + +void CPInstrument::set_filter_default_resonance(uint8_t p_amount) { + + CP_ERR_COND(p_amount>MAX_FILTER_RESONANCE); + data.pitch.default_resonance=p_amount; + +} +uint8_t CPInstrument::get_filter_default_resonance() { + + return data.pitch.default_resonance; +} + +/* Envelopes */ + + +CPEnvelope* CPInstrument::get_volume_envelope() { + + return &data.volume.envelope; +} +CPEnvelope* CPInstrument::get_pan_envelope() { + + return &data.pan.envelope; +} +CPEnvelope* CPInstrument::get_pitch_filter_envelope() { + + return &data.pitch.envelope; + + +} + + +void CPInstrument::reset() { + + name[0]=0; + + data.NNA_type=NNA_NOTE_CUT; + data.DC_action=DCA_NOTE_CUT; + data.DC_type=DCT_DISABLED; + + for (int i=0;i<CPNote::NOTES;i++) { + + data.sample_number[i]=CPNote::EMPTY; + data.note_number[i]=i; + } + + data.volume.envelope.reset(); + data.volume.envelope.set_max(64); + data.volume.envelope.set_min(0); + data.volume.envelope.add_position(0,64,false); + data.volume.envelope.add_position(30,64,false); + + data.volume.global_amount=MAX_VOLUME; + data.volume.fadeout=0; + data.volume.random_variation=0; + + data.pan.envelope.reset(); + data.pan.envelope.set_max(32); + data.pan.envelope.set_min(-32); + data.pan.envelope.add_position(0,0,false); + data.pan.envelope.add_position(30,0,false); + + data.pan.default_amount=32; + data.pan.pitch_center=48; + data.pan.pitch_separation=0; + data.pan.use_default=false; + data.pan.random_variation=0; + + + data.pitch.envelope.reset(); + data.pitch.envelope.set_max(32); + data.pitch.envelope.set_min(-32); + data.pitch.envelope.add_position(0,0,false); + data.pitch.envelope.add_position(30,0,false); + data.pitch.use_as_filter=false; + data.pitch.use_default_cutoff=false; + data.pitch.use_default_resonance=false; + data.pitch.default_cutoff=0; + data.pitch.default_resonance=0; + +} + +bool CPInstrument::is_empty() { + + bool has_sample=false; + + for (int i=0;i<CPNote::NOTES;i++) { + + if (data.sample_number[i]!=CPNote::EMPTY) { + + has_sample=true; + break; + } + } + + return !has_sample; +} + +CPInstrument::CPInstrument() { + + reset(); + +} + diff --git a/modules/chibi/cp_instrument.h b/modules/chibi/cp_instrument.h new file mode 100644 index 0000000000..d8eb8333ee --- /dev/null +++ b/modules/chibi/cp_instrument.h @@ -0,0 +1,219 @@ +/*************************************************************************/ +/* cp_instrument.h */ +/*************************************************************************/ +/* This file is part of: */ +/* GODOT ENGINE */ +/* http://www.godotengine.org */ +/*************************************************************************/ +/* Copyright (c) 2007-2016 Juan Linietsky, Ariel Manzur. */ +/* */ +/* Permission is hereby granted, free of charge, to any person obtaining */ +/* a copy of this software and associated documentation files (the */ +/* "Software"), to deal in the Software without restriction, including */ +/* without limitation the rights to use, copy, modify, merge, publish, */ +/* distribute, sublicense, and/or sell copies of the Software, and to */ +/* permit persons to whom the Software is furnished to do so, subject to */ +/* the following conditions: */ +/* */ +/* The above copyright notice and this permission notice shall be */ +/* included in all copies or substantial portions of the Software. */ +/* */ +/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */ +/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */ +/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/ +/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */ +/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */ +/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */ +/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ +/*************************************************************************/ +#ifndef CP_INSTRUMENT_H +#define CP_INSTRUMENT_H + + +#include "cp_config.h" +#include "cp_note.h" +#include "cp_envelope.h" + +class CPInstrument { +public: + + + enum NNA_Type { + + NNA_NOTE_CUT, + NNA_NOTE_CONTINUE, + NNA_NOTE_OFF, + NNA_NOTE_FADE + }; + + enum DC_Type { + + DCT_DISABLED, + DCT_NOTE, + DCT_SAMPLE, + DCT_INSTRUMENT + }; + + enum DC_Action + { + + DCA_NOTE_CUT, + DCA_NOTE_OFF, + DCA_NOTE_FADE, + }; + + enum EnvelopeType { + VOLUME_ENVELOPE, + PAN_ENVELOPE, + PITCH_ENVELOPE + }; + + + enum { + MAX_NAME_LEN=26, + MAX_ENVELOPE_NODES=25, + ENVELOPE_FRAC_BITS=8, + MAX_VOLUME=128, + MAX_FADEOUT=256, + MAX_PAN=128, + MAX_VOLUME_RANDOM=100, + MAX_PAN_RANDOM=64, //what did this guy have inside his head? + + MAX_FILTER_CUTOFF=127, + MAX_FILTER_RESONANCE=127 + + }; + + + struct Data { + + + uint8_t sample_number[CPNote::NOTES]; + uint8_t note_number[CPNote::NOTES]; + + NNA_Type NNA_type; + DC_Type DC_type; + DC_Action DC_action; + + struct Volume { + + CPEnvelope envelope; + uint8_t global_amount; + uint16_t fadeout; + uint8_t random_variation; + + } volume; + + struct Pan { + + CPEnvelope envelope; + bool use_default; + uint8_t default_amount; + int8_t pitch_separation; + uint8_t pitch_center; + uint8_t random_variation; + + } pan; + + struct Pitch { + + CPEnvelope envelope; + bool use_as_filter; + bool use_default_cutoff; + uint8_t default_cutoff; + bool use_default_resonance; + uint8_t default_resonance; + } pitch; + + }; + +private: + + + + Data data; + char name[MAX_NAME_LEN]; + +public: + + /* CPInstrument General */ + + const char *get_name(); + void set_name(const char *p_name); + + void set_sample_number(uint8_t p_note,uint8_t p_sample_id); + uint8_t get_sample_number(uint8_t p_note); + + void set_note_number(uint8_t p_note,uint8_t p_note_id); + uint8_t get_note_number(uint8_t p_note); + + void set_NNA_type(NNA_Type p_NNA_type); + NNA_Type get_NNA_type(); + + void set_DC_type(DC_Type p_DC_type); + DC_Type get_DC_type(); + + void set_DC_action(DC_Action p_DC_action); + DC_Action get_DC_action(); + + /* Volume */ + + void set_volume_global_amount(uint8_t p_amount); + uint8_t get_volume_global_amount(); + + void set_volume_fadeout(uint16_t p_amount); + uint16_t get_volume_fadeout(); + + void set_volume_random_variation(uint8_t p_amount); + uint8_t get_volume_random_variation(); + + /* Panning */ + + void set_pan_default_amount(uint8_t p_amount); + uint8_t get_pan_default_amount(); + + void set_pan_default_enabled(bool p_enabled); + bool is_pan_default_enabled(); + + void set_pan_pitch_separation(int8_t p_amount); + int8_t get_pan_pitch_separation(); + + void set_pan_pitch_center(uint8_t p_amount); + uint8_t get_pan_pitch_center(); + + void set_pan_random_variation(uint8_t p_amount); + uint8_t get_pan_random_variation(); + + /* Pitch / Filter */ + + void set_pitch_use_as_filter(bool p_enabled); + bool is_pitch_use_as_filter(); + + void set_filter_use_default_cutoff(bool p_enabled); + bool filter_use_default_cutoff(); + + void set_filter_default_cutoff(uint8_t p_amount); + uint8_t get_filter_default_cutoff(); + + void set_filter_use_default_resonance(bool p_enabled); + bool filter_use_default_resonance(); + + void set_filter_default_resonance(uint8_t p_amount); + uint8_t get_filter_default_resonance(); + + CPEnvelope* get_volume_envelope(); + CPEnvelope* get_pan_envelope(); + CPEnvelope* get_pitch_filter_envelope(); + + bool is_empty(); + + void reset(); + CPInstrument(); + +}; + + + +#endif + + diff --git a/modules/chibi/cp_loader.h b/modules/chibi/cp_loader.h new file mode 100644 index 0000000000..9d1074d1b8 --- /dev/null +++ b/modules/chibi/cp_loader.h @@ -0,0 +1,64 @@ +/*************************************************************************/ +/* cp_loader.h */ +/*************************************************************************/ +/* This file is part of: */ +/* GODOT ENGINE */ +/* http://www.godotengine.org */ +/*************************************************************************/ +/* Copyright (c) 2007-2016 Juan Linietsky, Ariel Manzur. */ +/* */ +/* Permission is hereby granted, free of charge, to any person obtaining */ +/* a copy of this software and associated documentation files (the */ +/* "Software"), to deal in the Software without restriction, including */ +/* without limitation the rights to use, copy, modify, merge, publish, */ +/* distribute, sublicense, and/or sell copies of the Software, and to */ +/* permit persons to whom the Software is furnished to do so, subject to */ +/* the following conditions: */ +/* */ +/* The above copyright notice and this permission notice shall be */ +/* included in all copies or substantial portions of the Software. */ +/* */ +/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */ +/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */ +/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/ +/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */ +/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */ +/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */ +/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ +/*************************************************************************/ +#ifndef CP_LOADER_H +#define CP_LOADER_H + + +#include "cp_song.h" +#include "cp_file_access_wrapper.h" +/** + @author Juan Linietsky <reduzio@gmail.com> +*/ +class CPLoader { + +public: + + enum Error { + FILE_OK, + FILE_UNRECOGNIZED, + FILE_CANNOT_OPEN, + FILE_CORRUPTED, + FILE_OUT_OF_MEMORY, + }; + + + virtual bool can_load_song()=0; + virtual bool can_load_sample()=0; + virtual bool can_load_instrument()=0; + + virtual Error load_song(const char *p_file,CPSong *p_song,bool p_sampleset)=0; + virtual Error load_sample(const char *p_file,CPSample *p_sample)=0; + virtual Error load_instrument(const char *p_file,CPSong *p_song,int p_instr_idx)=0; + + + virtual ~CPLoader() {} + +}; + +#endif diff --git a/modules/chibi/cp_loader_it.cpp b/modules/chibi/cp_loader_it.cpp new file mode 100644 index 0000000000..20a3960a23 --- /dev/null +++ b/modules/chibi/cp_loader_it.cpp @@ -0,0 +1,216 @@ +/*************************************************************************/ +/* cp_loader_it.cpp */ +/*************************************************************************/ +/* This file is part of: */ +/* GODOT ENGINE */ +/* http://www.godotengine.org */ +/*************************************************************************/ +/* Copyright (c) 2007-2016 Juan Linietsky, Ariel Manzur. */ +/* */ +/* Permission is hereby granted, free of charge, to any person obtaining */ +/* a copy of this software and associated documentation files (the */ +/* "Software"), to deal in the Software without restriction, including */ +/* without limitation the rights to use, copy, modify, merge, publish, */ +/* distribute, sublicense, and/or sell copies of the Software, and to */ +/* permit persons to whom the Software is furnished to do so, subject to */ +/* the following conditions: */ +/* */ +/* The above copyright notice and this permission notice shall be */ +/* included in all copies or substantial portions of the Software. */ +/* */ +/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */ +/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */ +/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/ +/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */ +/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */ +/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */ +/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ +/*************************************************************************/ +#include "cp_loader_it.h" + +bool CPLoader_IT::can_load_song() { return true; } +bool CPLoader_IT::can_load_sample() { return true; } +bool CPLoader_IT::can_load_instrument() { return true; } + +CPLoader::Error CPLoader_IT::load_song(const char *p_file,CPSong *p_song, bool p_sampleset) { + + + song=p_song; + + if (file->open( p_file, CPFileAccessWrapper::READ )!=CPFileAccessWrapper::OK) + return CPLoader::FILE_CANNOT_OPEN; + + + Error err; + + char aux_identifier[4]; + file->get_byte_array((uint8_t*)aux_identifier,4); + + if ( aux_identifier[0]!='I' || + aux_identifier[1]!='M' || + aux_identifier[2]!='P' || + aux_identifier[3]!='M') { + + + CP_PRINTERR("IT CPLoader CPSong: Failed Identifier"); + return FILE_UNRECOGNIZED; + } + + + if (p_sampleset) { + + song->reset(false,true,true,false); + + if ((err=load_header(true))) { + file->close(); + return err; + } + + if ((err=load_samples())) { + file->close(); + return err; + } + + if ((err=load_instruments())) { + file->close(); + return err; + } + + return FILE_OK; + } + + song->reset(); + + if ((err=load_header(false))) { + file->close(); + return err; + } + + if ((err=load_orders())) { + file->close(); + return err; + } + + if ((err=load_patterns())) { + file->close(); + return err; + } + + if ((err=load_samples())) { + file->close(); + return err; + } + + if ((err=load_effects())) { + file->close(); + return err; + } + + if ((err=load_instruments())) { + file->close(); + return err; + } + + if ((err=load_message())) { + file->close(); + return err; + } + + file->close(); + return FILE_OK; + +} + + + + +CPLoader::Error CPLoader_IT::load_sample(const char *p_file,CPSample *p_sample) { + + if (file->open( p_file, CPFileAccessWrapper::READ )!=CPFileAccessWrapper::OK) + return CPLoader::FILE_CANNOT_OPEN; + + p_sample->reset(); + CPLoader::Error res=load_sample(p_sample); + + file->close(); + + return res; +} +CPLoader::Error CPLoader_IT::load_instrument(const char *p_file,CPSong *p_song,int p_instr_idx) { + + CP_FAIL_INDEX_V(p_instr_idx,CPSong::MAX_INSTRUMENTS,CPLoader::FILE_CANNOT_OPEN); + + if (file->open( p_file, CPFileAccessWrapper::READ )!=CPFileAccessWrapper::OK) + return CPLoader::FILE_CANNOT_OPEN; + + + p_song->get_instrument( p_instr_idx )->reset(); + + + int samples=0; + CPLoader::Error res=load_instrument( p_song->get_instrument( p_instr_idx ), &samples ); + + if (res) { + file->close(); + return res; + } + + + char exchange[CPSong::MAX_SAMPLES]; + for (int i=0;i<CPSong::MAX_SAMPLES;i++) + exchange[i]=0; + + for (int i=0;i<samples;i++) { + + file->seek( 554+i*80 ); //i think this should work?! seems to.. but i'm not sure + + /* find free sample */ + + int free_idx=-1; + for (int s=0;s<CPSong::MAX_SAMPLES;s++) { + + if (p_song->get_sample( s )->get_sample_data().is_null()) { + free_idx=s; + break; + } + } + if (free_idx==-1) + break; //can't seem to be able to load more samples + + exchange[i]=free_idx; + res=load_sample( p_song->get_sample( free_idx ) ); + + if (res) { + + file->close(); + return res; + } + } + + for (int i=0;i<CPNote::NOTES;i++) { + + int smp=song->get_instrument(p_instr_idx)->get_sample_number(i); + + if (smp>=CPSong::MAX_SAMPLES) + continue; + + if (smp<0) + continue; + + smp=exchange[smp]; + + song->get_instrument(p_instr_idx)->set_sample_number(i,smp); + + } + + file->close(); + + return res; + +} + +CPLoader_IT::CPLoader_IT(CPFileAccessWrapper *p_file) { + + file=p_file; + +} diff --git a/modules/chibi/cp_loader_it.h b/modules/chibi/cp_loader_it.h new file mode 100644 index 0000000000..38a1cdd9c4 --- /dev/null +++ b/modules/chibi/cp_loader_it.h @@ -0,0 +1,125 @@ +/*************************************************************************/ +/* cp_loader_it.h */ +/*************************************************************************/ +/* This file is part of: */ +/* GODOT ENGINE */ +/* http://www.godotengine.org */ +/*************************************************************************/ +/* Copyright (c) 2007-2016 Juan Linietsky, Ariel Manzur. */ +/* */ +/* Permission is hereby granted, free of charge, to any person obtaining */ +/* a copy of this software and associated documentation files (the */ +/* "Software"), to deal in the Software without restriction, including */ +/* without limitation the rights to use, copy, modify, merge, publish, */ +/* distribute, sublicense, and/or sell copies of the Software, and to */ +/* permit persons to whom the Software is furnished to do so, subject to */ +/* the following conditions: */ +/* */ +/* The above copyright notice and this permission notice shall be */ +/* included in all copies or substantial portions of the Software. */ +/* */ +/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */ +/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */ +/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/ +/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */ +/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */ +/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */ +/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ +/*************************************************************************/ + +#ifndef CP_LOADER_IT_H +#define CP_LOADER_IT_H + +#include "cp_loader.h" +/** + *@author Juan Linietsky + */ + +/****************************** + loader_it.h + ---------- +Impulse Tracker Module CPLoader! +It lacks support for old +instrument files methinks... +and some other things like +midi. +********************************/ + +class AuxSampleData; //used for internal crap + +class CPLoader_IT : public CPLoader { + + + + CPFileAccessWrapper *file; + CPSong *song; + + struct IT_Header { + uint8_t blank01[2]; + uint16_t ordnum; + uint16_t insnum; + uint16_t smpnum; + uint16_t patnum; + uint16_t cwt; /* Created with tracker (y.xx = 0x0yxx) */ + uint16_t cmwt; /* Compatible with tracker ver > than val. */ + uint16_t flags; + uint16_t special; /* bit 0 set = song message attached */ + uint16_t msglength; + uint32_t msgoffset; + bool is_chibi; + }; + + /* Variables to store temp data */ + IT_Header header; + + /* CPSong Info Methods */ + Error load_header(bool p_dont_set); + Error load_orders(); + Error load_message(); + + /* CPPattern Methods */ + Error load_patterns(); + + /* CPSample Methods */ + + Error load_samples(); + Error load_sample(CPSample *p_sample); + CPSample_ID load_sample_data(AuxSampleData& p_sample_data); + + // CPSample decompression + + uint32_t read_n_bits_from_IT_compressed_block(uint8_t p_bits_to_read); + bool read_IT_compressed_block (bool p_16bits); + void free_IT_compressed_block (); + bool load_sample_8bits_IT_compressed(void *p_dest_buffer,int p_buffsize); + bool load_sample_16bits_IT_compressed(void *p_dest_buffer,int p_buffsize); + uint32_t *source_buffer; /* source buffer */ + uint32_t *source_position; /* actual reading position */ + uint8_t source_remaining_bits; /* bits remaining in read dword */ + uint8_t* pat_data; + + /* CPInstruments Methods */ + Error load_effects(); + Error load_instruments(); + Error load_instrument(CPInstrument *p_instrument,int *p_samples=0); + void load_envelope(CPEnvelope *p_envelope,bool*p_has_filter_flag=0); + + +public: + + + bool can_load_song(); + bool can_load_sample(); + bool can_load_instrument(); + + Error load_song(const char *p_file,CPSong *p_song, bool p_sampleset=false); + Error load_sample(const char *p_file,CPSample *p_sample); + Error load_instrument(const char *p_file,CPSong *p_song,int p_instr_idx); + + CPLoader_IT(CPFileAccessWrapper *p_file); + +}; + + + +#endif diff --git a/modules/chibi/cp_loader_it_info.cpp b/modules/chibi/cp_loader_it_info.cpp new file mode 100644 index 0000000000..0360f7f9a4 --- /dev/null +++ b/modules/chibi/cp_loader_it_info.cpp @@ -0,0 +1,268 @@ +/*************************************************************************/ +/* cp_loader_it_info.cpp */ +/*************************************************************************/ +/* This file is part of: */ +/* GODOT ENGINE */ +/* http://www.godotengine.org */ +/*************************************************************************/ +/* Copyright (c) 2007-2016 Juan Linietsky, Ariel Manzur. */ +/* */ +/* Permission is hereby granted, free of charge, to any person obtaining */ +/* a copy of this software and associated documentation files (the */ +/* "Software"), to deal in the Software without restriction, including */ +/* without limitation the rights to use, copy, modify, merge, publish, */ +/* distribute, sublicense, and/or sell copies of the Software, and to */ +/* permit persons to whom the Software is furnished to do so, subject to */ +/* the following conditions: */ +/* */ +/* The above copyright notice and this permission notice shall be */ +/* included in all copies or substantial portions of the Software. */ +/* */ +/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */ +/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */ +/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/ +/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */ +/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */ +/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */ +/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ +/*************************************************************************/ +#include "cp_loader_it.h" + + + +CPLoader::Error CPLoader_IT::load_header(bool p_dont_set) { + + + char aux_songname[26]; + + file->get_byte_array((uint8_t*)aux_songname,26); + if (!p_dont_set) + song->set_name( aux_songname ); + + uint8_t aux_hlmin=file->get_byte(); + uint8_t aux_hlmaj=file->get_byte(); + + if (aux_hlmin==0) aux_hlmin=4; + if (aux_hlmaj==0) aux_hlmaj=16; + + if (!p_dont_set) { + song->set_row_highlight_minor( aux_hlmin ); + song->set_row_highlight_major( aux_hlmaj ); + } + + header.ordnum=file->get_word(); + header.insnum=file->get_word(); + header.smpnum=file->get_word(); + header.patnum=file->get_word(); + + header.cwt=file->get_word(); /* Created with tracker (y.xx = 0x0yxx) */ + header.cmwt=file->get_word(); /* Compatible with tracker ver > than val. */ + header.flags=file->get_word(); + + if (!p_dont_set) { + song->set_stereo( header.flags & 1 ); + song->set_linear_slides( header.flags & 8 ); + song->set_old_effects( header.flags & 16 ); + song->set_compatible_gxx( header.flags & 32 ); + song->set_instruments( header.flags & 4 ); + } + + + header.special=file->get_word(); + if (!p_dont_set) { + + song->set_global_volume( file->get_byte() ); + song->set_mixing_volume( file->get_byte() ); + song->set_speed( file->get_byte() ); + song->set_tempo( file->get_byte() ); + song->set_stereo_separation( file->get_byte() ); + + } else { + + file->get_byte(); // skip + file->get_byte(); // skip + file->get_byte(); // skip + file->get_byte(); // skip + file->get_byte(); // skip + } + file->get_byte(); // ZERO Byte + header.msglength=file->get_word(); + header.msgoffset=file->get_dword(); + char chibi[4]; + file->get_byte_array((uint8_t*)chibi,4); + header.is_chibi=(chibi[0]=='C' && chibi[1]=='H' && chibi[2]=='B' && chibi[3]=='I'); + + for (int i=0;i<64;i++) { + + uint8_t panbyte=file->get_byte(); + + uint8_t pan_dst=(panbyte<65) ? panbyte : 32; + bool surround_dst=(panbyte==100); + bool mute_dst=(panbyte>=128); + + if (!p_dont_set) { + song->set_channel_pan( i, pan_dst ); + song->set_channel_surround( i, surround_dst ); + song->set_channel_mute( i, mute_dst ); + } + } + for (int i=0;i<64;i++) { + unsigned char cv = file->get_byte(); + if (!p_dont_set) + song->set_channel_volume( i, cv ); + } + + CP_ERR_COND_V( file->eof_reached(),FILE_CORRUPTED ); + CP_ERR_COND_V( file->get_error(),FILE_CORRUPTED ); + + return FILE_OK; +} + +CPLoader::Error CPLoader_IT::load_effects() { + + if (!header.is_chibi) + return FILE_OK; //no effects, regular IT file + + /* GOTO End of IT header */ + file->seek(0xC0+header.ordnum+header.insnum*4+header.smpnum*4+header.patnum*4); + + + if (file->get_byte()>0) //not made with this version, ignore extended info + return FILE_OK; + + /* Chibitracker Extended info */ + + switch(file->get_byte()) { + + case CPSong::REVERB_MODE_ROOM: { + + song->set_reverb_mode( CPSong::REVERB_MODE_ROOM ); + } break; + case CPSong::REVERB_MODE_STUDIO_SMALL: { + + song->set_reverb_mode( CPSong::REVERB_MODE_STUDIO_SMALL ); + + } break; + case CPSong::REVERB_MODE_STUDIO_MEDIUM: { + + song->set_reverb_mode( CPSong::REVERB_MODE_STUDIO_MEDIUM ); + + } break; + case CPSong::REVERB_MODE_STUDIO_LARGE: { + + song->set_reverb_mode( CPSong::REVERB_MODE_STUDIO_LARGE ); + + } break; + case CPSong::REVERB_MODE_HALL: { + + song->set_reverb_mode( CPSong::REVERB_MODE_HALL ); + + } break; + case CPSong::REVERB_MODE_SPACE_ECHO: { + + song->set_reverb_mode( CPSong::REVERB_MODE_SPACE_ECHO ); + + } break; + + case CPSong::REVERB_MODE_ECHO: { + + song->set_reverb_mode( CPSong::REVERB_MODE_ECHO ); + + } break; + case CPSong::REVERB_MODE_DELAY: { + + song->set_reverb_mode( CPSong::REVERB_MODE_DELAY ); + + } break; + case CPSong::REVERB_MODE_HALF_ECHO: { + + song->set_reverb_mode( CPSong::REVERB_MODE_HALF_ECHO ); + + } break; + + } + + //chorus + song->set_chorus_speed_hz10( file->get_byte() ); + song->set_chorus_delay_ms( file->get_byte() ); + song->set_chorus_depth_ms10( file->get_byte() ); + song->set_chorus_separation_ms( file->get_byte() ); + + for (int i=0;i<CPPattern::WIDTH;i++) { + song->set_channel_reverb(i,file->get_byte()); + } + for (int i=0;i<CPPattern::WIDTH;i++) { + song->set_channel_chorus(i,file->get_byte()); + } + + return FILE_OK; + +} + +CPLoader::Error CPLoader_IT::load_message() { + + + if (!(header.special & 1)) { + + return FILE_OK; + } + + + file->seek(header.msgoffset); + + //(void*)tmpmsg=malloc(header.msglength+1); + + char message[8000]; + + + char *tmpmsg = message; + + file->get_byte_array((uint8_t*)tmpmsg,header.msglength); + tmpmsg[header.msglength]=0; + + for (int i=0;i<header.msglength;i++) if (tmpmsg[i]=='\r') tmpmsg[i]='\n'; + + song->set_message(tmpmsg); + + return FILE_OK; +} + +CPLoader::Error CPLoader_IT::load_orders() { + + file->seek(0xC0); + + + for (int i=0;i<header.ordnum;i++) { + + uint8_t aux_order=file->get_byte(); + CPOrder order=CP_ORDER_NONE; + + + if (i>=CPSong::MAX_ORDERS) + continue; + if (aux_order==254) { + + order=CP_ORDER_BREAK; + + } else if (aux_order<200) { + + order=aux_order; + //nothing! + + } + song->set_order(i,order); + + } + + if (file->eof_reached() || file->get_error()) { + + + return FILE_CORRUPTED; + + } + + return FILE_OK; +} + + + diff --git a/modules/chibi/cp_loader_it_instruments.cpp b/modules/chibi/cp_loader_it_instruments.cpp new file mode 100644 index 0000000000..ccb24bd81c --- /dev/null +++ b/modules/chibi/cp_loader_it_instruments.cpp @@ -0,0 +1,224 @@ +/*************************************************************************/ +/* cp_loader_it_instruments.cpp */ +/*************************************************************************/ +/* This file is part of: */ +/* GODOT ENGINE */ +/* http://www.godotengine.org */ +/*************************************************************************/ +/* Copyright (c) 2007-2016 Juan Linietsky, Ariel Manzur. */ +/* */ +/* Permission is hereby granted, free of charge, to any person obtaining */ +/* a copy of this software and associated documentation files (the */ +/* "Software"), to deal in the Software without restriction, including */ +/* without limitation the rights to use, copy, modify, merge, publish, */ +/* distribute, sublicense, and/or sell copies of the Software, and to */ +/* permit persons to whom the Software is furnished to do so, subject to */ +/* the following conditions: */ +/* */ +/* The above copyright notice and this permission notice shall be */ +/* included in all copies or substantial portions of the Software. */ +/* */ +/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */ +/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */ +/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/ +/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */ +/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */ +/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */ +/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ +/*************************************************************************/ + +#include "cp_loader_it.h" + +enum EnvFlags { + ENV_ON=1, + ENV_LOOP=2, + ENV_SUSLOOP=4, + ENV_CARRY=8, + ENV_FILTER=128 +}; + +void CPLoader_IT::load_envelope(CPEnvelope *p_envelope,bool*p_has_filter_flag) { + + uint8_t flags=file->get_byte(); + uint8_t points=file->get_byte(); + uint8_t begin=file->get_byte(); + uint8_t end=file->get_byte(); + uint8_t susbegin=file->get_byte(); + uint8_t susend=file->get_byte(); + + p_envelope->reset(); + + for (int i=0;i<25;i++) { + + uint8_t height=file->get_byte(); + int8_t &signed_height=(int8_t&)height; + uint16_t tick=file->get_word(); + + if (i>=points) + continue; + p_envelope->add_position( tick, signed_height ); + + } + + p_envelope->set_enabled( flags & ENV_ON ); + p_envelope->set_carry_enabled( flags & ENV_CARRY); + + p_envelope->set_loop_enabled( flags & ENV_LOOP ); + p_envelope->set_loop_begin( begin ); + p_envelope->set_loop_end( end ); + + p_envelope->set_sustain_loop_enabled( flags & ENV_SUSLOOP ); + p_envelope->set_sustain_loop_begin( susbegin ); + p_envelope->set_sustain_loop_end( susend ); + + if (p_has_filter_flag) + *p_has_filter_flag=flags&ENV_FILTER; + + file->get_byte(); //zerobyte + + //fill with stuff if the envelope hass less than 2 points + while(p_envelope->get_node_count()<2) { + + p_envelope->add_position( 30*p_envelope->get_node_count(), p_envelope->get_min()==0 ? 64 : 0, false ); + } +} + + +CPLoader::Error CPLoader_IT::load_instrument(CPInstrument *p_instrument,int *p_samples) { + + + + char aux_header[4]; + + file->get_byte_array((uint8_t*)aux_header,4); + + + if ( aux_header[0]!='I' || + aux_header[1]!='M' || + aux_header[2]!='P' || + aux_header[3]!='I') { + CP_PRINTERR("IT CPLoader CPInstrument: Failed Identifier"); + + return FILE_UNRECOGNIZED; + } + + + + // Ignore deprecated 8.3 filename field + for (int i=0;i<12;i++) file->get_byte(); + + //Ignore zerobyte + file->get_byte(); /* (byte) CPInstrument type (always 0) */ + + switch( file->get_byte() ) { /* New CPNote Action [0,1,2,3] */ + case 0: p_instrument->set_NNA_type( CPInstrument::NNA_NOTE_CUT ) ; break; + case 1: p_instrument->set_NNA_type( CPInstrument::NNA_NOTE_CONTINUE ) ; break; + case 2: p_instrument->set_NNA_type( CPInstrument::NNA_NOTE_OFF ) ; break; + case 3: p_instrument->set_NNA_type( CPInstrument::NNA_NOTE_FADE ) ; break; + }; + switch( file->get_byte() ) { // Duplicate Check Type + case 0: p_instrument->set_DC_type( CPInstrument::DCT_DISABLED ); break ; + case 1: p_instrument->set_DC_type( CPInstrument::DCT_NOTE ); break ; + case 2: p_instrument->set_DC_type( CPInstrument::DCT_SAMPLE ); break ; + case 3: p_instrument->set_DC_type( CPInstrument::DCT_INSTRUMENT ); break ; + } + switch( file->get_byte() ) { //Duplicate Check Action + case 0: p_instrument->set_DC_action( CPInstrument::DCA_NOTE_CUT ); break ; + case 1: p_instrument->set_DC_action( CPInstrument::DCA_NOTE_OFF ); break ; + case 2: p_instrument->set_DC_action( CPInstrument::DCA_NOTE_FADE ); break ; + } + + int fade = file->get_word(); + //intf("AFADE: %i\n",fade); + if (fade>CPInstrument::MAX_FADEOUT) //needs to be clipped because of horrible modplug doings + fade=CPInstrument::MAX_FADEOUT; + + p_instrument->set_volume_fadeout( fade ); + p_instrument->set_pan_pitch_separation( file->get_byte() ); + p_instrument->set_pan_pitch_center( file->get_byte() ); + p_instrument->set_volume_global_amount( file->get_byte() ); + uint8_t pan=file->get_byte(); + p_instrument->set_pan_default_amount(pan&0x7F); + p_instrument->set_pan_default_enabled( !(pan&0x80) ); + p_instrument->set_volume_random_variation( file->get_byte() ); + p_instrument->set_pan_random_variation( file->get_byte() ); + + + + file->get_word(); //empty (version) + uint8_t samples=file->get_byte(); + if (p_samples) + *p_samples=samples; + file->get_byte(); //empty + char aux_name[26]; + file->get_byte_array((uint8_t*)aux_name,26); + p_instrument->set_name(aux_name); + + uint8_t cutoff=file->get_byte(); + + p_instrument->set_filter_default_cutoff(cutoff&0x7F); + p_instrument->set_filter_use_default_cutoff(cutoff&0x80); + + uint8_t resonance=file->get_byte(); + + p_instrument->set_filter_default_resonance(resonance&0x7F); + p_instrument->set_filter_use_default_resonance(resonance&0x80); + + file->get_dword(); //MIDI, IGNORED! + + /* CPNote -> CPSample table */ + for (uint8_t i=0;i<CPNote::NOTES;i++) { + + + uint8_t note=file->get_byte(); + if (note>=CPNote::NOTES) + note=0; + p_instrument->set_note_number(i,note); + + uint8_t samp=file->get_byte(); + if (samp==0 || samp>99) + samp=CPNote::EMPTY; + else + samp--; + + + p_instrument->set_sample_number(i,samp); + + + } + + + load_envelope( p_instrument->get_volume_envelope() ); + load_envelope( p_instrument->get_pan_envelope() ); + bool use_as_filter; + load_envelope( p_instrument->get_pitch_filter_envelope(), &use_as_filter ); + p_instrument->set_pitch_use_as_filter( use_as_filter ); + + return FILE_OK; + +} + + +CPLoader::Error CPLoader_IT::load_instruments() { + + + for (int i=0;i<header.insnum;i++) { + + + file->seek(0xC0+header.ordnum+i*4); + uint32_t final_location=file->get_dword(); + file->seek( final_location ); + + Error err=load_instrument( song->get_instrument( i ) ); + if (err) + return err; + + } + + return FILE_OK; + + if (file->eof_reached() || file->get_error()) + return FILE_CORRUPTED; +} + + diff --git a/modules/chibi/cp_loader_it_patterns.cpp b/modules/chibi/cp_loader_it_patterns.cpp new file mode 100644 index 0000000000..d951a91620 --- /dev/null +++ b/modules/chibi/cp_loader_it_patterns.cpp @@ -0,0 +1,166 @@ +/*************************************************************************/ +/* cp_loader_it_patterns.cpp */ +/*************************************************************************/ +/* This file is part of: */ +/* GODOT ENGINE */ +/* http://www.godotengine.org */ +/*************************************************************************/ +/* Copyright (c) 2007-2016 Juan Linietsky, Ariel Manzur. */ +/* */ +/* Permission is hereby granted, free of charge, to any person obtaining */ +/* a copy of this software and associated documentation files (the */ +/* "Software"), to deal in the Software without restriction, including */ +/* without limitation the rights to use, copy, modify, merge, publish, */ +/* distribute, sublicense, and/or sell copies of the Software, and to */ +/* permit persons to whom the Software is furnished to do so, subject to */ +/* the following conditions: */ +/* */ +/* The above copyright notice and this permission notice shall be */ +/* included in all copies or substantial portions of the Software. */ +/* */ +/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */ +/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */ +/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/ +/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */ +/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */ +/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */ +/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ +/*************************************************************************/ +#include "cp_loader_it.h" + + +CPLoader::Error CPLoader_IT::load_patterns() { + + + for (int i=0;i<header.patnum;i++) { + + if (i>=CPSong::MAX_PATTERNS) + break; + + /* Position where pattern offsets are stored */ + file->seek(0xC0+header.ordnum+header.insnum*4+header.smpnum*4+i*4); + uint32_t pattern_offset=file->get_dword(); + + if (pattern_offset==0) { + + continue; + } + + uint16_t pat_size; + uint16_t pat_length; + + int row=0,flag,channel,j; + uint8_t aux_byte; + uint32_t reserved; + uint8_t chan_mask[64]; //mask cache for each + CPNote last_value[64]; //last value of each + + for (j=0;j<64;j++) { + + chan_mask[j]=0; + last_value[j].clear(); + } + + file->seek(pattern_offset); + + pat_size=file->get_word(); + pat_length=file->get_word(); + reserved=file->get_dword(); + + song->get_pattern(i)->set_length( pat_length ); + + do { + + aux_byte=file->get_byte(); + flag=aux_byte; + + if ( flag==0 ) { + + row++; + } else { + + channel=(flag-1) & 63; + + if ( flag & 128 ) { + + aux_byte=file->get_byte(); + chan_mask[channel]=aux_byte; + } + + CPNote note; //note used for reading + + if ( chan_mask[channel]&1 ) { // read note + + aux_byte=file->get_byte(); + + if ( aux_byte<120 ) + note.note=aux_byte; + else if ( aux_byte==255 ) + note.note=CPNote::OFF; + else if ( aux_byte==254 ) + note.note=CPNote::CUT; + + last_value[channel].note=note.note; + } + + + if ( chan_mask[channel]&2 ) { + + aux_byte=file->get_byte(); + if ( aux_byte<100 ) + note.instrument=aux_byte-1; + + last_value[channel].instrument=note.instrument; + } + if ( chan_mask[channel]&4 ) { + + aux_byte=file->get_byte(); + if ( aux_byte<213 ) + note.volume=aux_byte; + + last_value[channel].volume=note.volume; + } + if ( chan_mask[channel]&8 ) { + + aux_byte=file->get_byte(); + if ( aux_byte>0 ) + note.command=aux_byte-1; + + + last_value[channel].command=note.command; + + note.parameter=file->get_byte(); + + last_value[channel].parameter=note.parameter; + } + + if ( chan_mask[channel]&16 ) { + + note.note=last_value[channel].note; + } + + if ( chan_mask[channel]&32 ) { + + note.instrument=last_value[channel].instrument; + } + if ( chan_mask[channel]&64 ) { + + note.volume=last_value[channel].volume; + } + if ( chan_mask[channel]&128 ) { + + note.command=last_value[channel].command; + note.parameter=last_value[channel].parameter; + } + + song->get_pattern(i)->set_note(channel,row,note); + } + + + } while(row<pat_length); + + } + + return FILE_OK; +} + diff --git a/modules/chibi/cp_loader_it_samples.cpp b/modules/chibi/cp_loader_it_samples.cpp new file mode 100644 index 0000000000..ced7252a6c --- /dev/null +++ b/modules/chibi/cp_loader_it_samples.cpp @@ -0,0 +1,620 @@ +/*************************************************************************/ +/* cp_loader_it_samples.cpp */ +/*************************************************************************/ +/* This file is part of: */ +/* GODOT ENGINE */ +/* http://www.godotengine.org */ +/*************************************************************************/ +/* Copyright (c) 2007-2016 Juan Linietsky, Ariel Manzur. */ +/* */ +/* Permission is hereby granted, free of charge, to any person obtaining */ +/* a copy of this software and associated documentation files (the */ +/* "Software"), to deal in the Software without restriction, including */ +/* without limitation the rights to use, copy, modify, merge, publish, */ +/* distribute, sublicense, and/or sell copies of the Software, and to */ +/* permit persons to whom the Software is furnished to do so, subject to */ +/* the following conditions: */ +/* */ +/* The above copyright notice and this permission notice shall be */ +/* included in all copies or substantial portions of the Software. */ +/* */ +/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */ +/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */ +/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/ +/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */ +/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */ +/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */ +/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ +/*************************************************************************/ +#include "cp_loader_it.h" +#include "cp_sample.h" + +struct AuxSampleData { + + + uint32_t fileofs; + uint32_t c5spd; + uint32_t length; + uint32_t loop_begin; + uint32_t loop_end; + bool loop_enabled; + bool pingpong_enabled; + bool is16bit; + bool stereo; + bool exists; + bool compressed; + +}; + + +enum IT_Sample_Flags { + + IT_SAMPLE_EXISTS=1, + IT_SAMPLE_16BITS=2, + IT_SAMPLE_STEREO=4, + IT_SAMPLE_COMPRESSED=8, + IT_SAMPLE_LOOPED=16, + IT_SAMPLE_SUSTAIN_LOOPED=32, + IT_SAMPLE_LOOP_IS_PINGPONG=64, + IT_SAMPLE_SUSTAIN_LOOP_IS_PINGPONG=128 +}; + + +CPLoader::Error CPLoader_IT::load_sample(CPSample *p_sample) { + + + AuxSampleData aux_sample_data; + + char aux_header[4]; + + file->get_byte_array((uint8_t*)aux_header,4); + + if ( aux_header[0]!='I' || + aux_header[1]!='M' || + aux_header[2]!='P' || + aux_header[3]!='S') { + + //CP_PRINTERR("IT CPLoader CPSample: Failed Identifier"); + return FILE_UNRECOGNIZED; + } + + + // Ignore deprecated 8.3 filename + for (int i=0;i<12;i++) file->get_byte(); + + file->get_byte(); //ignore zerobyte + + p_sample->set_global_volume( file->get_byte() ); + + /* SAMPLE FLAGS */ + uint8_t flags=file->get_byte(); + aux_sample_data.loop_enabled=flags&IT_SAMPLE_LOOPED; + aux_sample_data.pingpong_enabled=flags&IT_SAMPLE_LOOP_IS_PINGPONG; + aux_sample_data.is16bit=flags&IT_SAMPLE_16BITS; + aux_sample_data.exists=flags&IT_SAMPLE_EXISTS; + aux_sample_data.stereo=flags&IT_SAMPLE_STEREO; + aux_sample_data.compressed=flags&IT_SAMPLE_COMPRESSED; + + p_sample->set_default_volume(file->get_byte()); + /* SAMPLE NAME */ + char aux_name[26]; + file->get_byte_array((uint8_t*)aux_name,26); + p_sample->set_name(aux_name); + + // ?? + uint8_t convert_flag=file->get_byte(); + // PAN + uint8_t pan=file->get_byte(); + p_sample->set_pan( pan&0x7F ); + p_sample->set_pan_enabled( pan & 0x80 ); + + aux_sample_data.length=file->get_dword(); + + + aux_sample_data.loop_begin= file->get_dword(); + aux_sample_data.loop_end= file->get_dword(); + aux_sample_data.c5spd=file->get_dword(); + /*p_sample->data.set_sustain_loop_begin=*/file->get_dword(); + /*p_sample->data.sustain_loop_end=*/file->get_dword(); + aux_sample_data.fileofs=file->get_dword(); + p_sample->set_vibrato_speed( file->get_byte() ); + p_sample->set_vibrato_depth( file->get_byte() ); + p_sample->set_vibrato_rate( file->get_byte() ); + switch( file->get_byte() ) { + /* Vibrato Wave: 0=sine, 1=rampdown, 2=square, 3=random */ + case 0: p_sample->set_vibrato_type( CPSample::VIBRATO_SINE ); break; + case 1: p_sample->set_vibrato_type( CPSample::VIBRATO_SAW ); break; + case 2: p_sample->set_vibrato_type( CPSample::VIBRATO_SQUARE ); break; + case 3: p_sample->set_vibrato_type( CPSample::VIBRATO_RANDOM ); break; + default: p_sample->set_vibrato_type( CPSample::VIBRATO_SINE ); break; + } + + //printf("Name %s - Flags: fileofs :%i - c5spd %i - len %i 16b %i - data?: %i\n",p_sample->get_name(),aux_sample_data.fileofs,aux_sample_data.c5spd, aux_sample_data.length, aux_sample_data.is16bit,aux_sample_data.exists); + CPSample_ID samp_id; + + if (aux_sample_data.exists) { + samp_id=load_sample_data(aux_sample_data); + CPSampleManager::get_singleton()->set_c5_freq(samp_id,aux_sample_data.c5spd); + CPSampleManager::get_singleton()->set_loop_begin( samp_id,aux_sample_data.loop_begin ); + CPSampleManager::get_singleton()->set_loop_end( samp_id,aux_sample_data.loop_end ); + CPSample_Loop_Type loop_type=aux_sample_data.loop_enabled?( aux_sample_data.pingpong_enabled? CP_LOOP_BIDI: CP_LOOP_FORWARD):CP_LOOP_NONE; + CPSampleManager::get_singleton()->set_loop_end( samp_id,aux_sample_data.loop_end ); + CPSampleManager::get_singleton()->set_loop_type( samp_id, loop_type); + + } + + //printf("Loaded id is null?: %i\n",samp_id.is_null()); + p_sample->set_sample_data(samp_id); + if (!samp_id.is_null()) { + + // printf("Loaded ID: stereo: %i len %i 16bit %i\n",CPSampleManager::get_singleton()->is_stereo(samp_id), CPSampleManager::get_singleton()->get_size( samp_id), CPSampleManager::get_singleton()->is_16bits( samp_id) ); + } + + CP_ERR_COND_V( file->eof_reached(),FILE_CORRUPTED ); + CP_ERR_COND_V( file->get_error(),FILE_CORRUPTED ); + + return FILE_OK; + +} + +CPSample_ID CPLoader_IT::load_sample_data(AuxSampleData& p_sample_data) { + + + int aux_sample_properties = (p_sample_data.is16bit?IT_SAMPLE_16BITS:0)|(p_sample_data.compressed?IT_SAMPLE_COMPRESSED:0)|(p_sample_data.stereo?IT_SAMPLE_STEREO:0); + + file->seek(p_sample_data.fileofs); + + CPSampleManager *sm=CPSampleManager::get_singleton(); + + CPSample_ID id; + + switch (aux_sample_properties) { + + case (0): // 8 bits, mono + case (IT_SAMPLE_16BITS): // 16 bits mono + case (IT_SAMPLE_STEREO): // 8 bits stereo + case (IT_SAMPLE_16BITS|IT_SAMPLE_STEREO): { // 16 bits mono + + id=sm->create(p_sample_data.is16bit,p_sample_data.stereo,p_sample_data.length); + if (id.is_null()) + break; + + sm->lock_data(id); + + int16_t *ptr16 = (int16_t*)sm->get_data(id); + int8_t *ptr8=(int8_t*)ptr16; + + int chans=p_sample_data.stereo?2:1; + + if (p_sample_data.is16bit) { + + for (int c=0;c<chans;c++) { + + for (int i=0;i<p_sample_data.length;i++) { + + ptr16[i*chans+c]=file->get_word(); + } + } + } else { + + for (int c=0;c<chans;c++) { + + for (int i=0;i<p_sample_data.length;i++) { + + ptr8[i*chans+c]=file->get_byte(); + } + } + + } + + sm->unlock_data(id); + + } break; + case (IT_SAMPLE_COMPRESSED): { // 8 bits compressed + + + id=sm->create(false,false,p_sample_data.length); + if (id.is_null()) + break; + sm->lock_data(id); + + if ( load_sample_8bits_IT_compressed((void*)sm->get_data( id),p_sample_data.length) ) { + + sm->unlock_data(id); + sm->destroy(id); + + break; + } + + sm->unlock_data(id); + + + } break; + case (IT_SAMPLE_16BITS|IT_SAMPLE_COMPRESSED): { // 16 bits compressed + + + id=sm->create(true,false,p_sample_data.length); + if (id.is_null()) + break; + sm->lock_data(id); + + if ( load_sample_16bits_IT_compressed((void*)sm->get_data(id),p_sample_data.length) ) { + + sm->unlock_data(id); + sm->destroy(id); + break; + } + + sm->unlock_data(id); + + } break; + default: { + + // I dont know how to handle stereo compressed, does that exist? + } break; + + } + + + return id; +} + + +CPLoader::Error CPLoader_IT::load_samples() { + + for (int i=0;i<header.smpnum;i++) { + + //seek to sample + file->seek(0xC0+header.ordnum+header.insnum*4+i*4); + + uint32_t final_location=file->get_dword(); + file->seek( final_location ); + + + Error err=load_sample(song->get_sample(i)); + CP_ERR_COND_V(err,err); + + } + + if (file->eof_reached() || file->get_error()) + return FILE_CORRUPTED; + + return FILE_OK; +} +/* * NOTICE * NOTICE * NOTICE * NOTICE * NOTICE * NOTICE * NOTICE * NOTICE * NOTICE * NOTICE * NOTICE + + -The following sample decompression code is based on xmp's code.(http://xmp.helllabs.org) which is based in openCP code. + +* NOTICE * NOTICE * NOTICE * NOTICE * NOTICE * NOTICE * NOTICE * NOTICE * NOTICE * NOTICE * NOTICE */ + +uint32_t CPLoader_IT::read_n_bits_from_IT_compressed_block (uint8_t p_bits_to_read) { + + uint32_t aux_return_value; + uint32_t val; + + uint8_t *buffer=(uint8_t*)source_position; + if ( p_bits_to_read <= source_remaining_bits ) { + + val=buffer[3]; + val<<=8; + val|=buffer[2]; + val<<=8; + val|=buffer[1]; + val<<=8; + val|=buffer[0]; + + aux_return_value = val & ((1 << p_bits_to_read) - 1); + val >>= p_bits_to_read; + source_remaining_bits -= p_bits_to_read; + + buffer[3]=val>>24; + buffer[2]=(val>>16)&0xFF; + buffer[1]=(val>>8)&0xFF; + buffer[0]=(val)&0xFF; + + } else { + aux_return_value=buffer[3]; + aux_return_value<<=8; + aux_return_value|=buffer[2]; + aux_return_value<<=8; + aux_return_value|=buffer[1]; + aux_return_value<<=8; + aux_return_value|=buffer[0]; + + uint32_t nbits = p_bits_to_read - source_remaining_bits; + source_position++; + + buffer+=4; + val=buffer[3]; + val<<=8; + val|=buffer[2]; + val<<=8; + val|=buffer[1]; + val<<=8; + val|=buffer[0]; + aux_return_value |= ((val & ((1 << nbits) - 1)) << source_remaining_bits); + val >>= nbits; + source_remaining_bits = 32 - nbits; + buffer[3]=val>>24; + buffer[2]=(val>>16)&0xFF; + buffer[1]=(val>>8)&0xFF; + buffer[0]=(val)&0xFF; + + } + + return aux_return_value; +} + +bool CPLoader_IT::read_IT_compressed_block (bool p_16bits) { + + uint16_t size; + + size=file->get_word(); + + if (file->eof_reached() || file->get_error()) return true; + + pat_data = (uint8_t*)CP_ALLOC( 4* ((size >> 2) + 2) ); + if (!pat_data) + return true; + + + source_buffer=(uint32_t*)pat_data; + file->get_byte_array((uint8_t*)source_buffer,size); + + if (file->eof_reached() || file->get_error()) { + + free_IT_compressed_block(); + return true; + } + + source_position = source_buffer; + source_remaining_bits = 32; + + return false; +} + +void CPLoader_IT::free_IT_compressed_block () { + + + if (pat_data) { + CP_FREE(pat_data); + pat_data=NULL; + } + +} + +bool CPLoader_IT::load_sample_8bits_IT_compressed(void *p_dest_buffer,int p_buffsize) { + + int8_t *dest_buffer; /* destination buffer which will be returned */ + uint16_t block_length; /* length of compressed data block in samples */ + uint16_t block_position; /* position in block */ + uint8_t bit_width; /* actual "bit width" */ + uint16_t aux_value; /* value read from file to be processed */ + int8_t d1, d2; /* integrator buffers (d2 for it2.15) */ + int8_t *dest_position; /* position in output buffer */ + int8_t v; /* sample value */ + bool it215; // is this an it215 module? + + dest_buffer = (int8_t *) p_dest_buffer; + + if (dest_buffer==NULL) + return true; + + for (int i=0;i<p_buffsize;i++) + dest_buffer[i]=0; + + + dest_position = dest_buffer; + + it215=(header.cmwt==0x215); + + /* now unpack data till the dest buffer is full */ + + while (p_buffsize) { + /* read a new block of compressed data and reset variables */ + if ( read_IT_compressed_block(false) ) { + CP_PRINTERR("Out of memory decompressing IT CPSample"); + return true; + } + + + block_length = (p_buffsize < 0x8000) ? p_buffsize : 0x8000; + + block_position = 0; + + bit_width = 9; /* start with width of 9 bits */ + + d1 = d2 = 0; /* reset integrator buffers */ + + /* now uncompress the data block */ + while ( block_position < block_length ) { + + aux_value = read_n_bits_from_IT_compressed_block(bit_width); /* read bits */ + + if ( bit_width < 7 ) { /* method 1 (1-6 bits) */ + + if ( aux_value == (1 << (bit_width - 1)) ) { /* check for "100..." */ + + aux_value = read_n_bits_from_IT_compressed_block(3) + 1; /* yes -> read new width; */ + bit_width = (aux_value < bit_width) ? aux_value : aux_value + 1; + /* and expand it */ + continue; /* ... next value */ + } + + } else if ( bit_width < 9 ) { /* method 2 (7-8 bits) */ + + uint8_t border = (0xFF >> (9 - bit_width)) - 4; + /* lower border for width chg */ + + if ( aux_value > border && aux_value <= (border + 8) ) { + + aux_value -= border; /* convert width to 1-8 */ + bit_width = (aux_value < bit_width) ? aux_value : aux_value + 1; + /* and expand it */ + continue; /* ... next value */ + } + + + } else if ( bit_width == 9 ) { /* method 3 (9 bits) */ + + if ( aux_value & 0x100 ) { /* bit 8 set? */ + + bit_width = (aux_value + 1) & 0xff; /* new width... */ + continue; /* ... and next value */ + } + + } else { /* illegal width, abort */ + + + free_IT_compressed_block(); + CP_PRINTERR("CPSample has illegal BitWidth "); + return true; + } + + /* now expand value to signed byte */ + if ( bit_width < 8 ) { + + uint8_t tmp_shift = 8 - bit_width; + + v=(aux_value << tmp_shift); + v>>=tmp_shift; + + } else v = (int8_t) aux_value; + + /* integrate upon the sample values */ + d1 += v; + d2 += d1; + + /* ... and store it into the buffer */ + *(dest_position++) = it215 ? d2 : d1; + block_position++; + + } + + /* now subtract block lenght from total length and go on */ + free_IT_compressed_block(); + p_buffsize -= block_length; + } + + + return false; +} + +bool CPLoader_IT::load_sample_16bits_IT_compressed(void *p_dest_buffer,int p_buffsize) { + + int16_t *dest_buffer; /* destination buffer which will be returned */ + uint16_t block_length; /* length of compressed data block in samples */ + uint16_t block_position; /* position in block */ + uint8_t bit_width; /* actual "bit width" */ + uint32_t aux_value; /* value read from file to be processed */ + int16_t d1, d2; /* integrator buffers (d2 for it2.15) */ + int16_t *dest_position; /* position in output buffer */ + int16_t v; /* sample value */ + + bool it215; // is this an it215 module? + + dest_buffer = (int16_t *) p_dest_buffer; + + if (dest_buffer==NULL) + return true; + + for (int i=0;i<p_buffsize;i++) + dest_buffer[i]=0; + + dest_position = dest_buffer; + + it215=(header.cmwt==0x215); + + + while (p_buffsize) { + /* read a new block of compressed data and reset variables */ + if ( read_IT_compressed_block(true) ) { + + return true; + } + + + block_length = (p_buffsize < 0x4000) ? p_buffsize : 0x4000; + + block_position = 0; + + bit_width = 17; /* start with width of 9 bits */ + + d1 = d2 = 0; /* reset integrator buffers */ + + while ( block_position < block_length ) { + + aux_value = read_n_bits_from_IT_compressed_block(bit_width); /* read bits */ + + if ( bit_width < 7 ) { /* method 1 (1-6 bits) */ + + if ( (signed)aux_value == (1 << (bit_width - 1)) ) { /* check for "100..." */ + + aux_value = read_n_bits_from_IT_compressed_block(4) + 1; /* yes -> read new width; */ + bit_width = (aux_value < bit_width) ? aux_value : aux_value + 1; + /* and expand it */ + continue; /* ... next value */ + } + + } else if ( bit_width < 17 ) { + + uint16_t border = (0xFFFF >> (17 - bit_width)) - 8; + + if ( (int)aux_value > (int)border && (int)aux_value <= ((int)border + 16) ) { + + aux_value -= border; /* convert width to 1-8 */ + bit_width = (aux_value < bit_width) ? aux_value : aux_value + 1; + /* and expand it */ + continue; /* ... next value */ + } + + + } else if ( bit_width == 17 ) { + + if ( aux_value & 0x10000 ) { /* bit 8 set? */ + + bit_width = (aux_value + 1) & 0xff; /* new width... */ + continue; /* ... and next value */ + } + + } else { /* illegal width, abort */ + + CP_PRINTERR("CPSample has illegal BitWidth "); + + free_IT_compressed_block(); + + return true; + } + + /* now expand value to signed byte */ + if ( bit_width < 16 ) { + + uint8_t tmp_shift = 16 - bit_width; + + v=(aux_value << tmp_shift); + v>>=tmp_shift; + + } else v = (int16_t) aux_value; + + /* integrate upon the sample values */ + d1 += v; + d2 += d1; + + /* ... and store it into the buffer */ + *(dest_position++) = it215 ? d2 : d1; + block_position++; + + } + + /* now subtract block lenght from total length and go on */ + free_IT_compressed_block(); + p_buffsize -= block_length; + } + + + return false; + +} + + + diff --git a/modules/chibi/cp_loader_mod.cpp b/modules/chibi/cp_loader_mod.cpp new file mode 100644 index 0000000000..f867b77914 --- /dev/null +++ b/modules/chibi/cp_loader_mod.cpp @@ -0,0 +1,482 @@ +/*************************************************************************/ +/* cp_loader_mod.cpp */ +/*************************************************************************/ +/* This file is part of: */ +/* GODOT ENGINE */ +/* http://www.godotengine.org */ +/*************************************************************************/ +/* Copyright (c) 2007-2016 Juan Linietsky, Ariel Manzur. */ +/* */ +/* Permission is hereby granted, free of charge, to any person obtaining */ +/* a copy of this software and associated documentation files (the */ +/* "Software"), to deal in the Software without restriction, including */ +/* without limitation the rights to use, copy, modify, merge, publish, */ +/* distribute, sublicense, and/or sell copies of the Software, and to */ +/* permit persons to whom the Software is furnished to do so, subject to */ +/* the following conditions: */ +/* */ +/* The above copyright notice and this permission notice shall be */ +/* included in all copies or substantial portions of the Software. */ +/* */ +/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */ +/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */ +/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/ +/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */ +/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */ +/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */ +/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ +/*************************************************************************/ +#include "cp_loader_mod.h" + + +static bool tag_equal_to(const char *p_tag, const char *p_string) { + + return( p_tag[0]==p_string[0] && + p_tag[1]==p_string[1] && + p_tag[2]==p_string[2] && + p_tag[3]==p_string[3]); +} +/* ProTracker period table */ +uint16_t period_table[6*12] = { + 1712,1616,1524,1440,1356,1280,1208,1140,1076,1016,960,907, + 856,808,762,720,678,640,604,570,538,508,480,453, + 428,404,381,360,339,320,302,285,269,254,240,226, + 214,202,190,180,170,160,151,143,135,127,120,113, + 107,101,95,90,85,80,75,71,67,63,60,56, + 53,50,47,45,42,40,37,35,33,31,30,28 +}; + + +CPLoader::Error CPLoader_MOD::load_song(const char *p_file,CPSong *p_song,bool p_sampleset) { + + if (file->open(p_file,CPFileAccessWrapper::READ)) { + //printf("Can't open file! %s\n",p_file); + return FILE_CANNOT_OPEN; + }; + + /* FIRST OF ALL, one needs to read the .mod file format tag */ + file->seek( 1080 ); //located at 1080 + + char format_tag[4]; + + file->get_byte_array( (uint8_t*)format_tag, 4 ); + + int channels=-1; + + /** THE PAIN!! - COMPARE TAGS */ + + /* Classic 4-chan */ + if (tag_equal_to(format_tag,"M.K.") ) + channels=4; + if (tag_equal_to(format_tag,"FLT4") ) + channels=4; + if (tag_equal_to(format_tag,"M!K!") ) + channels=4; + + /* 8 Channel MODS */ + + if (tag_equal_to(format_tag,"FLT8") ) + channels=2; + + if (tag_equal_to(format_tag,"CD81") ) + channels=2; + + /* Custom channel MODS */ + + for (int i=1;i<=32;i++) { + + if (i<10) { // up to 9 channels mods + + /* Old Take Tracker */ + char old_take_tracker[4]={'T','D','Z',char('0'+i)}; + + if (tag_equal_to(format_tag,old_take_tracker)) { + + channels=i; + break; + } + + /* Contemplates many XCHN Formats */ + char xchn[4]={char('0'+i),'C','H','N'}; + + if (tag_equal_to(format_tag,xchn)) { + + channels=i; + break; + } + } + + /* Fast Tracker */ + char fast_tracker[4]={char('0'+(i/10)),char('0'+(i%10)),'C','H'}; + + if (tag_equal_to(format_tag,fast_tracker)) { + + channels=i; + break; + } + + } + + + if (channels==-1) { + + file->close(); + return FILE_UNRECOGNIZED; + } + + + + /** Load CPSong INFO */ + + file->seek( 0 ); //go to begining of file + + file->set_endian_conversion( true ); + p_song->reset(); + p_song->set_instruments( false ); + + char name[21]; + + file->get_byte_array( (uint8_t*)name,20); + name[20]=0; + + p_song->set_name(name); + p_song->set_old_effects( true ); + p_song->set_linear_slides( false ); + p_song->set_compatible_gxx( true ); + + + + CPSampleManager *sm=CPSampleManager::get_singleton(); + + int instruments=31; + + for (int i=0;i<instruments;i++) { + + char sample_name[23]; + file->get_byte_array( (uint8_t*)sample_name,22); + sample_name[22]=0; + + uint32_t sample_len=file->get_word(); + sample_len<<=1; + + uint8_t fine_nibble=file->get_byte()&0xF; + + + //(int8_t)(fine_nibble & 7) - (int8_t)(fine_nibble & 8); //yesso's genius trick + // boo, I can't use it :( but i leave it here because of how cool it is + uint8_t linear_volume=file->get_byte(); //0 .. ? + + uint32_t loop_begin=file->get_word(); //0 .. ? + loop_begin<<=1; + uint32_t loop_end=file->get_word(); //0 .. ? + loop_end<<=1; + + if (sample_len>0) { + + CPSample_ID sid=sm->create( false, false, sample_len ); + + if (sid.is_null()) { + + file->close(); + return FILE_OUT_OF_MEMORY; + } + + if (loop_end>2) { + sm->set_loop_begin( sid, loop_begin ); + sm->set_loop_end( sid, loop_end+loop_begin ); + sm->set_loop_type( sid,CP_LOOP_FORWARD ); + } + static const uint16_t fine_to_freq[16]={ + 8363,8413,8463,8529,8581,8651,8723,8757, + 7895,7941,7985,8046,8107,8169,8232,8280 + }; + + sm->set_c5_freq( sid, fine_to_freq[fine_nibble] ); + p_song->get_sample(i)->set_sample_data(sid); + } + + p_song->get_sample(i)->set_name(sample_name); + p_song->get_sample(i)->set_default_volume( linear_volume ); + + + + } + + /* pan for MODs */ + for (int i=0;i<channels;i++) + p_song->set_channel_pan( i, (((i&3)==1) || ((i&3)==2)) ? 0: 64); + + + uint8_t order_count=file->get_byte(); +// uint8_t loop_to=file->get_byte(); + + + int pattern_count=0; + + for (int i=0;i<128;i++) { + + uint8_t order=file->get_byte(); + + + if (i<order_count) { + p_song->set_order(i,order); + + /* Determine the amount of patterns */ + if ((order+1)>pattern_count) + pattern_count=order+1; + } else + p_song->set_order( i, CP_ORDER_NONE ); + } + + if (instruments==31) + file->get_dword(); // identiefier, now skip it + + for (int i=0;i<pattern_count;i++) { + + for(int line=0;line<64;line++) { + + for(int column=0;column<channels;column++) { + + uint32_t note_w=file->get_dword(); + + CPNote note; + + note.instrument=(note_w>>12)&0xF; + note.instrument|=(note_w>>24)&0xF0; + + if (note.instrument==0) + note.instrument=CPNote::EMPTY; + else + note.instrument--; + + note.parameter=note_w&0xFF; + + int cmd=(note_w>>8)&0xF; + + uint32_t period=(note_w>>16)&0xFFF; + + if (period>0 && period<0xFFF) { + + //period>>=2; + //period<<=1; + for (int n=0; n<6*12; n++) { + + if (period >= period_table[n]) { + + if ((period!=period_table[n]) && (n)) + { + uint32_t p1 = period_table[n-1]; + uint32_t p2 = period_table[n]; + if (p1 - period < (period - p2)) { + + note.note=n+36; + break; + } + } + note.note=n+1+36; + break; + } + } + if (note.note==CPNote::EMPTY) + note.note=6*12+36; + + note.note--; + } + + + switch(cmd) { + + case 0x0: { + + if (note.parameter>0) + note.command='J'-'A'; + } break; + case 0x1: { + note.command='F'-'A'; + } break; + case 0x2: { + + note.command='E'-'A'; + } break; + case 0x3: { + + note.command='G'-'A'; + } break; + case 0x4: { + + note.command='H'-'A'; + } break; + case 0x5: { + note.command='L'-'A'; + } break; + case 0x6: { + + note.command='K'-'A'; + } break; + case 0x7: { + note.command='R'-'A'; + } break; + case 0x8: { + + note.command='X'-'A'; + } break; + case 0x9: { + + note.command='O'-'A'; + + } break; + case 0xA: { + + note.command='D'-'A'; + + } break; + case 0xB: { + + note.command='B'-'A'; + + } break; + case 0xC: { + + note.volume=note.parameter; + if (note.volume>64) + note.volume=64; + note.parameter=0; + + } break; + case 0xD: { + + note.command='C'-'A'; + note.parameter=(note.parameter>>4)*10 + (note.parameter&0xF); + + } break; + case 0xE: { //SPECIAL EFFECT! + + note.command='S'-'A'; + + switch(note.parameter>>4) { + + case 0x1: { + + note.command='F'-'A'; + note.parameter=0xF0|(note.parameter&0xF); + } break; + case 0x2: { + + note.command='E'-'A'; + note.parameter=0xF0|(note.parameter&0xF); + } break; + case 0x4: { + + note.command='S'-'A'; + note.parameter=0x30|(note.parameter&0x3); + + } break; + case 0x6: { + + note.command='S'-'A'; + note.parameter=0xB0|(note.parameter&0xF); + + } break; + case 0x7: { + note.command='S'-'A'; + note.parameter=0x40|(note.parameter&0x3); + + } break; + case 0x8: { + + note.command='S'-'A'; // wow, it's the same! + + } break; + case 0x9: { + note.command='Q'-'A'; + note.parameter=(note.parameter&0xF); + + } break; + case 0xA: { + + note.command='D'-'A'; + note.parameter=0xF|((note.parameter&0xF)<<4); + + } break; + case 0xB: { + note.command='D'-'A'; + note.parameter=0xF0|(note.parameter&0xF); + + } break; + case 0xC: + case 0xD: { + + note.command='S'-'A'; //wow, they are the same! + + } break; + case 0xE: { + note.command='S'-'A'; + note.parameter=0x60|(note.parameter&0xF); + + } break; + + default: { + + note.command=CPNote::EMPTY; + note.parameter=0; + } break; + + } + } break; + case 0xF: { + + if (note.parameter<32) + note.command='A'-'A'; + else + note.command='T'-'A'; + + } break; + } + + p_song->get_pattern(i)->set_note( column,line, note ); + } + } + } + + + + for (int i=0;i<instruments;i++) { + + CPSample_ID sid=p_song->get_sample(i)->get_sample_data(); + if (sid.is_null()) { + continue; //empty sample, not stored? + } + sm->lock_data(sid); + uint8_t *dataptr = (uint8_t*)sm->get_data(sid); + + int len=sm->get_size(sid); + for (int s=0;s<len;s++) { + + uint8_t d=file->get_byte(); + //d-=128; //convert to signed + int8_t*ds=(int8_t*)&d; + dataptr[s]=*ds; + + } + sm->unlock_data(sid); + } + + file->close(); + + return FILE_OK; + + +} + + +CPLoader_MOD::CPLoader_MOD(CPFileAccessWrapper *p_file) { + + file=p_file; +} + + +CPLoader_MOD::~CPLoader_MOD() +{ +} + + diff --git a/modules/chibi/cp_loader_mod.h b/modules/chibi/cp_loader_mod.h new file mode 100644 index 0000000000..636f4f00f2 --- /dev/null +++ b/modules/chibi/cp_loader_mod.h @@ -0,0 +1,52 @@ +/*************************************************************************/ +/* cp_loader_mod.h */ +/*************************************************************************/ +/* This file is part of: */ +/* GODOT ENGINE */ +/* http://www.godotengine.org */ +/*************************************************************************/ +/* Copyright (c) 2007-2016 Juan Linietsky, Ariel Manzur. */ +/* */ +/* Permission is hereby granted, free of charge, to any person obtaining */ +/* a copy of this software and associated documentation files (the */ +/* "Software"), to deal in the Software without restriction, including */ +/* without limitation the rights to use, copy, modify, merge, publish, */ +/* distribute, sublicense, and/or sell copies of the Software, and to */ +/* permit persons to whom the Software is furnished to do so, subject to */ +/* the following conditions: */ +/* */ +/* The above copyright notice and this permission notice shall be */ +/* included in all copies or substantial portions of the Software. */ +/* */ +/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */ +/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */ +/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/ +/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */ +/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */ +/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */ +/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ +/*************************************************************************/ +#ifndef CP_LOADER_MOD_H +#define CP_LOADER_MOD_H +#include "cp_loader.h" +/** + @author Juan Linietsky <reduz@gmail.com> +*/ +class CPLoader_MOD : public CPLoader { + + CPFileAccessWrapper *file; +public: + + bool can_load_song() { return true; } + bool can_load_sample() { return false; } + bool can_load_instrument() { return false; } + + Error load_song(const char *p_file,CPSong *p_song,bool p_sampleset); + Error load_sample(const char *p_file,CPSample *p_sample) { return FILE_UNRECOGNIZED; } + Error load_instrument(const char *p_file,CPSong *p_song,int p_instr_idx) { return FILE_UNRECOGNIZED; } + + CPLoader_MOD(CPFileAccessWrapper *p_file); + ~CPLoader_MOD(); +}; + +#endif diff --git a/modules/chibi/cp_loader_s3m.cpp b/modules/chibi/cp_loader_s3m.cpp new file mode 100644 index 0000000000..0fc15c1e2f --- /dev/null +++ b/modules/chibi/cp_loader_s3m.cpp @@ -0,0 +1,413 @@ +/*************************************************************************/ +/* cp_loader_s3m.cpp */ +/*************************************************************************/ +/* This file is part of: */ +/* GODOT ENGINE */ +/* http://www.godotengine.org */ +/*************************************************************************/ +/* Copyright (c) 2007-2016 Juan Linietsky, Ariel Manzur. */ +/* */ +/* Permission is hereby granted, free of charge, to any person obtaining */ +/* a copy of this software and associated documentation files (the */ +/* "Software"), to deal in the Software without restriction, including */ +/* without limitation the rights to use, copy, modify, merge, publish, */ +/* distribute, sublicense, and/or sell copies of the Software, and to */ +/* permit persons to whom the Software is furnished to do so, subject to */ +/* the following conditions: */ +/* */ +/* The above copyright notice and this permission notice shall be */ +/* included in all copies or substantial portions of the Software. */ +/* */ +/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */ +/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */ +/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/ +/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */ +/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */ +/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */ +/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ +/*************************************************************************/ + +#include "cp_loader_s3m.h" + +#define BITBOOL(m_exp) ((m_exp)?1:0) + + +CPLoader::Error CPLoader_S3M::load_header() { + + int i; + + + file->get_byte_array((uint8_t*)header.songname,28); + header.t1a=file->get_byte(); + header.type=file->get_byte(); + file->get_byte_array((uint8_t*)header.unused1,2); + header.ordnum=file->get_word(); + header.insnum=file->get_word(); + header.patnum=file->get_word(); + header.flags=file->get_word(); + header.tracker=file->get_word(); + header.fileformat=file->get_word(); + file->get_byte_array((uint8_t*)header.scrm,4); + header.scrm[4]=0; + + if (header.scrm[0]!='S' || header.scrm[1]!='C' || header.scrm[2]!='R' || header.scrm[3]!='M') + return FILE_UNRECOGNIZED; + + header.mastervol=file->get_byte(); + header.initspeed=file->get_byte(); + header.inittempo=file->get_byte(); + header.mastermult=file->get_byte(); + header.ultraclick=file->get_byte(); + header.pantable=file->get_byte(); + file->get_byte_array((uint8_t*)header.unused2,8); + header.special=file->get_word(); + file->get_byte_array((uint8_t*)header.channels,32); + + file->get_byte_array((uint8_t*)header.orderlist,header.ordnum); + + header.scrm[4]=0; + if (header.scrm[0]!='S' || header.scrm[1]!='C' || header.scrm[2]!='R' || header.scrm[3]!='M') //again? + return FILE_UNRECOGNIZED; + //sample parapointers + for (i=0;i<header.insnum;i++) { + + int parapointer; + parapointer=file->get_word(); + parapointer=(parapointer*16); + sample_parapointers[i]=parapointer; + } + //pattern + for (i=0;i<header.patnum;i++) { + + int parapointer; + parapointer=file->get_word(); + parapointer=(parapointer*16); + pattern_parapointers[i]=parapointer; + } + + if (header.pantable==252) { + + file->get_byte_array((uint8_t*)header.pannings,32); + } + + return FILE_OK; + + +} + + +void CPLoader_S3M::set_header() { + + + + + song->set_name( header.songname ); +// song->variables.filename= + + song->set_row_highlight_minor( 4 ); + song->set_row_highlight_major( 16 ); + song->set_mixing_volume( header.mastervol ); + song->set_linear_slides( false ); + song->set_old_effects( !(header.flags&64) ); + song->set_compatible_gxx( true ); + + song->set_global_volume( header.mastermult ); + song->set_speed( header.initspeed ); + song->set_tempo( header.inittempo ); + + //[TODO] Set Panning Positions.. ? + + for (int i=0;i<header.ordnum;i++) song->set_order(i,header.orderlist[i]); + +} + +CPLoader::Error CPLoader_S3M::load_sample(CPSample *p_sample) { + + + + int type=file->get_byte(); + + char filename[13]; + file->get_byte_array((uint8_t*)filename,12); + filename[12]=0; + + + uint32_t samplepos=(uint32_t)file->get_byte() << 16; + samplepos|=file->get_word(); + samplepos*=16; +// printf("sample at %i\n",samplepos); + /**/ + int sample_size=file->get_dword(); + + + int loop_begin=file->get_dword(); + int loop_end=file->get_dword(); + + int def_volume=file->get_byte();; + int dsk=file->get_byte(); + int pack=file->get_byte(); + + int flags=file->get_byte(); + int c2speed=file->get_dword(); + + file->get_dword(); //useless crap + file->get_dword(); + file->get_dword(); + + + char name[29]; + file->get_byte_array((uint8_t*)name,28); + name[28]=0; + + p_sample->set_default_volume(def_volume); + p_sample->set_name(name); + + char scrs[5]; + file->get_byte_array((uint8_t*)scrs,4); + scrs[4]=0; + + + + bool data_is_16bits=flags&4; + bool data_is_stereo=flags&2; + + if (type==0) { + //empty sample + return FILE_OK; + } + + + if ((type!=1) || scrs[0]!='S' || scrs[1]!='C' || scrs[2]!='R' || scrs[3]!='S' ) { +// printf("type: %i, %c%c%c%c\n",type,scrs[0],scrs[1],scrs[2],scrs[3]); + CP_PRINTERR("Not an S3M CPSample!"); + return FILE_CORRUPTED; + } + + //p_sample->data.set_c5_freq(p_sample->c2spd<<1); + + file->seek(samplepos); + + int real_sample_size=sample_size<<BITBOOL(data_is_16bits); + real_sample_size<<=BITBOOL(data_is_stereo); + + CPSampleManager *sm=CPSampleManager::get_singleton(); + + CPSample_ID id =sm->create( data_is_16bits, data_is_stereo, sample_size ); + + if (id.is_null()) + return FILE_OUT_OF_MEMORY; + + sm->lock_data(id); + void *dataptr = sm->get_data(id); + + int chans = (data_is_stereo?2:1); + for (int c=0;c<chans;c++) { + for (int i=0;i<sample_size;i++) { + + if (data_is_16bits) { + + uint16_t s=file->get_word(); + s-=32768; //toggle sign + + int16_t *v=(int16_t*)&s; + ((int16_t*)dataptr)[i*chans+c]=*v; + } else { + + + int8_t *v; + uint8_t s=file->get_byte(); + s-=128; //toggle sign + v=(int8_t*)&s; + ((int8_t*)dataptr)[i*chans+c]=*v; + + } + + } + + } + + sm->unlock_data(id); + + + sm->set_loop_begin( id, loop_begin ); + sm->set_loop_end( id, loop_end ); + sm->set_loop_type( id, (flags&1) ? CP_LOOP_FORWARD : CP_LOOP_NONE ); + sm->set_c5_freq( id, c2speed << 1 ); + p_sample->set_sample_data(id); + + /* Scream tracker previous to 3.10 seems to be buggy, as in, wont save what is after the sample loop, including the loop end point. Because of this I must fix it by habd */ + if (flags&1) { + + for (int c=0;c<(data_is_stereo?2:1);c++) { + sm->set_data( id, loop_end, sm->get_data( id, loop_begin,c ),c ); + + } + } + + + return FILE_OK; + +} + + +CPLoader::Error CPLoader_S3M::load_pattern(CPPattern *p_pattern) { + + int row=0,flag,ch; + CPNote n; + int length,accum=0; + + length=file->get_word(); + p_pattern->set_length(64); + + /* clear pattern data */ + while((row<64) && (accum<=length) ) { + flag=file->get_byte(); + accum++; + + n.clear(); + if(flag) { + // ch=remap[flag&31]; +// ch=remap[flag&31]; +// if(ch!=-1) +// n=s3mbuf[(64U*ch)+row]; +// else +// n=&dummy; + + ch=flag&31; + + if(flag&32) { + n.note=file->get_byte(); + if (n.note==255) { + + n.note=CPNote::EMPTY; + } else if (n.note==254) { + + n.note=CPNote::CUT; + } else { + + n.note=((n.note>>4)*12)+(n.note&0xF); + } + + n.instrument=file->get_byte()-1; + accum+=2; + + } + if(flag&64) { + n.volume=file->get_byte(); + if (n.volume>64) n.volume=64; + accum++; + + } + if(flag&128) { + n.command=file->get_byte()-1; + n.parameter=file->get_byte(); + accum+=2; + } + + p_pattern->set_note(ch,row,n); + } else row++; + } + return FILE_OK; + + +} + +CPLoader::Error CPLoader_S3M::load_sample(const char *p_file,CPSample *p_sample) { + + return FILE_UNRECOGNIZED; +} +CPLoader::Error CPLoader_S3M::load_instrument(const char *p_file,CPSong *p_song,int p_instr_idx) { + + return FILE_UNRECOGNIZED; + +} + + +CPLoader::Error CPLoader_S3M::load_samples() { + + int i; + + for(i=0;i<header.insnum;i++) { + + file->seek(sample_parapointers[i]); + load_sample(song->get_sample(i)); + sample_count++; + } + + return FILE_OK; +} + +CPLoader::Error CPLoader_S3M::load_patterns() { + + int i; + + Error err; + for(i=0;i<header.patnum;i++) { + + file->seek(pattern_parapointers[i]); + + err=load_pattern(song->get_pattern(i) ); + CP_ERR_COND_V(err,err); + + + pattern_count++; + } + return FILE_OK; + +} + +CPLoader::Error CPLoader_S3M::load_song(const char *p_file,CPSong *p_song,bool p_sampleset) { + + song=p_song; + + if (file->open(p_file,CPFileAccessWrapper::READ)) { + //printf("Can't open file! %s\n",p_file); + return FILE_CANNOT_OPEN; + }; + + sample_count=0; + pattern_count=0; + + //printf("LOADING HEADER\n"); + CPLoader::Error err; + if ((err=load_header())) { + file->close(); + CP_ERR_COND_V(err,err); + + } + + song->reset(); //file type recognized, reset song! + + set_header(); + + //printf("LOADING SAMPLES\n"); + + if ((err=load_samples())) { + file->close(); + + CP_ERR_COND_V(err,err); + } + + //printf("LOADING PATTERNS\n"); + + if ((err=load_patterns())) { + + file->close(); + return err; + } + + file->close(); + + return FILE_OK; +} + + + +CPLoader_S3M::CPLoader_S3M(CPFileAccessWrapper *p_file){ + + file=p_file; + +} +CPLoader_S3M::~CPLoader_S3M(){ +} + diff --git a/modules/chibi/cp_loader_s3m.h b/modules/chibi/cp_loader_s3m.h new file mode 100644 index 0000000000..175e5e80fe --- /dev/null +++ b/modules/chibi/cp_loader_s3m.h @@ -0,0 +1,111 @@ +/*************************************************************************/ +/* cp_loader_s3m.h */ +/*************************************************************************/ +/* This file is part of: */ +/* GODOT ENGINE */ +/* http://www.godotengine.org */ +/*************************************************************************/ +/* Copyright (c) 2007-2016 Juan Linietsky, Ariel Manzur. */ +/* */ +/* Permission is hereby granted, free of charge, to any person obtaining */ +/* a copy of this software and associated documentation files (the */ +/* "Software"), to deal in the Software without restriction, including */ +/* without limitation the rights to use, copy, modify, merge, publish, */ +/* distribute, sublicense, and/or sell copies of the Software, and to */ +/* permit persons to whom the Software is furnished to do so, subject to */ +/* the following conditions: */ +/* */ +/* The above copyright notice and this permission notice shall be */ +/* included in all copies or substantial portions of the Software. */ +/* */ +/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */ +/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */ +/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/ +/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */ +/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */ +/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */ +/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ +/*************************************************************************/ + +#ifndef CP_LOADER_S3M_H +#define CP_LOADER_S3M_H + +#include "cp_loader.h" + +/** + *@author Juan Linietsky + */ +/****************************** + loader_s3m.h + ---------- +Scream Tracker Module CPLoader! +It lacks support for +individual sample loading +and reorganizing the columns. +********************************/ + + + + +class CPLoader_S3M : public CPLoader { + + struct S3M_Header { + char songname[28]; + uint8_t t1a; + uint8_t type; + uint8_t unused1[2]; + uint16_t ordnum; + uint16_t insnum; + uint16_t patnum; + uint16_t flags; + uint16_t tracker; + uint16_t fileformat; + char scrm[5]; + uint8_t mastervol; + uint8_t initspeed; + uint8_t inittempo; + uint8_t mastermult; + uint8_t ultraclick; + uint8_t pantable; + uint8_t unused2[8]; + uint16_t special; + uint8_t channels[32]; + uint8_t pannings[32]; + uint8_t orderlist[300]; + }; + + + int sample_parapointers[CPSong::MAX_SAMPLES]; + int pattern_parapointers[CPSong::MAX_PATTERNS]; + + Error load_header(); + void set_header(); + Error load_sample(CPSample *p_sample); + Error load_pattern(CPPattern *p_pattern); + Error load_patterns(); + + Error load_samples(); + + S3M_Header header; + int sample_count; + int pattern_count; + + CPFileAccessWrapper *file; + CPSong *song; +public: + + bool can_load_song() { return true; } + bool can_load_sample() { return false; } + bool can_load_instrument() { return false; } + + Error load_song(const char *p_file,CPSong *p_song,bool p_sampleset); + Error load_sample(const char *p_file,CPSample *p_sample); + Error load_instrument(const char *p_file,CPSong *p_song,int p_instr_idx); + + CPLoader_S3M(CPFileAccessWrapper *p_file); + ~CPLoader_S3M(); +}; + + + +#endif diff --git a/modules/chibi/cp_loader_xm.cpp b/modules/chibi/cp_loader_xm.cpp new file mode 100644 index 0000000000..bff8615a32 --- /dev/null +++ b/modules/chibi/cp_loader_xm.cpp @@ -0,0 +1,752 @@ +/*************************************************************************/ +/* cp_loader_xm.cpp */ +/*************************************************************************/ +/* This file is part of: */ +/* GODOT ENGINE */ +/* http://www.godotengine.org */ +/*************************************************************************/ +/* Copyright (c) 2007-2016 Juan Linietsky, Ariel Manzur. */ +/* */ +/* Permission is hereby granted, free of charge, to any person obtaining */ +/* a copy of this software and associated documentation files (the */ +/* "Software"), to deal in the Software without restriction, including */ +/* without limitation the rights to use, copy, modify, merge, publish, */ +/* distribute, sublicense, and/or sell copies of the Software, and to */ +/* permit persons to whom the Software is furnished to do so, subject to */ +/* the following conditions: */ +/* */ +/* The above copyright notice and this permission notice shall be */ +/* included in all copies or substantial portions of the Software. */ +/* */ +/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */ +/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */ +/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/ +/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */ +/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */ +/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */ +/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ +/*************************************************************************/ + +#include "cp_loader_xm.h" +#include "cp_tables.h" + +#define ABORT_LOAD { file->close(); return FILE_CORRUPTED; } + + + + +CPLoader::Error CPLoader_XM::load_song(const char *p_file,CPSong *p_song,bool p_sampleset) { + + song=p_song; + + if (file->open(p_file,CPFileAccessWrapper::READ)) { + + return FILE_CANNOT_OPEN; + }; + + + /************************************** + LOAD HEADER + ***************************************/ + + file->get_byte_array(header.idtext,17); + header.idtext[17]=0; + + file->get_byte_array(header.songname,20); + + + + header.songname[20]=0; + header.hex1a=file->get_byte(); + if (header.hex1a!=0x1A) { //XM "magic" byte.. this sucks :) + + file->close(); + return FILE_UNRECOGNIZED; + + } + + + //magic byte sucks, but can't do much about it.. + + song->reset(); //must reset the song + + song->set_name( (const char*)header.songname ); + + file->get_byte_array(header.trackername,20); + header.trackername[20]=0; + + + header.version=file->get_word(); + + header.headersize=file->get_dword(); + + header.songlength=file->get_word(); + + header.restart_pos=file->get_word(); + + header.channels_used=file->get_word(); + + header.patterns_used=file->get_word(); + + header.instruments_used=file->get_word(); + + song->set_linear_slides( file->get_word() ); + + song->set_speed( file->get_word() ); + + song->set_tempo( file->get_word() ); + song->set_instruments( true ); + + file->get_byte_array(header.orderlist,256); + + for (int i=0;i<header.songlength;i++) { + + if (i>199) + break; + song->set_order(i,header.orderlist[i]); + } + + /************************************** + LOAD PATTERNS + ***************************************/ + + for (int i=0;i<header.patterns_used;i++) { + + uint32_t aux,rows; + + aux=file->get_dword(); //length + aux=file->get_byte(); //packing type + rows=aux=file->get_word(); //rows! + + song->get_pattern(i)->set_length( aux ); + + aux=file->get_word(); //packed size + if (aux==0) + continue; + //unpaaack! + for(int j=0;j<(int)rows;j++) + for(int k=0;k<header.channels_used;k++) { + + CPNote aux_note; + uint8_t aux_byte; + //uint8_t field; + aux_byte=file->get_byte(); //packing type + if (!(aux_byte&0x80)) { + + aux_note.note=aux_byte; + aux_byte=0xFE; //if bit 7 not set, read all of them except the note + } + + if (aux_byte&1) aux_note.note=file->get_byte(); + if (aux_byte&2) aux_note.instrument=file->get_byte(); + if (aux_byte&4) aux_note.volume=file->get_byte(); + if (aux_byte&8) aux_note.command=file->get_byte(); + if (aux_byte&16) aux_note.parameter=file->get_byte(); + + if (aux_note.note!=CPNote::EMPTY) { + + if (aux_note.note==97) aux_note.note=CPNote::OFF; + else { + aux_note.note+=11; //octave minus one (XM C-0 is 1, not zero ) + } + } + if (aux_note.instrument!=CPNote::EMPTY) { + + if ((aux_note.instrument>0) && (aux_note.instrument<100)) + aux_note.instrument--; + else + aux_note.instrument=CPNote::EMPTY; + } + if (aux_note.volume!=CPNote::EMPTY) { + + if (aux_note.volume<0x10) {} + else if (aux_note.volume<0x50) { + + aux_note.volume-=0x10; + + } else if (aux_note.volume<0x60) { + // + aux_note.volume=CPNote::EMPTY; + + } else if (aux_note.volume<0x70) { + //60 -- volume slide down + aux_note.volume-=0x60; + if (aux_note.volume>9) aux_note.volume=9; + aux_note.volume+=95; + + } else if (aux_note.volume<0x80) { + //70 -- volume slide up + aux_note.volume-=0x70; + if (aux_note.volume>9) aux_note.volume=9; + aux_note.volume+=85; + + + } else if (aux_note.volume<0x90) { + //80 -- fine volume slide down + aux_note.volume-=0x80; + if (aux_note.volume>9) aux_note.volume=9; + aux_note.volume+=75; + + + } else if (aux_note.volume<0xA0) { + //9 -- fine volume slide up + + aux_note.volume-=0x90; + if (aux_note.volume>9) aux_note.volume=9; + + aux_note.volume+=65; + + + + } else if (aux_note.volume<0xB0) { + //A -- set vibrato speed + aux_note.volume=CPNote::EMPTY; + + } else if (aux_note.volume<0xC0) { + //B -- vibrato + aux_note.volume-=0xB0; + if (aux_note.volume>9) aux_note.volume=9; + aux_note.volume+=203; + + + } else if (aux_note.volume<0xD0) { + //C -- set panning + int aux=aux_note.volume-=0xC0; + aux=aux*65/0xF; + aux_note.volume=128+aux; + + } else if (aux_note.volume<0xE0) { + aux_note.volume=CPNote::EMPTY; + + + } else if (aux_note.volume<0xF0) { + aux_note.volume=CPNote::EMPTY; + + + } else { + //F -- tone porta + aux_note.volume-=0xF0; + aux_note.volume*=9; + aux_note.volume/=0xF; + aux_note.volume+=193; + } + } + if (aux_note.command!=CPNote::EMPTY) { + + switch(aux_note.command) { + + case 0x0: + aux_note.command='J'-'A'; + break; + case 0x1: + aux_note.command='F'-'A'; + break; + case 0x2: + aux_note.command='E'-'A'; + break; + case 0x3: + aux_note.command='G'-'A'; + break; + case 0x4: + aux_note.command='H'-'A'; + break; + case 0x5: + aux_note.command='L'-'A'; + break; + case 0x6: + aux_note.command='K'-'A'; + break; + case 0x7: + aux_note.command='R'-'A'; + break; + case 0x8: + aux_note.command='X'-'A'; + break; + case 0x9: + aux_note.command='O'-'A'; + break; + case 0xa: + aux_note.command='D'-'A'; + break; + case 0xb: + aux_note.command='B'-'A'; + break; + case 0xc: + //printf("XM Import: Warning! effect C (set volume) not implemented!\n"); + break; + case 0xd: + aux_note.command='C'-'A'; + break; + + case 0xe: /* Extended effects */ + + aux_note.command='S'-'A'; + switch(aux_note.parameter>>4) { + case 0x1: /* XM fine porta up */ + if (!(aux_note.parameter&0xF)) { aux_note.command=CPNote::EMPTY; aux_note.parameter=0; break; } + aux_note.command='F'-'A'; + aux_note.parameter=0xF0|(aux_note.parameter&0xF); + break; + case 0x2: /* XM fine porta down */ + if (!(aux_note.parameter&0xF)) { aux_note.command=CPNote::EMPTY; aux_note.parameter=0; break; } + aux_note.command='E'-'A'; + aux_note.parameter=0xF0|(aux_note.parameter&0xF); + break; + case 0xa: /* XM fine volume up */ + if (!(aux_note.parameter&0xF)) { aux_note.command=CPNote::EMPTY; aux_note.parameter=0; break; } + aux_note.command='D'-'A'; + aux_note.parameter=0x0F|((aux_note.parameter&0xF)<<4); + + break; + case 0xb: /* XM fine volume down */ + if (!(aux_note.parameter&0xF)) { aux_note.command=CPNote::EMPTY; aux_note.parameter=0; break; } + aux_note.command='D'-'A'; + aux_note.parameter=0xF0|(aux_note.parameter&0xF); + + break; + case 0x9: /* XM fine volume down */ + if (!(aux_note.parameter&0xF)) { aux_note.command=CPNote::EMPTY; aux_note.parameter=0; break; } + aux_note.command='Q'-'A'; + aux_note.parameter=0x00|(aux_note.parameter&0xF); + break; + + case 0xc: //notecut + + aux_note.parameter=0xC0|(aux_note.parameter&0xF); + break; + + case 0xd: //notedelay + + aux_note.parameter=0xD0|(aux_note.parameter&0xF); + break; + + case 0xe: //patterndelay + + aux_note.parameter=0xE0|(aux_note.parameter&0xF); + break; + } + + break; + case 0xf: + if (aux_note.parameter<32) { + aux_note.command='A'-'A'; + } else { + aux_note.command='T'-'A'; + } + break; + case 'G'-55: + aux_note.command='V'-'A'; + break; + case 'H'-55: + aux_note.command='W'-'A'; + break; + case 'K'-55: + if (aux_note.note!=CPNote::EMPTY) break; + aux_note.note=CPNote::OFF; + break; + case 'P'-55: + aux_note.command='P'-'A'; + break; + case 'R'-55: + aux_note.command='Q'-'A'; + break; + case 'T'-55: + aux_note.command='I'-'A'; + break; + default: { + + aux_note.command=CPNote::EMPTY; + } + } + + + } + + song->get_pattern( i)->set_note( k,j,aux_note ); + } + } + + /************************************** + LOAD INSTRUMENTS! + ***************************************/ + + for (int i=0;i<header.instruments_used;i++) { + + + uint32_t aux; + int sampnum; + + CPInstrument &instrument=*song->get_instrument(i); + uint32_t cpos=file->get_pos(); + //printf("pos is %i\n",cpos); + + + +/* +4 */ uint32_t hsize=file->get_dword(); //header length + + char instrname[23]; + instrname[22]=0; + + file->get_byte_array((uint8_t*)instrname,22); +//XM_LOAD_DEBUG printf("name is %s\n",instrname); + +/* +27 */ aux=file->get_byte(); //byte that must be ignored +//XM_LOAD_DEBUG printf("header size is %i\n",hsize); + +/* +29 */ sampnum=file->get_word(); + +//XM_LOAD_DEBUG printf("samples %i\n",sampnum); + + + instrument.set_name( instrname ); +// printf("Header Len: %i, CPInstrument %i, %i samples , name: s,\n",hsize,i,sampnum,instrname); + + if (sampnum==0) { + //aux=file->get_dword(); //Why is this for? -- for nothing, skipped + if (hsize) { + + file->seek( cpos+hsize ); //skip header if size has been specified + } + continue; + } + +/* +33 */ file->get_dword(); + + if (Error result=load_instrument_internal(&instrument,false,cpos,hsize,sampnum)) { + + CP_PRINTERR("Error loading instrument"); + file->close(); + return result; + } + + } +// + file->close(); + return FILE_OK; +} + +CPLoader::Error CPLoader_XM::load_instrument_internal(CPInstrument *p_instr,bool p_xi,int p_cpos, int p_hsize, int p_sampnum) { + + int sampnum; + uint32_t aux; + uint8_t notenumb[96]; + uint16_t panenv[24],volenv[24]; + int volpoints,panpoints; + int vol_loop_begin,vol_loop_end,vol_sustain_loop; + int pan_loop_begin,pan_loop_end,pan_sustain_loop; + char instrname[23]; + int sample_index[16]={-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1}; //-1 means no index! + + instrname[22]=0; + + +/* +129 */ file->get_byte_array((uint8_t*)notenumb,96); + for (int j=0;j<24;j++) { + volenv[j]=file->get_word(); + } + for (int j=0;j<24;j++) { + panenv[j]=file->get_word(); + } + +/* +177 */ +/* +225 */ +/* +226 */ volpoints=file->get_byte(); +/* +227 */ panpoints=file->get_byte(); +/* +230 */ vol_sustain_loop=file->get_byte(); +/* +228 */ vol_loop_begin=file->get_byte(); +/* +229 */ vol_loop_end=file->get_byte(); + +//XM_LOAD_DEBUG printf("1- volpoints: %i, panpoints: %i, susloop: %i, loop begin: %i, loop end %i\n",volpoints,panpoints,vol_sustain_loop,vol_loop_begin,vol_loop_end); + pan_sustain_loop=file->get_byte(); +/* +231 */ pan_loop_begin=file->get_byte(); +/* +232 */ pan_loop_end=file->get_byte(); + + + +/* +234 */ aux=file->get_byte(); + p_instr->get_volume_envelope()->reset(); + p_instr->get_volume_envelope()->set_enabled(aux&1); + p_instr->get_volume_envelope()->set_sustain_loop_enabled((aux&2)?true:false); + p_instr->get_volume_envelope()->set_loop_enabled((aux&4)?true:false); +/* +235 */ aux=file->get_byte(); + p_instr->get_pan_envelope()->reset(); + p_instr->get_pan_envelope()->set_enabled(aux&1); + p_instr->get_pan_envelope()->set_sustain_loop_enabled((aux&2)?true:false); + p_instr->get_pan_envelope()->set_loop_enabled((aux&4)?true:false); + +/* +239 */ aux=file->get_dword(); // sadly, cant use those +/* +241 */ p_instr->set_volume_fadeout( file->get_word() >> 4 ); +/* +243 */ aux=file->get_word(); // reserved! + + + + for (int j=0;j<volpoints;j++) { + int ofs=volenv[j*2]; + int val=volenv[j*2+1]; + p_instr->get_volume_envelope()->add_position(ofs,val); + + } + + //make sure minimum is 2 + while (p_instr->get_volume_envelope()->get_node_count()<2) { + + p_instr->get_volume_envelope()->add_position( p_instr->get_volume_envelope()->get_node_count()*20,64 ); + } + + for (int j=0;j<panpoints;j++) { + int ofs=panenv[j*2]; + int val=panenv[j*2+1]; + p_instr->get_pan_envelope()->add_position(ofs,val-32); + } + + //make sure minimum is 2 + while (p_instr->get_pan_envelope()->get_node_count()<2) { + + p_instr->get_pan_envelope()->add_position( p_instr->get_pan_envelope()->get_node_count()*20,0 ); + } + + + p_instr->get_volume_envelope()->set_loop_begin(vol_loop_begin); + p_instr->get_volume_envelope()->set_loop_end(vol_loop_end); + p_instr->get_volume_envelope()->set_sustain_loop_end(vol_sustain_loop); + p_instr->get_volume_envelope()->set_sustain_loop_begin(vol_sustain_loop); + p_instr->get_pan_envelope()->set_loop_begin(pan_loop_begin); + p_instr->get_pan_envelope()->set_loop_end(pan_loop_end); + p_instr->get_pan_envelope()->set_sustain_loop_end(pan_sustain_loop); + p_instr->get_pan_envelope()->set_sustain_loop_begin(pan_sustain_loop); + + + if (!p_xi) { + + if ((file->get_pos()-p_cpos)<p_hsize) { + + uint8_t junkbuster[500]; + + //printf("extra junk XM instrument in header! hsize is %i, extra junk: %i\n",p_hsize,(file->get_pos()-p_cpos)); + //printf("extra: %i\n",p_hsize-(file->get_pos()-p_cpos)); + file->get_byte_array((uint8_t*)junkbuster,p_hsize-(file->get_pos()-p_cpos)); + } + + sampnum=p_sampnum; + } else { + + uint8_t junkbuster[500]; + file->get_byte_array((uint8_t*)junkbuster,20); //14 bytes? + + sampnum=file->get_word(); + + } + + + CPSampleManager *sm=CPSampleManager::get_singleton(); + + /*SAMPLE!!*/ + + for (int j=0;j<sampnum;j++) { + + if (j>16) ABORT_LOAD; + + + int s_idx=-1; + for (int s=0;s<CPSong::MAX_SAMPLES;s++) { + + if (song->get_sample(s)->get_sample_data().is_null()) { + //empty sample! + s_idx=s; + break; + } + } + + if (s_idx==-1) ABORT_LOAD; + //printf("free sample: %i\n",s_idx); + + + CPSample& sample=*song->get_sample(s_idx); + + int sample_size=file->get_dword(); + int tmp_loop_begin=file->get_dword(); + + int tmp_loop_end=file->get_dword(); + + sample.set_default_volume(file->get_byte()); + + uint8_t ftb=file->get_byte(); + int8_t *fts=(int8_t*)&ftb; + int finetune=*fts; + uint32_t flags=file->get_byte(); + + if (flags&16) { // is 16 bits.. at flag 16.. fun :) + + tmp_loop_end/=2; + tmp_loop_begin/=2; + sample_size/=2; + } + + + CPSample_ID sample_data=sm->create( flags&16, false, sample_size ); + + sample.set_sample_data(sample_data); + sm->set_loop_begin(sample_data,tmp_loop_begin); + sm->set_loop_end(sample_data,tmp_loop_end+tmp_loop_begin); + + sm->set_loop_type( sample_data, (flags&3)?( (flags&2) ? CP_LOOP_BIDI : CP_LOOP_FORWARD ):CP_LOOP_NONE ); + + + + sample.set_pan_enabled(true); + sample.set_pan(file->get_byte()*64/255); + uint8_t noteb=file->get_byte(); + int8_t *notes=(int8_t*)¬eb; + int note_offset=*notes; + note_offset+=48; + //note_offset+=60; + + + + //int linear_period=10*12*16*4 - (note_offset)*16*4 - finetune/2; + //int freq=(int)(8363*pow(2.0,(double)(6*12*16*4 - linear_period) / (double)(12*16*4))); + + //sm->set_c5_freq( sample_data, freq); + sm->set_c5_freq( sample_data, CPTables::get_linear_frequency(CPTables::get_linear_period(note_offset<<1,finetune)) ); + //printf("NOTE %i,fine %i\n",note_offset,finetune); + + char auxb; + auxb=file->get_byte(); //reserved? + file->get_byte_array((uint8_t*)instrname,22); + sample.set_name(instrname); + + sample_index[j]=s_idx; + } + + /*SAMPLE __DATA__!!*/ + + for (int j=0;j<sampnum;j++) { + + if (sample_index[j]==-1) continue; + + CPSample *sample=song->get_sample(sample_index[j]); + CPSample_ID sid=sample->get_sample_data(); + + sm->lock_data(sid); + + void*dataptr=sm->get_data(sid); + + if (sm->is_16bits( sid)) { + + int16_t old=0; + + + for (int k=0;k<sm->get_size(sid);k++) { + + int16_t newsample; + int16_t sampleval=file->get_word(); + newsample=sampleval+old; + old=newsample; + + ((int16_t*)dataptr)[k]=newsample; + //sm->set_data( sid, k, newsample ); + } + } else { + + int8_t old=0; + + + for (int k=0;k<sm->get_size(sid);k++) { + + int8_t newsample; + int8_t sampleval=file->get_byte(); + newsample=sampleval+old; + old=newsample; + + ((int8_t*)dataptr)[k]=newsample; + + //sm->set_data( sid, k, (int16_t)newsample << 8 ); + + } + } + + sm->unlock_data(sid); + + } + + for (int j=0;j<96;j++) { + + int val=notenumb[j]; + if ((val<0) || (val>15)) continue; + else val=sample_index[val]; + if (val==-1) continue; + p_instr->set_sample_number( 12+j,val ); + } + + + return FILE_OK; +} + + + +CPLoader::Error CPLoader_XM::load_sample(const char *p_file,CPSample *p_sample) { + + return FILE_UNRECOGNIZED; +} + + +/* Compute CPInstrument Info */ +CPLoader::Error CPLoader_XM::load_instrument(const char *p_file,CPSong *p_song,int p_instr_idx) { + + if ( file->open(p_file,CPFileAccessWrapper::READ) ) return FILE_CANNOT_OPEN; + //int i; + song=p_song; + CPInstrument& instr=*p_song->get_instrument( p_instr_idx ); + int aux; + + + char buffer[500]; + file->get_byte_array((uint8_t*)buffer,0x15); + buffer[8]=0; + if ( buffer[0]!='E' || + buffer[1]!='x' || + buffer[2]!='t' || + buffer[3]!='e' || + buffer[4]!='n' || + buffer[5]!='d' || + buffer[6]!='e' || + buffer[7]!='d') { + file->close(); + return FILE_UNRECOGNIZED; + } + + file->get_byte_array((uint8_t*)buffer,0x16); + buffer[0x16]=0; + instr.set_name(buffer); + aux=file->get_byte(); //says ignore ti + /*if(aux!=0x1a) { I'm not sure. this is supposed to be ignored... + + file->close(); + return FILE_UNRECOGNIZED; + } */ + + file->get_byte_array((uint8_t*)buffer,0x14); //somethingaboutthename + aux=file->get_word(); //version or blahblah + + if (load_instrument_internal(&instr,true,0,0)) { + + file->close(); + return FILE_CORRUPTED; + } + + file->close(); //ook, we got it.. + + + return FILE_OK; + +} + + + +CPLoader_XM::CPLoader_XM(CPFileAccessWrapper *p_file){ + + file=p_file; +} +CPLoader_XM::~CPLoader_XM(){ +} + diff --git a/modules/chibi/cp_loader_xm.h b/modules/chibi/cp_loader_xm.h new file mode 100644 index 0000000000..9ae480cc8f --- /dev/null +++ b/modules/chibi/cp_loader_xm.h @@ -0,0 +1,89 @@ +/*************************************************************************/ +/* cp_loader_xm.h */ +/*************************************************************************/ +/* This file is part of: */ +/* GODOT ENGINE */ +/* http://www.godotengine.org */ +/*************************************************************************/ +/* Copyright (c) 2007-2016 Juan Linietsky, Ariel Manzur. */ +/* */ +/* Permission is hereby granted, free of charge, to any person obtaining */ +/* a copy of this software and associated documentation files (the */ +/* "Software"), to deal in the Software without restriction, including */ +/* without limitation the rights to use, copy, modify, merge, publish, */ +/* distribute, sublicense, and/or sell copies of the Software, and to */ +/* permit persons to whom the Software is furnished to do so, subject to */ +/* the following conditions: */ +/* */ +/* The above copyright notice and this permission notice shall be */ +/* included in all copies or substantial portions of the Software. */ +/* */ +/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */ +/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */ +/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/ +/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */ +/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */ +/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */ +/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ +/*************************************************************************/ + +#ifndef CP_LOADER_XM_H +#define CP_LOADER_XM_H + +#include "cp_loader.h" + + +/** + *@author red + */ + + + + +class CPLoader_XM : public CPLoader { + + + struct XM_Header { + + uint8_t idtext[18]; + uint8_t songname[21]; + uint8_t hex1a; // ? + uint8_t trackername[21]; + uint16_t version; + uint32_t headersize; //from here + + uint16_t songlength; //pattern ordertable + uint16_t restart_pos; + uint16_t channels_used; + uint16_t patterns_used; + uint16_t instruments_used; + uint16_t use_linear_freq; + uint16_t tempo; + uint16_t speed; + uint8_t orderlist[256]; + + } header; + + CPFileAccessWrapper *file; + + Error load_instrument_internal(CPInstrument *pint,bool p_xi,int p_cpos, int p_hsize, int p_sampnumb=-1); + CPSong *song; + +public: + + bool can_load_song() { return true; } + bool can_load_sample() { return false; } + bool can_load_instrument() { return true; } + + Error load_song(const char *p_file,CPSong *p_song,bool p_sampleset); + Error load_sample(const char *p_file,CPSample *p_sample); + Error load_instrument(const char *p_file,CPSong *p_song,int p_instr_idx); + + + CPLoader_XM(CPFileAccessWrapper *p_file); + ~CPLoader_XM(); +}; + + + +#endif diff --git a/modules/chibi/cp_mixer.h b/modules/chibi/cp_mixer.h new file mode 100644 index 0000000000..7ad22ac146 --- /dev/null +++ b/modules/chibi/cp_mixer.h @@ -0,0 +1,115 @@ +/*************************************************************************/ +/* cp_mixer.h */ +/*************************************************************************/ +/* This file is part of: */ +/* GODOT ENGINE */ +/* http://www.godotengine.org */ +/*************************************************************************/ +/* Copyright (c) 2007-2016 Juan Linietsky, Ariel Manzur. */ +/* */ +/* Permission is hereby granted, free of charge, to any person obtaining */ +/* a copy of this software and associated documentation files (the */ +/* "Software"), to deal in the Software without restriction, including */ +/* without limitation the rights to use, copy, modify, merge, publish, */ +/* distribute, sublicense, and/or sell copies of the Software, and to */ +/* permit persons to whom the Software is furnished to do so, subject to */ +/* the following conditions: */ +/* */ +/* The above copyright notice and this permission notice shall be */ +/* included in all copies or substantial portions of the Software. */ +/* */ +/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */ +/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */ +/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/ +/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */ +/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */ +/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */ +/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ +/*************************************************************************/ + +#ifndef CP_MIXER_H +#define CP_MIXER_H + +#include "cp_sample_defs.h" + +/**Abstract base class representing a mixer + *@author Juan Linietsky + */ + + +/****************************** + mixer.h + ---------- + +Abstract base class for the mixer. +This is what the player uses to setup +voices and stuff.. this way +it can be abstracted to hardware +devices or other stuff.. +********************************/ + +class CPSample_ID; /* need this */ + +class CPMixer { +public: + + enum { + + FREQUENCY_BITS=8 + + }; + + enum ReverbMode { + REVERB_MODE_ROOM, + REVERB_MODE_STUDIO_SMALL, + REVERB_MODE_STUDIO_MEDIUM, + REVERB_MODE_STUDIO_LARGE, + REVERB_MODE_HALL, + REVERB_MODE_SPACE_ECHO, + REVERB_MODE_ECHO, + REVERB_MODE_DELAY, + REVERB_MODE_HALF_ECHO + }; + + /* Callback */ + + virtual void set_callback_interval(int p_interval_us)=0; //in usecs, for tracker it's 2500000/tempo + virtual void set_callback(void (*p_callback)(void*),void *p_userdata)=0; + + /* Voice Control */ + + virtual void setup_voice(int p_voice_index,CPSample_ID p_sample_id,int32_t p_start_index) =0; + virtual void stop_voice(int p_voice_index) =0; + virtual void set_voice_frequency(int p_voice_index,int32_t p_freq) =0; //in freq*FREQUENCY_BITS + virtual void set_voice_panning(int p_voice_index,int p_pan) =0; + virtual void set_voice_volume(int p_voice_index,int p_vol) =0; + virtual void set_voice_filter(int p_filter,bool p_enabled,uint8_t p_cutoff, uint8_t p_resonance )=0; + virtual void set_voice_reverb_send(int p_voice_index,int p_reverb)=0; + virtual void set_voice_chorus_send(int p_voice_index,int p_chorus)=0; /* 0 - 255 */ + + virtual void set_reverb_mode(ReverbMode p_mode)=0; + virtual void set_chorus_params(unsigned int p_delay_ms,unsigned int p_separation_ms,unsigned int p_depth_ms10,unsigned int p_speed_hz10)=0; + + + /* Info retrieving */ + + virtual int32_t get_voice_sample_pos_index(int p_voice_index) =0; + virtual int get_voice_panning(int p_voice_index) =0; + virtual int get_voice_volume(int p_voice_index) =0; + virtual CPSample_ID get_voice_sample_id(int p_voice_index) =0; + virtual bool is_voice_active(int p_voice_index) =0; + virtual int get_active_voice_count()=0; + virtual int get_total_voice_count()=0; + + + virtual uint32_t get_mix_frequency()=0; //if mixer is not software, return 0 + + /* Methods below only work with software mixers, meant for software-based sound drivers, hardware mixers ignore them */ + virtual int32_t process(int32_t p_frames)=0; /* Call this to process N frames, returns how much it was processed */ + virtual int32_t *get_mixdown_buffer_ptr()=0; /* retrieve what was mixed */ + virtual void set_mix_frequency(int32_t p_mix_frequency)=0; + + virtual ~CPMixer() {} +}; + +#endif diff --git a/modules/chibi/cp_note.h b/modules/chibi/cp_note.h new file mode 100644 index 0000000000..5cfa3f11ec --- /dev/null +++ b/modules/chibi/cp_note.h @@ -0,0 +1,102 @@ +/*************************************************************************/ +/* cp_note.h */ +/*************************************************************************/ +/* This file is part of: */ +/* GODOT ENGINE */ +/* http://www.godotengine.org */ +/*************************************************************************/ +/* Copyright (c) 2007-2016 Juan Linietsky, Ariel Manzur. */ +/* */ +/* Permission is hereby granted, free of charge, to any person obtaining */ +/* a copy of this software and associated documentation files (the */ +/* "Software"), to deal in the Software without restriction, including */ +/* without limitation the rights to use, copy, modify, merge, publish, */ +/* distribute, sublicense, and/or sell copies of the Software, and to */ +/* permit persons to whom the Software is furnished to do so, subject to */ +/* the following conditions: */ +/* */ +/* The above copyright notice and this permission notice shall be */ +/* included in all copies or substantial portions of the Software. */ +/* */ +/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */ +/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */ +/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/ +/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */ +/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */ +/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */ +/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ +/*************************************************************************/ +#ifndef CP_NOTE_H +#define CP_NOTE_H + +#include "cp_config.h" + +struct CPNote { + + enum { + + NOTES=120, + OFF=254, + CUT=253, + EMPTY=255, + SCRIPT=252, + }; + + + uint8_t note; + uint8_t instrument; + uint8_t volume; + uint8_t command; + uint8_t parameter; + unsigned int script_source_sign; + bool cloned; + + void clear() { + + note=EMPTY; + instrument=EMPTY; + volume=EMPTY; + command=EMPTY; + parameter=0; + script_source_sign='\0'; + cloned=false; + } + + void raise() { + + if (note<(NOTES-1)) + note++; + else if (note==SCRIPT && parameter<0xFF) + parameter++; + } + + void lower() { + + if ((note>0) && (note<NOTES)) + note--; + else if (note==SCRIPT && parameter>0) + parameter--; + + } + + bool operator== (const CPNote &rvalue) { + + return ( + (note==rvalue.note) && + (instrument==rvalue.instrument) && + (volume==rvalue.volume) && + (command==rvalue.command) && + (parameter==rvalue.parameter) + ); + } + + bool is_empty() const { return (note==EMPTY && instrument==EMPTY && volume==EMPTY && command==EMPTY && parameter==0 && !cloned); } + CPNote() { + + clear(); + } +}; + + +#endif + diff --git a/modules/chibi/cp_order.h b/modules/chibi/cp_order.h new file mode 100644 index 0000000000..03ecc00bba --- /dev/null +++ b/modules/chibi/cp_order.h @@ -0,0 +1,43 @@ +/*************************************************************************/ +/* cp_order.h */ +/*************************************************************************/ +/* This file is part of: */ +/* GODOT ENGINE */ +/* http://www.godotengine.org */ +/*************************************************************************/ +/* Copyright (c) 2007-2016 Juan Linietsky, Ariel Manzur. */ +/* */ +/* Permission is hereby granted, free of charge, to any person obtaining */ +/* a copy of this software and associated documentation files (the */ +/* "Software"), to deal in the Software without restriction, including */ +/* without limitation the rights to use, copy, modify, merge, publish, */ +/* distribute, sublicense, and/or sell copies of the Software, and to */ +/* permit persons to whom the Software is furnished to do so, subject to */ +/* the following conditions: */ +/* */ +/* The above copyright notice and this permission notice shall be */ +/* included in all copies or substantial portions of the Software. */ +/* */ +/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */ +/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */ +/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/ +/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */ +/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */ +/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */ +/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ +/*************************************************************************/ +#ifndef CP_ORDER_H +#define CP_ORDER_H + + +#include "cp_config.h" + +enum CPOrderType { + CP_ORDER_NONE=255, + CP_ORDER_BREAK=254 +}; + +typedef uint8_t CPOrder; + +#endif + diff --git a/modules/chibi/cp_pattern.cpp b/modules/chibi/cp_pattern.cpp new file mode 100644 index 0000000000..83e165bf87 --- /dev/null +++ b/modules/chibi/cp_pattern.cpp @@ -0,0 +1,574 @@ +/*************************************************************************/ +/* cp_pattern.cpp */ +/*************************************************************************/ +/* This file is part of: */ +/* GODOT ENGINE */ +/* http://www.godotengine.org */ +/*************************************************************************/ +/* Copyright (c) 2007-2016 Juan Linietsky, Ariel Manzur. */ +/* */ +/* Permission is hereby granted, free of charge, to any person obtaining */ +/* a copy of this software and associated documentation files (the */ +/* "Software"), to deal in the Software without restriction, including */ +/* without limitation the rights to use, copy, modify, merge, publish, */ +/* distribute, sublicense, and/or sell copies of the Software, and to */ +/* permit persons to whom the Software is furnished to do so, subject to */ +/* the following conditions: */ +/* */ +/* The above copyright notice and this permission notice shall be */ +/* included in all copies or substantial portions of the Software. */ +/* */ +/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */ +/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */ +/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/ +/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */ +/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */ +/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */ +/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ +/*************************************************************************/ +#include "cp_pattern.h" + +void CPPattern::clear() { + + if (event_count>0) { + + + CP_FREE(events); + events=NULL; + event_count=0; + } + + length=DEFAULT_LEN; + +} + + +bool CPPattern::resize_event_list_to(uint32_t p_events) { + + + //Module is slow in some cpus, so this should be fast enough + uint32_t new_size=((p_events-1)&(~((1<<RESIZE_EVERY_BITS)-1)))+(1<<RESIZE_EVERY_BITS); + + CP_ERR_COND_V(new_size<p_events,true); //bugARM_INFO + + if (event_count==0 && new_size==0) + return false; //nothing to do + + if (event_count==0) { + + events=(Event*)CP_ALLOC( new_size*sizeof(Event) ); + + } else if (new_size==0) { + + CP_FREE(events); + events=NULL; + } else { + + CP_ERR_COND_V(events==NULL,true); + events=(Event*)CP_REALLOC(events, new_size*sizeof(Event)); + + } + + event_count=p_events; + + return false; +} + + +int32_t CPPattern::get_event_pos(uint16_t p_target_pos) { + + + if (event_count==0) + return -1; + + int low = 0; + int high = event_count -1; + int middle; + + while( low <= high ) + { + middle = ( low + high ) / 2; + + if( p_target_pos == events[middle].pos ) { //match + break; + } else if( p_target_pos < events[middle].pos ) + high = middle - 1; //search low end of array + else + low = middle + 1; //search high end of array + } + + /* adapt so we are behind 2 */ + + if (events[middle].pos<p_target_pos) + middle++; + return middle; + + /* Linear search for now */ + + /* + int32_t pos_idx=0; + + for (;pos_idx<event_count;pos_idx++) { + + if (event_list[pos_idx].pos>=p_target_pos) + break; + + } */ + + //return pos_idx; +} + +bool CPPattern::erase_event_at_pos(uint16_t p_pos) { + + if (event_count==0) + return false; + + + + Event *event_list=events; + + int32_t pos_idx = get_event_pos(p_pos); + if (pos_idx==-1) { + CP_ERR_COND_V(pos_idx==-1,true); + } + + if (pos_idx==event_count || event_list[pos_idx].pos!=p_pos) { + /* Nothing to Erase */ + return false; + } + + for (int32_t i=pos_idx;i<(event_count-1);i++) { + + event_list[i]=event_list[i+1]; + } + + + resize_event_list_to(event_count-1); + + return false; +} + +bool CPPattern::set_note(uint8_t p_column, uint16_t p_row,const CPNote& p_note) { + + CP_ERR_COND_V(p_column>=WIDTH,true); + CP_ERR_COND_V(p_row>=length,true); + + int32_t new_pos; + uint16_t target_pos=p_row*WIDTH+p_column; + + + + if (p_note.is_empty()) { + bool res=erase_event_at_pos(target_pos); + + return res;; + } + + Event *event_list=0; + + if (event_count==0) { + /* If no events, create the first */ + + if (resize_event_list_to(1)) { + + CP_PRINTERR("Can't resize event list to 1"); + return true; + } + + event_list=events; + if (event_list==0) { + + + CP_PRINTERR("Can't get event list"); + return true; + } + + new_pos=0; + + } else { + /* Prepare to add */ + + event_list=events; + if (event_list==0) { + + + CP_PRINTERR("Can't get event list"); + return true; + } + + int32_t pos_idx = get_event_pos(target_pos); + + if (pos_idx==-1) { + + + CP_PRINTERR("Can't find add position"); + return true; + } + + + if (pos_idx==event_count || event_list[pos_idx].pos!=target_pos) { + /* If the note being modified didnt exist, then we add it */ + + //resize, and return if out of mem + if (resize_event_list_to( event_count+1)) { + + + CP_PRINTERR("Can't resize event list"); + return true; + } + event_list=events; + if (event_list==0) { + + + CP_PRINTERR("Can't get event list"); + return true; + } + + //make room for new pos, this wont do a thing if pos_idx was ==event_count + for(int32_t i=(event_count-1);i>pos_idx;i--) { + event_list[i]=event_list[i-1]; + + } + + } /* Else it means that position is taken, so we just modify it! */ + + + new_pos=pos_idx; + } + + event_list[new_pos].pos=target_pos; + event_list[new_pos].note=p_note.note; + event_list[new_pos].instrument=p_note.instrument; + event_list[new_pos].volume=p_note.volume; + event_list[new_pos].command=p_note.command; + event_list[new_pos].parameter=p_note.parameter; + event_list[new_pos].script_source_sign=p_note.script_source_sign; + event_list[new_pos].cloned=p_note.cloned; + + + + + return false; + +} +CPNote CPPattern::get_note(uint8_t p_column,uint16_t p_row) { + + if (p_column==CPNote::EMPTY) return CPNote(); + + CP_ERR_COND_V(p_column>=WIDTH,CPNote()); + CP_ERR_COND_V(p_row>=length,CPNote()); + + if (event_count==0) + return CPNote(); + + + Event *event_list=events; + + CP_ERR_COND_V(event_list==0,CPNote()); + + uint16_t target_pos=p_row*WIDTH+p_column; + int32_t pos_idx = get_event_pos(target_pos); + if (pos_idx==-1) { + + CP_PRINTERR("Can't find event pos"); + return CPNote(); + } + + if (pos_idx>=event_count || event_list[pos_idx].pos!=target_pos) { + /* no note found */ + + return CPNote(); + } + + CPNote n; + n.note=event_list[pos_idx].note; + n.instrument=event_list[pos_idx].instrument; + n.volume=event_list[pos_idx].volume; + n.command=event_list[pos_idx].command; + n.parameter=event_list[pos_idx].parameter; + n.script_source_sign=event_list[pos_idx].script_source_sign; + n.cloned=event_list[pos_idx].cloned; + + + return n; + +} + +CPNote CPPattern::get_transformed_script_note(uint8_t p_column,uint16_t p_row ) { + + CPNote n = get_note( p_column, p_row ); + + // get source channel and note + + int channel = get_scripted_note_target_channel( p_column, p_row ); + CPNote src_n = get_note( channel, 0 ); + + if ( src_n.note == CPNote::SCRIPT ) return CPNote(); + + script_transform_note( src_n, n ); + + return src_n; + +} + +int CPPattern::get_scripted_note_target_channel(uint8_t p_column, uint16_t p_row) { + + CPNote n = get_note( p_column, p_row ); + + if ( n.note != CPNote::SCRIPT ) return CPNote::EMPTY; + + int channel = n.instrument; + + if ( n.script_source_sign == '\0' ) { + + if ( channel < 0 || channel >= CPPattern::WIDTH ) return CPNote::EMPTY; + + } else { + + channel = p_column + ( ( n.script_source_sign=='+') ? 1 : -1 ) * (channel+1); + if ( channel < 0 || channel >= CPPattern::WIDTH ) return CPNote::EMPTY; + + } + + return channel; +} + +void CPPattern::scripted_clone(uint8_t p_column, uint16_t p_row) { + + int channel = get_scripted_note_target_channel( p_column, p_row ); + int src_row = 1; + CPNote script_n = get_note( p_column, p_row ); + + for ( int row = p_row+1; row < length; ++row ) { + + CPNote src_n = get_note( channel, src_row ); + CPNote target_n = get_note( p_column, row ); + + if ( target_n.note != CPNote::SCRIPT ) { + if ( src_n.note == CPNote::SCRIPT ) { + src_n = CPNote(); + channel = CPNote::EMPTY; + } + + script_transform_note( src_n, script_n ); + + src_n.cloned = true; + set_note( p_column, row, src_n ); + + } else { + + return; + + } + + src_row++; + } + +} + +void CPPattern::scripted_clone_remove(uint8_t p_column, uint16_t p_row) { + + if ( get_note( p_column, p_row ).cloned ) + set_note( p_column, p_row, CPNote() ); + + for ( int row = p_row+1; row < length; ++row ) { + + CPNote target_n = get_note( p_column, row ); + + if ( target_n.note != CPNote::SCRIPT ) { + + set_note( p_column, row, CPNote() ); + + } else { + + return; + + } + + } + +} + +void CPPattern::script_transform_note(CPNote& n, const CPNote& p_note) { + + // set instrument + + if ( n.note < CPNote::NOTES && p_note.volume != CPNote::EMPTY ) { + + n.instrument = p_note.volume; + + } + + // transpose + + if ( n.note < CPNote::NOTES && p_note.command != CPNote::EMPTY ) { + + int transpose = ( p_note.parameter & 0xF ) + ( p_note.parameter / 0x10 ) * 12; + + if ( p_note.command == '^' ) { + + if ( n.note >= CPNote::NOTES-transpose ) + n.note = CPNote::NOTES-1; + else + n.note += transpose; + + } else if ( p_note.command == 'v' ) { + + if ( n.note <= transpose ) + n.note = 0; + else + n.note -= transpose; + + } + } + +} + +bool CPPattern::update_scripted_clones_sourcing_channel( int channel ) { + + bool updated = false; + + for ( int x = 0; x < WIDTH; ++x ) { + + for (int y = 0; y < length; ++y ) { + + if ( channel == get_scripted_note_target_channel( x, y ) ) { + + scripted_clone( x, y ); + updated = true; + } + + } + + } + + return updated; +} + +void CPPattern::set_length(uint16_t p_rows) { + + + + if (event_count==0) { + + if (p_rows>=MIN_ROWS) + length=p_rows; + + + return; + + } + + if (p_rows<MIN_ROWS) { + + return; + } + + if (p_rows<length) { + + Event* event_list=events; + if (event_list==0) { + + CP_PRINTERR("get_event_list() Failed"); + return; + } + + + uint16_t target_pos=p_rows*WIDTH; + int32_t pos_idx = get_event_pos(target_pos); + + + if (pos_idx==-1) { + + CP_ERR_COND(pos_idx==-1); + } + + if (resize_event_list_to(pos_idx)) { + + CP_PRINTERR("resize_event_list_to(pos_idx) Failed"); + return; + } + + } + + length=p_rows; + + +} +#if 0 +void CPPattern::copy_to(CPPattern *p_pattern) const { + + + + + p_pattern->clear(); + p_pattern->length=length; + + + if (!event_count) + return; + + + + int bufsiz=MemPool_Wrapper::get_singleton()->get_mem_size( mem_handle ); + MemPool_Handle aux_mem_handle=MemPool_Wrapper::get_singleton()->alloc_mem( bufsiz ); + + if (aux_mem_handle.is_null()) { + + CP_PRINTERR("own handle is null"); + + return; + } + + + if (MemPool_Wrapper::get_singleton()->lock_mem(aux_mem_handle)) { + CP_PRINTERR("Unable to lock aux new handle"); + + return; + + } + + if (MemPool_Wrapper::get_singleton()->lock_mem(mem_handle)) { + + CP_PRINTERR("Unable to lock own handle"); + + return; + } + + uint8_t* srcuint8_tt8_t*)MemPool_Wrapper::get_singleton()->get_mem(mem_handle); + uint8_t* dstuint8_tt8_t*)MemPool_Wrapper::get_singleton()->get_mem(aux_mem_handle); + + for (int i=0;i<bufsiz;i++) + dst[i]=src[i]; + + MemPool_Wrapper::get_singleton()->unlock_mem(mem_handle); + MemPool_Wrapper::get_singleton()->unlock_mem(aux_mem_handle); + + p_pattern->mem_handle=aux_mem_handle; + p_pattern->event_count=event_count; + + +} +#endif +uint16_t CPPattern::get_length() { + + + return length; +} +CPPattern::CPPattern() { + + + length=DEFAULT_LEN; + event_count=0; + clear(); + +} +bool CPPattern::is_empty() { + + return events==NULL; +} + +CPPattern::~CPPattern() { + + clear(); +} diff --git a/modules/chibi/cp_pattern.h b/modules/chibi/cp_pattern.h new file mode 100644 index 0000000000..4065caa5e5 --- /dev/null +++ b/modules/chibi/cp_pattern.h @@ -0,0 +1,94 @@ +/*************************************************************************/ +/* cp_pattern.h */ +/*************************************************************************/ +/* This file is part of: */ +/* GODOT ENGINE */ +/* http://www.godotengine.org */ +/*************************************************************************/ +/* Copyright (c) 2007-2016 Juan Linietsky, Ariel Manzur. */ +/* */ +/* Permission is hereby granted, free of charge, to any person obtaining */ +/* a copy of this software and associated documentation files (the */ +/* "Software"), to deal in the Software without restriction, including */ +/* without limitation the rights to use, copy, modify, merge, publish, */ +/* distribute, sublicense, and/or sell copies of the Software, and to */ +/* permit persons to whom the Software is furnished to do so, subject to */ +/* the following conditions: */ +/* */ +/* The above copyright notice and this permission notice shall be */ +/* included in all copies or substantial portions of the Software. */ +/* */ +/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */ +/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */ +/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/ +/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */ +/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */ +/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */ +/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ +/*************************************************************************/ +#ifndef CP_PATTERN_H +#define CP_PATTERN_H + +#include "cp_note.h" + +class CPPattern { +public: + + + enum { + WIDTH=64, + DEFAULT_LEN=64, + RESIZE_EVERY_BITS=4, + MIN_ROWS=1, //otherwise clipboard wont work + MAX_LEN=256 + + }; + +private: + struct Event { + + uint16_t pos; //column*WIDTH+row + uint8_t note; + uint8_t instrument; + uint8_t volume; + uint8_t command; + uint8_t parameter; + unsigned int script_source_sign; + bool cloned; + }; + + uint16_t length; + uint32_t event_count; + Event* events; + + int32_t get_event_pos(uint16_t p_target_pos); + bool erase_event_at_pos(uint16_t p_pos); + + bool resize_event_list_to(uint32_t p_events); + + void operator=(const CPPattern& p_pattern); //no operator= +public: + + bool is_empty(); + void clear(); + + bool set_note(uint8_t p_column, uint16_t p_row,const CPNote& p_note); //true if no more memory + CPNote get_note(uint8_t p_column,uint16_t p_row); + + CPNote get_transformed_script_note(uint8_t p_column, uint16_t p_row); + int get_scripted_note_target_channel(uint8_t p_column, uint16_t p_row); + void scripted_clone(uint8_t p_column, uint16_t p_row); + void scripted_clone_remove(uint8_t p_column, uint16_t p_row); + void script_transform_note(CPNote& n, const CPNote& p_note); + bool update_scripted_clones_sourcing_channel(int channel); + + //void copy_to(CPPattern *p_pattern) const; + void set_length(uint16_t p_rows); + uint16_t get_length(); + CPPattern(); + ~CPPattern(); + + +}; + +#endif diff --git a/modules/chibi/cp_player_data.cpp b/modules/chibi/cp_player_data.cpp new file mode 100644 index 0000000000..3f3e9a5202 --- /dev/null +++ b/modules/chibi/cp_player_data.cpp @@ -0,0 +1,151 @@ +/*************************************************************************/ +/* cp_player_data.cpp */ +/*************************************************************************/ +/* This file is part of: */ +/* GODOT ENGINE */ +/* http://www.godotengine.org */ +/*************************************************************************/ +/* Copyright (c) 2007-2016 Juan Linietsky, Ariel Manzur. */ +/* */ +/* Permission is hereby granted, free of charge, to any person obtaining */ +/* a copy of this software and associated documentation files (the */ +/* "Software"), to deal in the Software without restriction, including */ +/* without limitation the rights to use, copy, modify, merge, publish, */ +/* distribute, sublicense, and/or sell copies of the Software, and to */ +/* permit persons to whom the Software is furnished to do so, subject to */ +/* the following conditions: */ +/* */ +/* The above copyright notice and this permission notice shall be */ +/* included in all copies or substantial portions of the Software. */ +/* */ +/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */ +/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */ +/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/ +/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */ +/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */ +/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */ +/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ +/*************************************************************************/ + +#include "cp_player_data.h" +#include <stdio.h> + + +CPPlayer::CPPlayer(CPMixer *p_mixer,CPSong *p_song){ + + song=p_song; + mixer=p_mixer; + control.max_voices=p_mixer->get_total_voice_count()-1; //leave one for the sample + control.force_no_nna=false; + control.external_vibrato=false; + control.filters=true; + control.random_seed=128364; //anything + control.play_mode=0; + set_virtual_channels(p_mixer->get_total_voice_count()); + mixer->set_callback( &CPPlayer::callback_function, this ); + + reset(); +} +CPPlayer::~CPPlayer(){ +} + +void CPPlayer::set_virtual_channels(int p_amount) { + + if (p_amount<1) return; + if (p_amount>mixer->get_total_voice_count()) + return; + + control.max_voices=p_amount; + +} + + +void CPPlayer::callback_function(void *p_userdata) { + + CPPlayer*pd=(CPPlayer*)p_userdata; + pd->process_tick(); + +} + +void CPPlayer::process_tick() { + + handle_tick(); + mixer->set_callback_interval( 2500000/control.tempo ); + song_usecs+=2500000/control.tempo; +} + +void CPPlayer::reset() { + + if ( mixer==NULL ) return ; + if ( song==NULL ) return ; + + int i; + + for (i=0;i<control.max_voices;i++) { + + voice[i].reset(); + mixer->stop_voice(i); + } + + for (i=0;i<CPPattern::WIDTH;i++) { + + control.channel[i].reset(); + control.channel[i].channel_volume=song->get_channel_volume(i); + control.channel[i].channel_panning=((int)song->get_channel_pan( i)*PAN_RIGHT/64); + if (song->is_channel_surround(i)) + control.channel[i].channel_panning=PAN_SURROUND; + control.channel[i].mute=song->is_channel_mute( i ); + control.channel[i].chorus_send=song->get_channel_chorus(i)*0xFF/64; + control.channel[i].reverb_send=song->get_channel_reverb(i)*0xFF/64; + } + + + control.speed=song->get_speed(); + control.tempo=song->get_tempo(); + control.global_volume=song->get_global_volume(); + + control.position.current_pattern=0; + control.position.current_row=0; + control.position.current_order=0; + control.position.force_next_order=-1; + control.ticks_counter=control.speed; + control.position.forbid_jump=false; + + song_usecs=0; + +} + +int64_t CPPlayer::get_channel_last_note_time_usec(int p_channel) const { + + CP_FAIL_INDEX_V(p_channel,64,-1); + return control.channel[p_channel].last_event_usecs; + +} + +void CPPlayer::set_channel_global_volume(int p_channel,int p_volume) { + + CP_FAIL_INDEX(p_channel,64); + control.channel[p_channel].channel_global_volume=CLAMP(p_volume,0,255); + +} + +int CPPlayer::get_channel_global_volume(int p_channel) const{ + + CP_FAIL_INDEX_V(p_channel,64,-1); + return control.channel[p_channel].channel_global_volume; + +} + +bool CPPlayer::reached_end_of_song() { + + return control.reached_end; + +} +void CPPlayer::set_force_external_vibratos(bool p_force) { + + control.external_vibrato=p_force; +} +void CPPlayer::set_force_no_nna(bool p_force) { + + control.force_no_nna=p_force; +} diff --git a/modules/chibi/cp_player_data.h b/modules/chibi/cp_player_data.h new file mode 100644 index 0000000000..282592b8f4 --- /dev/null +++ b/modules/chibi/cp_player_data.h @@ -0,0 +1,582 @@ +/*************************************************************************/ +/* cp_player_data.h */ +/*************************************************************************/ +/* This file is part of: */ +/* GODOT ENGINE */ +/* http://www.godotengine.org */ +/*************************************************************************/ +/* Copyright (c) 2007-2016 Juan Linietsky, Ariel Manzur. */ +/* */ +/* Permission is hereby granted, free of charge, to any person obtaining */ +/* a copy of this software and associated documentation files (the */ +/* "Software"), to deal in the Software without restriction, including */ +/* without limitation the rights to use, copy, modify, merge, publish, */ +/* distribute, sublicense, and/or sell copies of the Software, and to */ +/* permit persons to whom the Software is furnished to do so, subject to */ +/* the following conditions: */ +/* */ +/* The above copyright notice and this permission notice shall be */ +/* included in all copies or substantial portions of the Software. */ +/* */ +/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */ +/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */ +/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/ +/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */ +/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */ +/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */ +/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ +/*************************************************************************/ + +#ifndef CP_PLAYER_DATA_H +#define CP_PLAYER_DATA_H + +#include "cp_config.h" +#include "cp_song.h" +#include "cp_mixer.h" +#include "cp_tables.h" + +/**CPPlayer Data + *@author Juan Linietsky + */ + +/****************************** + player_data.h + ------------------------ + +The player and its data. +I hope you dont get sick reading this +********************************/ + +//Default pan values + + +class CPPlayer { + + enum { + PAN_SURROUND=512, + PAN_RIGHT=255, + PAN_LEFT=0, + PAN_CENTER=128 + }; + + + CPSong *song; + + CPMixer *mixer; + + struct Filter_Control { + + int32_t it_reso; + int32_t it_cutoff; + int32_t envelope_cutoff; + int32_t final_cutoff; + + void process(); + void set_filter_parameters(int *p_cutoff,uint8_t *p_reso); + + }; + + //tells you if a channel is doing + //noteoff/notekill/notefade/etc + enum { + + END_NOTE_NOTHING=0, + END_NOTE_OFF=1, + END_NOTE_FADE=2, + END_NOTE_KILL=4 + }; + + //Tells you what should a channel restart + enum { + + KICK_NOTHING, + KICK_NOTE, + KICK_NOTEOFF, + KICK_ENVELOPE + }; + + enum { + + MAX_VOICES=256 + }; + + struct Channel_Control; + + struct Voice_Control { + + struct Envelope_Control { + + int pos_index; + int status; + int value; + bool sustain_looping; + bool looping; + bool terminated; + bool active; + bool kill; + + }; + + Filter_Control filter; + uint16_t reverb_send; + uint16_t chorus_send; + + CPInstrument* instrument_ptr; + CPSample* sample_ptr; + +// Sample_Data *sample_data; + + int32_t period; + + int32_t sample_start_index; /* The starting byte index in the sample */ + + bool has_master_channel; + int master_channel_index; + int instruement_index; + + int instrument_index; + int sample_index; + int8_t NNA_type; + + int note_end_flags; + + uint8_t sample; /* which instrument number */ + + int16_t output_volume; /* output volume (vol + sampcol + instvol) */ + int8_t channel_volume; /* channel's "global" volume */ + uint16_t fadeout_volume; /* fading volume rate */ + int32_t total_volume; /* total volume of channel (before global mixings) */ + uint8_t kick; /* if true = sample has to be restarted */ + + uint8_t note; /* the audible note (as heard, direct rep of period) */ + + int16_t panning; /* panning position */ + + uint8_t nna; /* New note action type + master/slave flags */ + uint8_t volflg; /* volume envelope settings */ + uint8_t panflg; /* panning envelope settings */ + uint8_t pitflg; /* pitch envelope settings */ + uint8_t keyoff; /* if true = fade out and stuff */ + int16_t handle; /* which sample-handle */ + int32_t start; /* The start byte index in the sample */ + + /* Below here is info NOT in MP_CONTROL!! */ + //ENVPR venv; + //ENVPR penv; + //ENVPR cenv; + + Envelope_Control volume_envelope_ctrl; + Envelope_Control panning_envelope_ctrl; + Envelope_Control pitch_envelope_ctrl; + + uint16_t auto_vibrato_pos; /* autovibrato pos */ + uint16_t auto_vibrato_sweep_pos; /* autovibrato sweep pos */ + + int16_t masterchn; + uint16_t masterperiod; + + Channel_Control* master_channel; /* index of "master" effects channel */ + + void start_envelope(CPEnvelope *p_envelope,Envelope_Control *p_envelope_ctrl,Envelope_Control *p_from_env); + bool process_envelope(CPEnvelope *p_envelope,Envelope_Control *p_envelope_ctrl); + + uint16_t display_volume; + + Voice_Control() { + + reset(); + } + + void reset(); + void update_info_from_master_channel(); + + + }; + + + struct Channel_Control { + + /* NOTE info */ + uint8_t note; /* the audible note as heard, direct rep of period */ + uint8_t real_note; /* the note that indexes the audible */ + int32_t sample_start_index; /* The starting byte index in the sample */ + uint8_t old_note; + + uint8_t kick; + + Filter_Control filter; + uint16_t reverb_send; + uint16_t chorus_send; + + + int note_end_flags; + + /* INSTRUMENT INFO */ + + CPInstrument* instrument_ptr; + CPSample* sample_ptr; + + uint8_t instrument_index; + uint8_t sample_index; + bool new_instrument; + + /* SAMPLE SPECIFIC INFO */ + int32_t base_speed; /* what finetune to use */ + + /* INSTRUMENT SPECIFIC INFO */ + + int8_t NNA_type; + int8_t duplicate_check_type; + int8_t duplicate_check_action; + + bool volume_envelope_on; + bool panning_envelope_on; + bool pitch_envelope_on; + + bool has_own_period; + + bool row_has_note; + + /* VOLUME COLUMN */ + + int16_t volume; /* amiga volume (0 t/m 64) to play the sample at */ + int16_t aux_volume; + bool has_own_volume; + bool mute; + int16_t random_volume_variation; /* 0-100 - 100 has no effect */ + + /* VOLUME/PAN/PITCH MODIFIERS */ + + int8_t default_volume; // CHANNEL default volume (0-64) + int16_t channel_volume; // CHANNEL current volume //chanvol - current! + int16_t output_volume; /* output volume (vol + sampcol + instvol) //volume */ + int16_t channel_global_volume; + + uint16_t fadeout_volume; /* fading volume rate */ + + int32_t period; /* period to play the sample at */ + + /* PAN */ + + int16_t panning; /* panning position */ + int16_t channel_panning; + int8_t sliding; + + uint16_t aux_period; /* temporary period */ + + + + /* TIMING */ + uint8_t note_delay; /* (used for note delay) */ + + /* Slave Voice Control */ + + Voice_Control *slave_voice; /* Audio Slave of current effects control channel */ + + struct Carry { + + Voice_Control::Envelope_Control vol; + Voice_Control::Envelope_Control pan; + Voice_Control::Envelope_Control pitch; + bool maybe; + + } carry; + + + + uint8_t slave_voice_index; /* Audio Slave of current effects control channel */ + + uint8_t* row; /* row currently playing on this channel */ + + /* effect memory variables */ + + uint8_t current_command; + uint8_t current_parameter; + uint8_t current_volume_command; + uint8_t current_volume_parameter; + uint8_t volcol_volume_slide; + + /* CPSample Offset */ + + int32_t lo_offset; + int32_t hi_offset; + + /* Panbrello waveform */ + uint8_t panbrello_type; /* current panbrello waveform */ + uint8_t panbrello_position; /* current panbrello position */ + int8_t panbrello_speed; /* "" speed */ + uint8_t panbrello_depth; /* "" depth */ + uint8_t panbrello_info; + /* Arpegio */ + + uint8_t arpegio_info; + /* CPPattern Loop */ + + int pattern_loop_position; + int8_t pattern_loop_count; + + /* Vibrato */ + bool doing_vibrato; + int8_t vibrato_position; /* current vibrato position */ + uint8_t vibrato_speed; /* "" speed */ + uint8_t vibrato_depth; /* "" depth */ + uint8_t vibrato_type; + /* Tremor */ + int8_t tremor_position; + uint8_t tremor_speed; /* s3m tremor ontime/offtime */ + uint8_t tremor_depth; + uint8_t tremor_info; + + /* Tremolo */ + int8_t tremolo_position; + uint8_t tremolo_speed; /* s3m tremor ontime/offtime */ + uint8_t tremolo_depth; + uint8_t tremolo_info; + uint8_t tremolo_type; + + /* Retrig */ + int8_t retrig_counter; /* retrig value (0 means don't retrig) */ + uint8_t retrig_speed; /* last used retrig speed */ + uint8_t retrig_volslide; /* last used retrig slide */ + + /* CPSample Offset */ + int32_t sample_offset_hi; /* last used high order of sample offset */ + uint16_t sample_offset; /* last used low order of sample-offset (effect 9) */ + uint16_t sample_offset_fine; /* fine sample offset memory */ + + /* Portamento */ + uint16_t slide_to_period; /* period to slide to (with effect 3 or 5) */ + uint8_t portamento_speed; + + /* Volume Slide */ + + uint8_t volume_slide_info; + + /* Channel Volume Slide */ + + uint8_t channel_volume_slide_info; + + /* Global Volume Slide */ + + uint8_t global_volume_slide_info; + + /* Channel Pan Slide */ + + uint8_t channel_pan_slide_info; + + /* Pitch Slide */ + + uint8_t pitch_slide_info; + /* Tempo Slide */ + + uint8_t tempo_slide_info; + + /* S effects memory */ + + uint8_t current_S_effect; + uint8_t current_S_data; + + /* Volume column memory */ + + uint8_t volume_column_effect_mem; + uint8_t volume_column_data_mem; + + int64_t last_event_usecs; + bool reserved; + + void reset(); + + Channel_Control() { channel_global_volume=255; last_event_usecs=-1; } + }; + + struct Control_Variables { // control variables (dynamic version) of initial variables + + bool reached_end; + + char play_mode; + bool filters; + int global_volume; + int speed; + int tempo; + + int ticks_counter; + + int pattern_delay_1; + int pattern_delay_2; + + Channel_Control channel[CPPattern::WIDTH]; + + int max_voices; + + int voices_used; /* reference value */ + + bool force_no_nna; + bool external_vibrato; + + struct Position { + + int current_order; + int current_pattern; + int current_row; + int force_next_order; + bool forbid_jump; + }; + + int32_t random_seed; + + Position position; + Position previous_position; + + }; + + + Voice_Control voice[MAX_VOICES]; + + Control_Variables control; + + /* VOICE SETUP */ + + void setup_voices(); + + /* MIXER SETUP */ + void handle_tick(); + void update_mixer(); + + /* NOTE / INSTRUMENT PROCESSING */ + + void process_new_note(int p_track,uint8_t p_note); + bool process_new_instrument(int p_track,uint8_t p_instrument); + bool process_note_and_instrument(int p_track,int p_note,int p_instrument); + + /* EFFECT PROCESSING */ + void do_effect_S(int p_track); + void do_panbrello(int p_track); + void do_global_volume_slide(int p_track); + void do_tremolo(int p_track); + void do_retrig(int p_track); + void do_pan_slide(int p_track); + void do_channel_volume_slide(int p_track); + void do_volume_slide(int p_track,int inf); + void do_pitch_slide_down(int p_track,uint8_t inf); + void do_pitch_slide_up(int p_track,uint8_t inf); + void do_tremor(int p_track); + void do_vibrato(int p_track,bool fine); + void do_pitch_slide_to_note(int p_track); + void run_effects(int p_track); + void run_volume_column_effects(int p_track); + void pre_process_effects(); + void do_arpegio(int p_track); + uint64_t song_usecs; + /* NNA */ + + void process_NNAs(); + + + /* MISC UTILS */ + + + int find_empty_voice(); + void process_volume_column(int p_track,uint8_t p_volume); + void process_note(int p_track,CPNote p_note); + + /* CPTables */ + static uint8_t auto_vibrato_table[128]; + static uint8_t vibrato_table[32]; + static int8_t panbrello_table[256]; + + static void callback_function(void *p_userdata); + +public: + //Play modes + + enum { + + PLAY_NOTHING =0, + PLAY_PATTERN =1, + PLAY_SONG =2 + }; + + + int32_t get_frequency(int32_t period); + int32_t get_period(uint16_t note,int32_t p_c5freq); + + + int get_current_tempo() { return control.tempo; }; + int get_current_speed() { return control.speed; }; + + int get_voices_used() { return control.voices_used;}; + int get_voice_envelope_pos(int p_voice,CPEnvelope *p_envelope); + int get_voice_amount_limit() { return control.max_voices; }; + void set_voice_amount_limit(int p_limit); + void set_reserved_voices(int p_amount); + int get_reserved_voices_amount(); + + bool is_voice_active(int p_voice); + int get_channel_voice(int p_channel); + const char* get_voice_sample_name(int p_voice); + const char* get_voice_instrument_name(int p_voice); + CPEnvelope* get_voice_envelope(int p_voice,CPInstrument::EnvelopeType p_env_type); + int get_voice_envelope_pos(int p_voice,CPInstrument::EnvelopeType p_env_type); + int get_voice_volume(int p_voice); + + int get_voice_sample_index(int p_voice); + + void set_virtual_channels(int p_amount); + int get_virtual_channels() { return control.max_voices; }; + + + /* Play Info/Position */ + bool is_playing() { return (control.play_mode>0); }; + int get_play_mode() {return (control.play_mode);}; + int get_current_order() { return control.position.current_order; }; + int get_current_row() { return control.position.current_row; }; + int get_current_pattern() { return control.position.current_pattern; }; + + void goto_next_order(); + void goto_previous_order(); + + void process_tick(); + + + CPMixer* get_mixer_ptr() { + + return mixer; + } + + + void reset(); + + + + /* External player control - editor - */ + + void play_start_pattern(int p_pattern); + void play_start_song(); + void play_start_song_from_order(int p_order); + void play_start_song_from_order_and_row(int p_order,int p_row); + void play_start(int p_pattern, int p_order, int p_row,bool p_lock=true); + + void play_stop(); + void play_note(int p_channel,CPNote note,bool p_reserve=false); + + bool reached_end_of_song(); + + void set_force_no_nna(bool p_force); + void set_force_external_vibratos(bool p_force); + + void set_filters_enabled(bool p_enable); + bool are_filters_enabled() { return control.filters; } + + void set_channel_global_volume(int p_channel,int p_volume); //0-255 + int get_channel_global_volume(int p_channel) const; + + int64_t get_channel_last_note_time_usec(int p_channel) const; + + CPSong *get_song() { return song; }; + + + CPPlayer(CPMixer *p_mixer,CPSong *p_song); + ~CPPlayer(); +}; + +#endif diff --git a/modules/chibi/cp_player_data_control.cpp b/modules/chibi/cp_player_data_control.cpp new file mode 100644 index 0000000000..d9aaed904f --- /dev/null +++ b/modules/chibi/cp_player_data_control.cpp @@ -0,0 +1,324 @@ +/*************************************************************************/ +/* cp_player_data_control.cpp */ +/*************************************************************************/ +/* This file is part of: */ +/* GODOT ENGINE */ +/* http://www.godotengine.org */ +/*************************************************************************/ +/* Copyright (c) 2007-2016 Juan Linietsky, Ariel Manzur. */ +/* */ +/* Permission is hereby granted, free of charge, to any person obtaining */ +/* a copy of this software and associated documentation files (the */ +/* "Software"), to deal in the Software without restriction, including */ +/* without limitation the rights to use, copy, modify, merge, publish, */ +/* distribute, sublicense, and/or sell copies of the Software, and to */ +/* permit persons to whom the Software is furnished to do so, subject to */ +/* the following conditions: */ +/* */ +/* The above copyright notice and this permission notice shall be */ +/* included in all copies or substantial portions of the Software. */ +/* */ +/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */ +/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */ +/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/ +/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */ +/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */ +/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */ +/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ +/*************************************************************************/ + +#include "cp_player_data.h" + +void CPPlayer::play_start_pattern(int p_pattern) { + + play_start(p_pattern,-1,-1); +} + +void CPPlayer::play_start_song() { + + play_start(-1,-1,-1); +} + +void CPPlayer::play_start_song_from_order(int p_order) { + + play_start(-1,p_order,-1); +} + +void CPPlayer::play_start_song_from_order_and_row(int p_order,int p_row) { + + play_start(-1,p_order,p_row); +} + +void CPPlayer::play_start(int p_pattern, int p_order, int p_row,bool p_lock) { + + + if (control.play_mode!=PLAY_NOTHING) play_stop(); + + + reset(); + + if (p_pattern!=-1) { + + control.play_mode=PLAY_PATTERN; + control.position.current_pattern=p_pattern; + control.position.current_row=(p_row!=-1)?p_row:0; + + } else { + + control.position.current_order=get_song_next_order_idx(song,(p_order==-1)?p_order:p_order-1); + if (control.position.current_order!=-1) { + + control.play_mode=PLAY_SONG; + control.position.current_pattern=song->get_order(control.position.current_order); + control.position.current_row=(p_row!=-1)?p_row:0; + } + } + + + control.reached_end=(control.play_mode==PLAY_NOTHING); + + +} + +void CPPlayer::play_stop() { + + int i; + + + control.play_mode=PLAY_NOTHING; + + for (i=0;i<control.max_voices;i++) { + + voice[i].reset(); + mixer->stop_voice(i); + } + + for (i=0;i<CPPattern::WIDTH;i++) { + + control.channel[i].reset(); + } + + reset(); + +} + +void CPPlayer::play_note(int p_channel,CPNote note,bool p_reserve) { + + + + if (control.play_mode==PLAY_NOTHING) { + + control.ticks_counter=0; + } + + /*control.channel[p_channel].reset(); + control.channel[p_channel].channel_volume=song->get_channel_volume(p_channel); + control.channel[p_channel].channel_panning=((int)song->get_channel_pan( p_channel)*255/64);*/ + if (p_reserve) { + control.channel[p_channel].mute=false; + control.channel[p_channel].reserved=true; + } else { + + control.channel[p_channel].reserved=false; + + } + process_note(p_channel,note); + + + +} + + +int CPPlayer::get_voice_volume(int p_voice) { + + return voice[p_voice].display_volume; +} + + +int CPPlayer::get_voice_envelope_pos(int p_voice,CPEnvelope *p_envelope) { + + int i,tmp_index=-1; + + i=p_voice; + + + + + if ((song->has_instruments()) && (voice[i].instrument_ptr!=NULL) && (voice[i].fadeout_volume>0)) { + + if ((p_envelope==voice[i].instrument_ptr->get_volume_envelope()) && (voice[i].instrument_ptr->get_volume_envelope()->is_enabled())) { + + tmp_index=voice[i].volume_envelope_ctrl.pos_index; + } + + if ((p_envelope==voice[i].instrument_ptr->get_pan_envelope()) && (voice[i].instrument_ptr->get_pan_envelope()->is_enabled())) { + + tmp_index=voice[i].panning_envelope_ctrl.pos_index; + } + + if ((p_envelope==voice[i].instrument_ptr->get_pitch_filter_envelope()) && (voice[i].instrument_ptr->get_pitch_filter_envelope()->is_enabled())) { + + + tmp_index=voice[i].pitch_envelope_ctrl.pos_index; + } + + } + + + + return tmp_index; +} + +void CPPlayer::goto_next_order() { + + + if (control.play_mode!=PLAY_SONG) return; + + + + control.position.current_row=0; + + + control.position.current_order=get_song_next_order_idx(song, control.position.current_order); + + + + if (control.position.current_order==-1) { + + reset(); + } + + control.position.current_pattern=song->get_order(control.position.current_order); + + +} +void CPPlayer::goto_previous_order() { + + if (control.play_mode!=PLAY_SONG) return; + + + int next_order,current_order; + + control.position.current_row=0; + + current_order=control.position.current_order; + + next_order=get_song_next_order_idx(song, current_order); + + while ((next_order!=control.position.current_order) && (next_order!=-1)) { + + current_order=next_order; + next_order=get_song_next_order_idx(song, current_order); + } + + if (next_order==-1) { + + reset(); + } else { + + control.position.current_order=current_order; + control.position.current_pattern=song->get_order(control.position.current_order); + + } + + + +} + +int CPPlayer::get_channel_voice(int p_channel) { + + if (control.channel[p_channel].slave_voice==NULL) return -1; + else return control.channel[p_channel].slave_voice_index; +} + +const char* CPPlayer::get_voice_sample_name(int p_voice) { + + const char *name = NULL; + + + + if (!voice[p_voice].sample_ptr) name=voice[p_voice].sample_ptr->get_name(); + + + + return name; + +} + + +bool CPPlayer::is_voice_active(int p_voice) { + + return !( ((voice[p_voice].kick==KICK_NOTHING)||(voice[p_voice].kick==KICK_ENVELOPE))&&!mixer->is_voice_active(p_voice) ); + +} + + + +int CPPlayer::get_voice_envelope_pos(int p_voice,CPInstrument::EnvelopeType p_env_type) { + + if (!is_voice_active(p_voice)) + return -1; + + Voice_Control::Envelope_Control *env=0; + + switch (p_env_type) { + + case CPInstrument::VOLUME_ENVELOPE: env=&voice[p_voice].volume_envelope_ctrl; break; + case CPInstrument::PAN_ENVELOPE: env=&voice[p_voice].panning_envelope_ctrl; break; + case CPInstrument::PITCH_ENVELOPE: env=&voice[p_voice].pitch_envelope_ctrl; break; + + } + + if (!env) + return -1; + + if (!env->active || env->terminated) + return -1; + + return env->pos_index; +} + + +CPEnvelope* CPPlayer::get_voice_envelope(int p_voice,CPInstrument::EnvelopeType p_env_type) { + + CPInstrument *ins=voice[p_voice].instrument_ptr; + + if (!ins) + return 0; + + switch( p_env_type ) { + + + case CPInstrument::VOLUME_ENVELOPE: return ins->get_volume_envelope(); + case CPInstrument::PAN_ENVELOPE: return ins->get_pan_envelope(); + case CPInstrument::PITCH_ENVELOPE: return ins->get_pitch_filter_envelope(); + }; + + return 0; + +} + +const char * CPPlayer::get_voice_instrument_name(int p_voice) { + + + + const char *name = NULL; + + + + if (voice[p_voice].instrument_ptr!=NULL) name=voice[p_voice].instrument_ptr->get_name(); + + + + return name; + +} +void CPPlayer::set_filters_enabled(bool p_enable){ + + control.filters=p_enable; +} + +int CPPlayer::get_voice_sample_index(int p_voice) { + + return voice[p_voice].sample_index; +} diff --git a/modules/chibi/cp_player_data_effects.cpp b/modules/chibi/cp_player_data_effects.cpp new file mode 100644 index 0000000000..3a52a3b91b --- /dev/null +++ b/modules/chibi/cp_player_data_effects.cpp @@ -0,0 +1,1232 @@ +/*************************************************************************/ +/* cp_player_data_effects.cpp */ +/*************************************************************************/ +/* This file is part of: */ +/* GODOT ENGINE */ +/* http://www.godotengine.org */ +/*************************************************************************/ +/* Copyright (c) 2007-2016 Juan Linietsky, Ariel Manzur. */ +/* */ +/* Permission is hereby granted, free of charge, to any person obtaining */ +/* a copy of this software and associated documentation files (the */ +/* "Software"), to deal in the Software without restriction, including */ +/* without limitation the rights to use, copy, modify, merge, publish, */ +/* distribute, sublicense, and/or sell copies of the Software, and to */ +/* permit persons to whom the Software is furnished to do so, subject to */ +/* the following conditions: */ +/* */ +/* The above copyright notice and this permission notice shall be */ +/* included in all copies or substantial portions of the Software. */ +/* */ +/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */ +/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */ +/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/ +/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */ +/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */ +/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */ +/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ +/*************************************************************************/ + +#include "cp_player_data.h" + + + +/********************** + complex effects +***********************/ +#define RANDOM_MAX 2147483647 + +static inline int32_t cp_random_generate(int32_t *seed) { + int32_t k; + int32_t s = (int32_t)(*seed); + if (s == 0) + s = 0x12345987; + k = s / 127773; + s = 16807 * (s - k * 127773) - 2836 * k; + if (s < 0) + s += 2147483647; + (*seed) = (int32_t)s; + return (int32_t)(s & RANDOM_MAX); +} + + + +void CPPlayer::do_vibrato(int p_track,bool fine) { + + uint8_t q; + uint16_t temp=0; + + if ((control.ticks_counter==0) && control.channel[p_track].row_has_note) control.channel[p_track].vibrato_position=0; + + q=(control.channel[p_track].vibrato_position>>2)&0x1f; + + switch (control.channel[p_track].vibrato_type) { + case 0: /* sine */ + temp=vibrato_table[q]; + break; + case 1: /* square wave */ + temp=255; + break; + case 2: /* ramp down */ + q<<=3; + if (control.channel[p_track].vibrato_position<0) q=255-q; + temp=q; + break; + case 3: /* random */ + temp=cp_random_generate(&control.random_seed) %256;//getrandom(256); + break; + } + + temp*=control.channel[p_track].vibrato_depth; + + if (song->has_old_effects()) { + + temp>>=7; + } else { + + temp>>=8; + } + + if (!fine) temp<<=2; + + if (control.channel[p_track].vibrato_position>=0) { + + control.channel[p_track].period=control.channel[p_track].aux_period+temp; + } else { + + control.channel[p_track].period=control.channel[p_track].aux_period-temp; + } + + if (!song->has_old_effects() || control.ticks_counter) control.channel[p_track].vibrato_position+=control.channel[p_track].vibrato_speed; +} + + +void CPPlayer::do_pitch_slide_down(int p_track,uint8_t inf) { + + uint8_t hi,lo; + + if (inf) control.channel[p_track].pitch_slide_info=inf; + else inf=control.channel[p_track].pitch_slide_info; + + hi=inf>>4; + lo=inf&0xf; + + if (hi==0xf) { + + if (!control.ticks_counter) control.channel[p_track].aux_period+=(uint16_t)lo<<2; + } else if (hi==0xe) { + + if (!control.ticks_counter) control.channel[p_track].aux_period+=lo; + } else { + + if (control.ticks_counter) control.channel[p_track].aux_period+=(uint16_t)inf<<2; + } +} + +void CPPlayer::do_pitch_slide_up(int p_track,uint8_t inf) { + + uint8_t hi,lo; + + if (inf) control.channel[p_track].pitch_slide_info=inf; + else inf=control.channel[p_track].pitch_slide_info; + + hi=inf>>4; + lo=inf&0xf; + + if (hi==0xf) { + + if (!control.ticks_counter) control.channel[p_track].aux_period-=(uint16_t)lo<<2; + } else if (hi==0xe) { + + if (!control.ticks_counter) control.channel[p_track].aux_period-=lo; + } else { + + if (control.ticks_counter) control.channel[p_track].aux_period-=(uint16_t)inf<<2; + } +} + +void CPPlayer::do_pitch_slide_to_note(int p_track) { + + if (control.ticks_counter) { + int dist; + + /* We have to slide a->period towards a->wantedperiod, compute the + difference between those two values */ + dist=control.channel[p_track].period-control.channel[p_track].slide_to_period; + + /* if they are equal or if portamentospeed is too big... */ + if ((!dist)||((control.channel[p_track].portamento_speed<<2)>cp_intabs(dist))) { + /* ... make tmpperiod equal tperiod */ + control.channel[p_track].aux_period=control.channel[p_track].period=control.channel[p_track].slide_to_period; + } else { + + if (dist>0) { + + control.channel[p_track].aux_period-=control.channel[p_track].portamento_speed<<2; + control.channel[p_track].period-=control.channel[p_track].portamento_speed<<2; /* dist>0 slide up */ + } else { + control.channel[p_track].aux_period+=control.channel[p_track].portamento_speed<<2; + control.channel[p_track].period+=control.channel[p_track].portamento_speed<<2; /* dist<0 slide down */ + } + } + + } else { + + control.channel[p_track].aux_period=control.channel[p_track].period; + } +} + +void CPPlayer::do_tremor(int p_track) { + + uint8_t on,off,inf; + + inf=control.channel[p_track].current_parameter; + + if (inf) { + control.channel[p_track].tremor_info=inf; + } else { + inf= control.channel[p_track].tremor_info; + if (!inf) return; + } + + //if (!control.ticks_counter) return; + + on=(inf>>4); + off=(inf&0xf); + + control.channel[p_track].tremor_position%=(on+off); + control.channel[p_track].volume=(control.channel[p_track].tremor_position<on)?control.channel[p_track].aux_volume:0; + control.channel[p_track].tremor_position++; +} + +void CPPlayer::do_pan_slide(int p_track) { + + uint8_t lo,hi,inf; + int16_t pan; + + inf=control.channel[p_track].current_parameter; + + if (inf) control.channel[p_track].channel_pan_slide_info=inf; + else inf=control.channel[p_track].channel_pan_slide_info; + + lo=inf&0xf; + hi=inf>>4; + + pan=(control.channel[p_track].panning==PAN_SURROUND)?PAN_CENTER:control.channel[p_track].panning; + + if (!hi) + pan+=lo<<2; + else + if (!lo) { + pan-=hi<<2; + } else + if (hi==0xf) { + if (!control.ticks_counter) pan+=lo<<2; + } else + if (lo==0xf) { + if (!control.ticks_counter) pan-=hi<<2; + } + //this sets both chan & voice paning + control.channel[p_track].panning=(pan<PAN_LEFT)?PAN_LEFT:(pan>PAN_RIGHT?PAN_RIGHT:pan); + control.channel[p_track].channel_panning=control.channel[p_track].panning; +} + +void CPPlayer::do_volume_slide(int p_track,int inf) { + + uint8_t hi,lo; + + lo=inf&0xf; + hi=inf>>4; + + if (!lo) { + + if ((control.ticks_counter)) control.channel[p_track].aux_volume+=hi; + + } else if (!hi) { + + if ((control.ticks_counter)) control.channel[p_track].aux_volume-=lo; + + } else if (lo==0xf) { + + if (!control.ticks_counter) control.channel[p_track].aux_volume+=(hi?hi:0xf); + } else if (hi==0xf) { + + if (!control.ticks_counter) control.channel[p_track].aux_volume-=(lo?lo:0xf); + } else return; + + if (control.channel[p_track].aux_volume<0) { + + control.channel[p_track].aux_volume=0; + } else if (control.channel[p_track].aux_volume>64) { + + control.channel[p_track].aux_volume=64; + } +} + +void CPPlayer::do_channel_volume_slide(int p_track) { + + uint8_t lo, hi,inf; + + inf=control.channel[p_track].current_parameter; + + if (inf) control.channel[p_track].channel_volume_slide_info=inf; + inf=control.channel[p_track].channel_volume_slide_info; + + lo=inf&0xf; + hi=inf>>4; + + if (!hi) + control.channel[p_track].channel_volume-=lo; + else + if (!lo) { + control.channel[p_track].channel_volume+=hi; + } else + if (hi==0xf) { + if (!control.ticks_counter) control.channel[p_track].channel_volume-=lo; + } else + if (lo==0xf) { + if (!control.ticks_counter) control.channel[p_track].channel_volume+=hi; + } + + if (control.channel[p_track].channel_volume<0) control.channel[p_track].channel_volume=0; + if (control.channel[p_track].channel_volume>64) control.channel[p_track].channel_volume=64; +} + +void CPPlayer::do_tremolo(int p_track) { + + uint8_t q; + int16_t temp=0; + + if ((control.ticks_counter==0) && control.channel[p_track].row_has_note) control.channel[p_track].tremolo_position=0; + + q=(control.channel[p_track].tremolo_position>>2)&0x1f; + + switch (control.channel[p_track].tremolo_type) { + case 0: /* sine */ + temp=vibrato_table[q]; + break; + case 1: /* ramp down */ + q<<=3; + if (control.channel[p_track].tremolo_position<0) q=255-q; + temp=q; + break; + case 2: /* square wave */ + temp=255; + break; + case 3: /* random */ + temp=cp_random_generate(&control.random_seed) % 256;//getrandom(256); + break; + } + + temp*=control.channel[p_track].tremolo_depth; + temp>>=7; + + + + if (control.channel[p_track].tremolo_position>=0) { + + + control.channel[p_track].volume=control.channel[p_track].aux_volume+temp; + if (control.channel[p_track].volume>64) control.channel[p_track].volume=64; + } else { + + control.channel[p_track].volume=control.channel[p_track].aux_volume-temp; + if (control.channel[p_track].volume<0) control.channel[p_track].volume=0; + } + + /*if (control.ticks_counter)*/ control.channel[p_track].tremolo_position+=control.channel[p_track].tremolo_speed; + +} + +void CPPlayer::do_arpegio(int p_track) { + + uint8_t note,dat; + //note=control.channel[p_track].note; + note=0; + + if (control.channel[p_track].current_parameter) { + + control.channel[p_track].arpegio_info=control.channel[p_track].current_parameter; + } + + dat=control.channel[p_track].arpegio_info; + + if (dat) { + + switch (control.ticks_counter%3) { + + case 1: { + + note+=(dat>>4); + + } break; + case 2: { + + note+=(dat&0xf); + } break; + } + + if (song->has_linear_slides()) { + + control.channel[p_track].period=control.channel[p_track].aux_period-cp_intabs(get_period((uint16_t)46,0)-get_period((uint16_t)44,0))*note; + } else if (control.channel[p_track].sample_ptr) { + + control.channel[p_track].period=get_period( (((uint16_t)control.channel[p_track].note)+note)<<1,CPSampleManager::get_singleton()->get_c5_freq( (control.channel[p_track].sample_ptr->get_sample_data()))); + } + + control.channel[p_track].has_own_period=true; + } + + +} + + +void CPPlayer::do_retrig(int p_track) { + + uint8_t inf; + + inf=control.channel[p_track].current_parameter; + + if (inf) { + + control.channel[p_track].retrig_volslide=inf>>4; + control.channel[p_track].retrig_speed=inf&0xf; + } + + /* only retrigger if low nibble > 0 */ + if ( control.channel[p_track].retrig_speed>0) { + + if ( !control.channel[p_track].retrig_counter ) { + /* when retrig counter reaches 0, reset counter and restart the + sample */ + if (control.channel[p_track].kick!=KICK_NOTE) control.channel[p_track].kick=KICK_NOTEOFF; + control.channel[p_track].retrig_counter=control.channel[p_track].retrig_speed; + + + if ((control.ticks_counter)/*||(pf->flags&UF_S3MSLIDES)*/) { + switch (control.channel[p_track].retrig_volslide) { + case 1: + case 2: + case 3: + case 4: + case 5: + control.channel[p_track].aux_volume-=(1<<(control.channel[p_track].retrig_volslide-1)); + break; + case 6: + control.channel[p_track].aux_volume=(2*control.channel[p_track].aux_volume)/3; + break; + case 7: + control.channel[p_track].aux_volume>>=1; + break; + case 9: + case 0xa: + case 0xb: + case 0xc: + case 0xd: + control.channel[p_track].aux_volume+=(1<<(control.channel[p_track].retrig_volslide-9)); + break; + case 0xe: + control.channel[p_track].aux_volume=(3*control.channel[p_track].aux_volume)>>1; + break; + case 0xf: + control.channel[p_track].aux_volume=control.channel[p_track].aux_volume<<1; + break; + } + if (control.channel[p_track].aux_volume<0) control.channel[p_track].aux_volume=0; + else if (control.channel[p_track].aux_volume>64) control.channel[p_track].aux_volume=64; + } + } + control.channel[p_track].retrig_counter--; /* countdown */ + } +} + +void CPPlayer::do_global_volume_slide(int p_track) { + + uint8_t lo,hi,inf; + + inf=control.channel[p_track].current_parameter; + + if (inf) control.channel[p_track].global_volume_slide_info=inf; + inf=control.channel[p_track].global_volume_slide_info; + + lo=inf&0xf; + hi=inf>>4; + + if (!lo) { + if (control.ticks_counter) control.global_volume+=hi; + } else + if (!hi) { + if (control.ticks_counter) control.global_volume-=lo; + } else + if (lo==0xf) { + if (!control.ticks_counter) control.global_volume+=hi; + } else + if (hi==0xf) { + if (!control.ticks_counter) control.global_volume-=lo; + } + + if (control.global_volume<0) control.global_volume=0; + if (control.global_volume>128) control.global_volume=128; +} + +void CPPlayer::do_panbrello(int p_track) { + + uint8_t q; + int32_t temp=0; + + q=control.channel[p_track].panbrello_position; + + switch (control.channel[p_track].panbrello_type) { + case 0: {/* sine */ + temp=panbrello_table[q]; + } break; + case 1: {/* square wave */ + temp=(q<0x80)?64:0; + } break; + case 2: {/* ramp down */ + q<<=3; + temp=q; + } break; + case 3: {/* random */ + if (control.channel[p_track].panbrello_position>=control.channel[p_track].panbrello_speed) { + control.channel[p_track].panbrello_position=0; + temp=cp_random_generate(&control.random_seed)%256;//getrandom(256); + } + } break; + } + + + + temp=temp*(int)control.channel[p_track].panbrello_depth/0xF; + temp<<=1; + if (control.channel[p_track].channel_panning!=PAN_SURROUND) + temp+=control.channel[p_track].channel_panning; + + control.channel[p_track].panning=(temp<PAN_LEFT)?PAN_LEFT:(temp>PAN_RIGHT?PAN_RIGHT:temp); + control.channel[p_track].panbrello_position+=control.channel[p_track].panbrello_speed; +} + +/****************** + S effect +*******************/ + + +void CPPlayer::do_effect_S(int p_track) { + + uint8_t inf,c,dat; + + dat=control.channel[p_track].current_parameter; + + inf=dat&0xf; + c=dat>>4; + + if (!dat) { + c=control.channel[p_track].current_S_effect; + inf=control.channel[p_track].current_S_data; + } else { + control.channel[p_track].current_S_effect=c; + control.channel[p_track].current_S_data=inf; + } + + switch (c) { + case 1: {/* S1x set glissando voice */ + // this is unsupported in IT! + + control.channel[p_track].chorus_send=inf*0xFF/0xF; + + }break; + case 2: /* S2x set finetune */ + //Also not supported! + break; + case 3: /* S3x set vibrato waveform */ + if (inf<4) control.channel[p_track].vibrato_type=inf; + break; + case 4: /* S4x set tremolo waveform */ + if (inf<4) control.channel[p_track].tremolo_type=inf; + break; + case 5: /* S5x panbrello */ + if (inf<4) control.channel[p_track].panbrello_type=inf; + break; + case 6: {/* S6x delay x number of frames (patdly) */ + + if (control.ticks_counter) break; + if (!control.pattern_delay_2) control.pattern_delay_1=inf+1; /* only once, when vbtick=0 */ + + } break; + case 7: /* S7x instrument / NNA commands */ + + if (!song->has_instruments()) + break; + switch(inf) { + + case 0x3: { + + control.channel[p_track].NNA_type=CPInstrument::NNA_NOTE_CUT; + } break; + case 0x4: { + + control.channel[p_track].NNA_type=CPInstrument::NNA_NOTE_CONTINUE; + } break; + case 0x5: { + + control.channel[p_track].NNA_type=CPInstrument::NNA_NOTE_OFF; + } break; + case 0x6: { + + control.channel[p_track].NNA_type=CPInstrument::NNA_NOTE_FADE; + } break; + case 0x7: { + + if (control.channel[p_track].slave_voice) + control.channel[p_track].slave_voice->volume_envelope_ctrl.active=false; + } break; + case 0x8: { + + if (control.channel[p_track].slave_voice) + control.channel[p_track].slave_voice->volume_envelope_ctrl.active=true; + + } break; + case 0x9: { + + if (control.channel[p_track].slave_voice) + control.channel[p_track].slave_voice->panning_envelope_ctrl.active=false; + + } break; + case 0xA: { + + if (control.channel[p_track].slave_voice) + control.channel[p_track].slave_voice->panning_envelope_ctrl.active=true; + + } break; + case 0xB: { + if (control.channel[p_track].slave_voice) + control.channel[p_track].slave_voice->pitch_envelope_ctrl.active=false; + + } break; + case 0xC: { + + if (control.channel[p_track].slave_voice) + control.channel[p_track].slave_voice->pitch_envelope_ctrl.active=true; + + } break; + + } break; + + break; + case 8: {/* S8x set panning position */ + +// if (pf->panflag) { + if (inf<=8) inf<<=4; + else inf*=17; + control.channel[p_track].panning=control.channel[p_track].channel_panning=inf; +// } + } break; + + case 9: { /* S9x set surround sound */ + //if (pf->panflag) + control.channel[p_track].panning=control.channel[p_track].channel_panning=PAN_SURROUND; + } break; + case 0xA:{ /* SAy set high order sample offset yxx00h */ + + if (control.channel[p_track].current_parameter) control.channel[p_track].hi_offset=(int32_t)inf<<16; + control.channel[p_track].sample_start_index=control.channel[p_track].hi_offset|control.channel[p_track].lo_offset; + } break; + case 0xB: { /* SBx pattern loop */ + if (control.ticks_counter) break; + + if (inf) { /* set reppos or repcnt ? */ + /* set repcnt, so check if repcnt already is set, which means we + are already looping */ + if (control.channel[p_track].pattern_loop_count>0) + control.channel[p_track].pattern_loop_count--; /* already looping, decrease counter */ + else { + control.channel[p_track].pattern_loop_count=inf; /* not yet looping, so set repcnt */ + } + + if (control.channel[p_track].pattern_loop_count>0) { /* jump to reppos if repcnt>0 */ + + control.position=control.previous_position; // This will also anulate any Cxx or break.. + + control.position.current_row=control.channel[p_track].pattern_loop_position; + control.position.forbid_jump=true; + } + + } else { + + + control.channel[p_track].pattern_loop_position=control.position.current_row-1; + } + + } break; + case 0xC: { /* SCx notecut */ + + if (control.ticks_counter>=inf) { + + control.channel[p_track].aux_volume=0; + control.channel[p_track].note_end_flags|=END_NOTE_OFF; + control.channel[p_track].note_end_flags|=END_NOTE_KILL; + } + } break; + case 0xD: {/* SDx notedelay */ + + if (!control.ticks_counter) { + + control.channel[p_track].note_delay=inf; + + } else if (control.channel[p_track].note_delay) { + + control.channel[p_track].note_delay--; + } + + } break; + case 0xF: {/* SEx patterndelay */ + + if (control.ticks_counter) break; + if (!control.pattern_delay_2) control.pattern_delay_1=inf+1; /* only once, when vbtick=0 */ + + } break; + } +} + + + + + + + + +/********************* + volume effects +**********************/ + +void CPPlayer::run_volume_column_effects(int p_track) { + + uint8_t param=control.channel[p_track].current_volume_parameter; + + + switch ('A'+control.channel[p_track].current_volume_command) { + + case 'A': { + + if (param>0) control.channel[p_track].volcol_volume_slide=param; + else param=control.channel[p_track].volcol_volume_slide; + + do_volume_slide(p_track,param*0x10+0xF); + + } break; + case 'B': { + + if (param>0) control.channel[p_track].volcol_volume_slide=param; + else param=control.channel[p_track].volcol_volume_slide; + + do_volume_slide(p_track,0xF0+param); + + } break; + case 'C': { + + if (param>0) control.channel[p_track].volcol_volume_slide=param; + else param=control.channel[p_track].volcol_volume_slide; + + do_volume_slide(p_track,param*0x10); + } break; + case 'D': { + + if (param>0) control.channel[p_track].volcol_volume_slide=param; + else param=control.channel[p_track].volcol_volume_slide; + do_volume_slide(p_track,param); + + } break; + case 'E': { + + do_pitch_slide_down(p_track,param<<2); + } break; + case 'F': { + + do_pitch_slide_up(p_track,param<<2); + } break; + case 'G': { + + const uint8_t slide_table[]={0,1,4,8,16,32,64,96,128,255}; + if (param) { + + control.channel[p_track].portamento_speed=slide_table[param]; + } + + if (control.channel[p_track].period && (control.channel[p_track].old_note<=120)) { + + if ( (!control.ticks_counter) && (control.channel[p_track].new_instrument) ){ + + //control.channel[p_track].kick=KICK_NOTE; + //control.channel[p_track].sample_start_index=0; // < am i stupid? + } else { + + control.channel[p_track].kick=(control.channel[p_track].kick==KICK_NOTE)?KICK_ENVELOPE:KICK_NOTHING; + do_pitch_slide_to_note(p_track); + control.channel[p_track].has_own_period=true; + } + + } + } break; + case 'H': { + + + if (!control.ticks_counter) { + if (param&0x0f) control.channel[p_track].vibrato_depth=param; + } + control.channel[p_track].doing_vibrato=true; + if (control.external_vibrato) break; + if (control.channel[p_track].period) { + + do_vibrato(p_track,false); + control.channel[p_track].has_own_period=true; + } + + } break; + } +} +/********************* + table +**********************/ + + +void CPPlayer::run_effects(int p_track) { + + switch ('A'+control.channel[p_track].current_command) { + + case 'A': { + + if ((control.ticks_counter>0) || (control.pattern_delay_2>0)) break; + + int new_speed; + + new_speed=control.channel[p_track].current_parameter % 128; + + if (new_speed>0) { + control.speed=new_speed; + control.ticks_counter=0; + } + } break; + case 'B': { + + int next_order; + + if (control.ticks_counter || control.position.forbid_jump) break; + + control.position.current_row=0; + + if (control.play_mode==PLAY_PATTERN) break; + + next_order=get_song_next_order_idx(song, (int)control.channel[p_track].current_parameter-1); + + if (next_order!=-1) { + // Do we have a "next order?" + control.position.current_pattern=song->get_order(next_order); + control.position.force_next_order=next_order; + + } else { + // no, probably the user deleted the orderlist. + control.play_mode=PLAY_NOTHING; + reset(); + } + } break; + case 'C': { + + int next_order; + + if (control.ticks_counter || control.position.forbid_jump) break; + + control.position.current_row=control.channel[p_track].current_parameter; + + if (control.play_mode==PLAY_PATTERN) { + + if (control.position.current_row>=song->get_pattern(control.position.current_pattern)->get_length()) { + + control.position.current_row=0; + } + + break; + } + + next_order=get_song_next_order_idx(song, (int)control.position.current_order); + + if (next_order!=-1) { + // Do we have a "next order?" + control.position.current_pattern=song->get_order(next_order); + + if (control.position.current_row>=song->get_pattern(song->get_order(next_order))->get_length()) { + + control.position.current_row=0; + } + + control.position.force_next_order=next_order; + + } else { + // no, probably the user deleted the orderlist. + control.play_mode=PLAY_NOTHING; + reset(); + } + + } break; + case 'D': { + + uint8_t inf ; + //explicitslides=1; + inf=control.channel[p_track].current_parameter; + + if (inf) control.channel[p_track].volume_slide_info=inf; + else inf=control.channel[p_track].volume_slide_info; + + do_volume_slide(p_track,inf); + + } break; + case 'E': { + + uint8_t inf; + + inf=control.channel[p_track].current_parameter; + do_pitch_slide_down(p_track,inf); + + } break; + case 'F': { + + uint8_t inf; + + inf=control.channel[p_track].current_parameter; + do_pitch_slide_up(p_track,inf); + + } break; + case 'G': { + + if (control.channel[p_track].current_parameter) { + + control.channel[p_track].portamento_speed=control.channel[p_track].current_parameter; + } + + if (control.channel[p_track].period && (control.channel[p_track].old_note<=120)) { + + if ( (!control.ticks_counter) && (control.channel[p_track].new_instrument) ){ + + + control.channel[p_track].kick=KICK_NOTE; + control.channel[p_track].sample_start_index=0; + + } else { + + control.channel[p_track].kick=(control.channel[p_track].kick==KICK_NOTE)?KICK_ENVELOPE:KICK_NOTHING; + } + + do_pitch_slide_to_note(p_track); + control.channel[p_track].has_own_period=true; + } + + } break; + case 'H': { + + uint8_t dat; + + control.channel[p_track].doing_vibrato=true; + + dat=control.channel[p_track].current_parameter; + + if (!control.ticks_counter) { + if (dat&0x0f) control.channel[p_track].vibrato_depth=dat&0xf; + if (dat&0xf0) control.channel[p_track].vibrato_speed=(dat&0xf0)>>2; + } + + if (control.external_vibrato) break; + + if (control.channel[p_track].period) { + + do_vibrato(p_track,false); + control.channel[p_track].has_own_period=true; + } + + } break; + case 'I': { + + do_tremor(p_track); + control.channel[p_track].has_own_volume=true; + } break; + case 'J': { + + do_arpegio(p_track); + } break; + case 'K': { + + uint8_t inf ; + //explicitslides=1; + inf=control.channel[p_track].current_parameter; + + control.channel[p_track].doing_vibrato=true; + + + if (inf) control.channel[p_track].volume_slide_info=inf; + else inf=control.channel[p_track].volume_slide_info; + + do_volume_slide(p_track,inf); + + if (control.external_vibrato) break; + + if (control.channel[p_track].period) { + + do_vibrato(p_track,false); + control.channel[p_track].has_own_period=true; + } + + } break; + case 'L': { + uint8_t inf ; + //explicitslides=1; + inf=control.channel[p_track].current_parameter; + + if (inf) control.channel[p_track].volume_slide_info=inf; + else inf=control.channel[p_track].volume_slide_info; + + do_volume_slide(p_track,inf); + + if (control.channel[p_track].period && (control.channel[p_track].old_note<=120)) { + if ( (!control.ticks_counter) && (control.channel[p_track].new_instrument) ){ + + control.channel[p_track].kick=KICK_NOTE; + control.channel[p_track].sample_start_index=0; + + } else { + + control.channel[p_track].kick=(control.channel[p_track].kick==KICK_NOTE)?KICK_ENVELOPE:KICK_NOTHING; + } + + do_pitch_slide_to_note(p_track); + control.channel[p_track].has_own_period=true; + } + } break; + case 'M': { + control.channel[p_track].channel_volume=control.channel[p_track].current_parameter; + if (control.channel[p_track].channel_volume>64) control.channel[p_track].channel_volume=64; + else if (control.channel[p_track].channel_volume<0) control.channel[p_track].channel_volume=0; + } break; + case 'N': { + + do_channel_volume_slide(p_track); + } + case 'O': { + + if (!control.ticks_counter) { + + if (control.channel[p_track].current_parameter) control.channel[p_track].lo_offset=(uint16_t)control.channel[p_track].current_parameter<<8; + control.channel[p_track].sample_start_index=control.channel[p_track].hi_offset|control.channel[p_track].lo_offset; + + //if ((control.channel[p_track].sample_ptr!=NULL)&&(control.channel[p_track].sample_start_index>control.channel[p_track].sample_ptr->data.size)) { + //TODO, O effect + //a->start=a->s->flags&(SF_LOOP|SF_BIDI)?a->s->loopstart:a->s->length; + //} + } + } break; + case 'P': { + + do_pan_slide(p_track); + } break; + case 'Q': { + do_retrig(p_track); + + } break; + case 'R': { + + + uint8_t dat; + + if (control.channel[p_track].current_parameter) { + + control.channel[p_track].tremolo_info=control.channel[p_track].current_parameter; + } + + dat=control.channel[p_track].tremolo_info; + + if (!control.ticks_counter && dat) { + + if (dat&0x0f) control.channel[p_track].tremolo_depth=dat&0xf; + if (dat&0xf0) control.channel[p_track].tremolo_speed=(dat&0xf0)>>2; + } + + do_tremolo(p_track); + control.channel[p_track].has_own_volume=true; + + } break; + case 'S': { + + do_effect_S(p_track); + } break; + case 'T': { + uint8_t dat; + int16_t temp=control.tempo; + + if (control.pattern_delay_2) return; + + if (control.channel[p_track].current_parameter) { + + control.channel[p_track].tempo_slide_info=control.channel[p_track].current_parameter; + } + + dat=control.channel[p_track].tempo_slide_info; + + if (dat>=0x20) { + + if (control.ticks_counter) break; + control.tempo=dat; + } else { + + if (!control.ticks_counter) break; + + if (dat&0x10) { + + temp+=(dat&0x0f); + } else { + + temp-=dat; + } + control.tempo=(temp>255)?255:(temp<0x20?0x20:temp); + } + + } break; + case 'U': { + + uint8_t dat; + + dat=control.channel[p_track].current_parameter; + control.channel[p_track].doing_vibrato=true; + if (!control.ticks_counter) { + if (dat&0x0f) control.channel[p_track].vibrato_depth=dat&0xf; + if (dat&0xf0) control.channel[p_track].vibrato_speed=(dat&0xf0)>>2; + } + + if (control.external_vibrato) break; + + if (control.channel[p_track].period) { + + do_vibrato(p_track,true); + control.channel[p_track].has_own_period=true; + } + } break; + case 'V': { + + control.global_volume=control.channel[p_track].current_parameter; + if (control.global_volume>128) control.global_volume=128; + } break; + case 'W': { + do_global_volume_slide(p_track); + } break; + case 'X': { + //sets both channel and current + control.channel[p_track].channel_panning=control.channel[p_track].current_parameter; + control.channel[p_track].panning=control.channel[p_track].current_parameter; + } break; + case 'Y': { + + uint8_t dat; + + if (control.channel[p_track].current_parameter) { + + control.channel[p_track].panbrello_info=control.channel[p_track].current_parameter; + } + + dat=control.channel[p_track].panbrello_info; + + if (!control.ticks_counter) { + + if (dat&0x0f) control.channel[p_track].panbrello_depth=(dat&0xf); + if (dat&0xf0) control.channel[p_track].panbrello_speed=(dat&0xf0)>>4; + } + + //if (pf->panflag) + if (control.channel[p_track].panning!=PAN_SURROUND)do_panbrello(p_track); + + } break; + case 'Z': { + //I DO! cuttoff! + uint16_t dat=control.channel[p_track].current_parameter; + + if (dat<0x80) { + + control.channel[p_track].filter.it_cutoff=dat*2; + if (control.channel[p_track].filter.it_cutoff>0x80) + control.channel[p_track].filter.it_cutoff++; + } else if (dat<0x90) { + + control.channel[p_track].filter.it_reso=(dat-0x80)*0x10; + } else { + + control.channel[p_track].reverb_send=(dat-0x90)*255/0x6F; + } + + } break; + + } + +} + +void CPPlayer::pre_process_effects() { + +// MP_VOICE *aout; + int i; + + for (i=0;i<CPPattern::WIDTH;i++) { + + //a=&pf->control[mp_channel]; + + // if ((aout=a->slave)) { + // a->fadevol=aout->fadevol; + // a->period=aout->period; + // if (a->kick==KICK_KEYOFF) a->keyoff=aout->keyoff; + //} + + //if (!a->row) continue; + //UniSetRow(a->row); + control.channel[i].has_own_period=false; + control.channel[i].has_own_volume=false; + control.channel[i].doing_vibrato=false; + //explicitslides=0; + //pt_playeffects(); + if (control.ticks_counter<control.speed) { + + run_effects(i); + run_volume_column_effects(i); + } + + /* continue volume slide if necessary for XM and IT */ + //if (pf->flags&UF_BGSLIDES) { + // if (!explicitslides && a->sliding) + // DoS3MVolSlide(0); + // else if (a->tmpvolume) a->sliding=explicitslides; + //} + + if (!control.channel[i].has_own_period) control.channel[i].period=control.channel[i].aux_period; + if (!control.channel[i].has_own_volume) control.channel[i].volume=control.channel[i].aux_volume; + + if ((control.channel[i].sample_ptr!=NULL) && !(song->has_instruments() && (control.channel[i].instrument_ptr==NULL))) { + + if (song->has_instruments()) { + + control.channel[i].output_volume= + (control.channel[i].volume*control.channel[i].sample_ptr->get_global_volume()*control.channel[i].instrument_ptr->get_volume_global_amount())/2048; + control.channel[i].output_volume=control.channel[i].output_volume*control.channel[i].random_volume_variation/100; + + } else { + + control.channel[i].output_volume= + (control.channel[i].volume*control.channel[i].sample_ptr->get_global_volume())>>4; + + } + + if (control.channel[i].output_volume>256) { + + control.channel[i].output_volume=256; + + } else if (control.channel[i].output_volume<0) { + + control.channel[i].output_volume=0; + } + + + } + } + +} diff --git a/modules/chibi/cp_player_data_envelopes.cpp b/modules/chibi/cp_player_data_envelopes.cpp new file mode 100644 index 0000000000..96af42d19f --- /dev/null +++ b/modules/chibi/cp_player_data_envelopes.cpp @@ -0,0 +1,89 @@ +/*************************************************************************/ +/* cp_player_data_envelopes.cpp */ +/*************************************************************************/ +/* This file is part of: */ +/* GODOT ENGINE */ +/* http://www.godotengine.org */ +/*************************************************************************/ +/* Copyright (c) 2007-2016 Juan Linietsky, Ariel Manzur. */ +/* */ +/* Permission is hereby granted, free of charge, to any person obtaining */ +/* a copy of this software and associated documentation files (the */ +/* "Software"), to deal in the Software without restriction, including */ +/* without limitation the rights to use, copy, modify, merge, publish, */ +/* distribute, sublicense, and/or sell copies of the Software, and to */ +/* permit persons to whom the Software is furnished to do so, subject to */ +/* the following conditions: */ +/* */ +/* The above copyright notice and this permission notice shall be */ +/* included in all copies or substantial portions of the Software. */ +/* */ +/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */ +/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */ +/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/ +/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */ +/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */ +/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */ +/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ +/*************************************************************************/ + +#include "cp_player_data.h" + + +void CPPlayer::Voice_Control::start_envelope(CPEnvelope *p_envelope,Envelope_Control *p_envelope_ctrl,Envelope_Control *p_from_env) { + + + if (p_from_env && p_envelope->is_carry_enabled() && !p_from_env->terminated) { + + + *p_envelope_ctrl=*p_from_env; + } else { + p_envelope_ctrl->pos_index=0; + p_envelope_ctrl->status=1; + p_envelope_ctrl->sustain_looping=p_envelope->is_sustain_loop_enabled(); + p_envelope_ctrl->looping=p_envelope->is_loop_enabled(); + p_envelope_ctrl->terminated=false; + p_envelope_ctrl->kill=false; + p_envelope_ctrl->value=p_envelope->get_height_at_pos(p_envelope_ctrl->pos_index); + } +} + +bool CPPlayer::Voice_Control::process_envelope(CPEnvelope *p_envelope,Envelope_Control *p_envelope_ctrl) { + + if (!p_envelope_ctrl->active) + return false; + + if (note_end_flags&END_NOTE_OFF) p_envelope_ctrl->sustain_looping=false; + + p_envelope_ctrl->value=p_envelope->get_height_at_pos(p_envelope_ctrl->pos_index); + if (p_envelope_ctrl->value==CPEnvelope::NO_POINT) + return false; + + + p_envelope_ctrl->pos_index++; + + if (p_envelope_ctrl->sustain_looping) { + + if (p_envelope_ctrl->pos_index>p_envelope->get_node(p_envelope->get_sustain_loop_end()).tick_offset) { + + p_envelope_ctrl->pos_index=p_envelope->get_node(p_envelope->get_sustain_loop_begin()).tick_offset; + } + + } else if (p_envelope_ctrl->looping) { + + if (p_envelope_ctrl->pos_index>p_envelope->get_node(p_envelope->get_loop_end()).tick_offset) { + + p_envelope_ctrl->pos_index=p_envelope->get_node(p_envelope->get_loop_begin()).tick_offset; + } + + } + + if (p_envelope_ctrl->pos_index>p_envelope->get_node(p_envelope->get_node_count()-1).tick_offset) { + + p_envelope_ctrl->terminated=true; + p_envelope_ctrl->pos_index=p_envelope->get_node(p_envelope->get_node_count()-1).tick_offset; + if (p_envelope->get_node(p_envelope->get_node_count()-1).value==0) p_envelope_ctrl->kill=true; + } + + return true; +} diff --git a/modules/chibi/cp_player_data_events.cpp b/modules/chibi/cp_player_data_events.cpp new file mode 100644 index 0000000000..fb5090461b --- /dev/null +++ b/modules/chibi/cp_player_data_events.cpp @@ -0,0 +1,679 @@ +/*************************************************************************/ +/* cp_player_data_events.cpp */ +/*************************************************************************/ +/* This file is part of: */ +/* GODOT ENGINE */ +/* http://www.godotengine.org */ +/*************************************************************************/ +/* Copyright (c) 2007-2016 Juan Linietsky, Ariel Manzur. */ +/* */ +/* Permission is hereby granted, free of charge, to any person obtaining */ +/* a copy of this software and associated documentation files (the */ +/* "Software"), to deal in the Software without restriction, including */ +/* without limitation the rights to use, copy, modify, merge, publish, */ +/* distribute, sublicense, and/or sell copies of the Software, and to */ +/* permit persons to whom the Software is furnished to do so, subject to */ +/* the following conditions: */ +/* */ +/* The above copyright notice and this permission notice shall be */ +/* included in all copies or substantial portions of the Software. */ +/* */ +/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */ +/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */ +/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/ +/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */ +/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */ +/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */ +/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ +/*************************************************************************/ + +#include "cp_player_data.h" +#include "cp_sample_manager.h" +#include "stdio.h" +/* + setup_voices(): + +This will go throught all the REAL channels, if it finds a channel +that needs to be restarted or assigned a new VIRTUAL channel, then it +will just find one and do it. + +*/ + + +#define C5FREQ 261.6255653006 +static const int32_t C5FREQ_MIXER = ((int32_t)(C5FREQ*(float)(1<<CPMixer::FREQUENCY_BITS))); + + +void CPPlayer::setup_voices() { + + int i,voice_index; + + + + + for (i=0;i<CPPattern::WIDTH;i++) { + + voice_index=-1; + + if (control.channel[i].note_delay) continue; + + + // check if we need a new empty voice + if (control.channel[i].kick==KICK_NOTE) { + + /* if no channel was cut above, find an empty or quiet channel + here */ + if ( song->has_instruments() && !control.force_no_nna) { + + if (control.channel[i].slave_voice==NULL) { // no slave?? + + int newchn; + if ((newchn=find_empty_voice())!=-1) { + + control.channel[i].slave_voice_index=newchn; + control.channel[i].slave_voice=&voice[newchn]; + } + } + + } else { + if (i<control.max_voices) { + + control.channel[i].slave_voice_index=i; + control.channel[i].slave_voice=&voice[i]; + } else { + //This is a _DIRTY_ hack, but i cant think a better way. + control.channel[i].slave_voice_index=control.max_voices-1; + control.channel[i].slave_voice=&voice[control.max_voices-1]; + } + + } + + + /* assign parts of MP_VOICE only done for a KICK_NOTE */ + if ( ( control.channel[i].slave_voice!=NULL ) ) { + + voice_index=control.channel[i].slave_voice_index; + Voice_Control &v=voice[voice_index]; + + if (v.has_master_channel && (v.master_channel!=NULL) ) { + // If this voice already has a master channel, make sure to remove the reference to it. + v.master_channel->slave_voice=NULL; + + } + //notify the voice that the current channel is the master + v.master_channel=&control.channel[i]; + //set the voice as slave of the current channel + control.channel[i].slave_voice=&v; + //master channel index of the voice + v.master_channel_index=i; + v.has_master_channel=true; + } + + } else { + // nope.. + // so if we DO have a slave voice then use it. + if ( control.channel[i].slave_voice!=NULL ) { + + voice_index=control.channel[i].slave_voice_index; + } + } + //assuming this channel has a slave voice.. + if (voice_index>=0) { + + // IMPROVE: Code a method for this: + voice[voice_index].update_info_from_master_channel(); + } + + control.channel[i].kick=KICK_NOTHING; + } +} +void CPPlayer::Voice_Control::reset() { + + cp_memzero(this,sizeof(*this)); + + instrument_ptr=NULL; + sample_ptr=NULL; + has_master_channel=false; + instrument_index=-1; + reverb_send=0; + chorus_send=0; + filter.it_cutoff=255; + filter.it_reso=0; + display_volume=0; + + +} + +void CPPlayer::Channel_Control::reset() { + + int prev_gv =channel_global_volume; + cp_memzero(this,sizeof(*this)); + + slave_voice=NULL; + slave_voice_index=255; + + mute=false; + old_note=255; + real_note=255; + instrument_index=255; + filter.it_cutoff=255; + filter.it_reso=0; + reverb_send=0; + chorus_send=0; + reserved=false; + carry.maybe=false; + last_event_usecs=-1; + channel_global_volume=prev_gv; +} + +void CPPlayer::Voice_Control::update_info_from_master_channel() { + + instrument_ptr=master_channel->instrument_ptr; + sample_ptr=master_channel->sample_ptr; + + instrument_index=master_channel->instrument_index; + sample_index=master_channel->sample_index; + + note=master_channel->note; + output_volume=master_channel->output_volume; + + channel_volume=master_channel->channel_volume; + + panning=master_channel->panning; + + kick=master_channel->kick; + note_end_flags=master_channel->note_end_flags; + period=master_channel->period; + + volume_envelope_ctrl.active=master_channel->volume_envelope_on; + panning_envelope_ctrl.active=master_channel->panning_envelope_on; + pitch_envelope_ctrl.active=master_channel->pitch_envelope_on; + + + NNA_type=master_channel->NNA_type; + reverb_send=master_channel->reverb_send; + chorus_send=master_channel->chorus_send; + +// last_note_type=master_channel->last_note_type; + + sample_start_index=master_channel->sample_start_index; + filter=master_channel->filter; + +} + + +void CPPlayer::update_mixer() { + + int tmp_mixer_period; + int32_t tmp_vibrato_value,tmp_vibrato_depth,tmp_volenv_value; + uint64_t tmpvol; // 64bits should be the only way to avoid getting notes raped out + int i; + + + control.voices_used=0; + + for (i=0;i<control.max_voices;i++) { + + + int filter_env=-1; + Voice_Control &v=voice[i]; + + if ( !((v.kick==KICK_NOTE)||(v.kick==KICK_NOTEOFF)) && !is_voice_active(i)) + continue; + + //if voice doesnt have a sample set or size is 0.. forget it + if ( v.sample_ptr==NULL) continue; + + + //TODO set limits somewhere else + + if (v.period<40) { + + v.period=40; + + } else if (v.period>50000) { + + v.period=50000; + } + + + if ((v.kick==KICK_NOTE)||(v.kick==KICK_NOTEOFF)) { + + int real_start_index; + + if (v.sample_start_index==-1) { + + real_start_index=0; + + } else { + + real_start_index=v.sample_start_index; + } + + mixer->setup_voice(i,v.sample_ptr->get_sample_data(),real_start_index); + v.fadeout_volume=1024; //IT Docs it is 1024 internally + v.auto_vibrato_sweep_pos=0; + + + + } + + + /* Start Envelopes */ + if ( song->has_instruments() && ((v.kick==KICK_NOTE)||(v.kick==KICK_ENVELOPE))) { + +// Voice_Control *carry=0; + + + if (v.has_master_channel && v.master_channel->carry.maybe) { + + v.start_envelope(v.instrument_ptr->get_volume_envelope(),&v.volume_envelope_ctrl,&v.master_channel->carry.vol); + v.start_envelope(v.instrument_ptr->get_pan_envelope(),&v.panning_envelope_ctrl,&v.master_channel->carry.pan); + v.start_envelope(v.instrument_ptr->get_pitch_filter_envelope(),&v.pitch_envelope_ctrl,&v.master_channel->carry.pitch); + + } else { + + v.start_envelope(v.instrument_ptr->get_volume_envelope(),&v.volume_envelope_ctrl,NULL); + v.start_envelope(v.instrument_ptr->get_pan_envelope(),&v.panning_envelope_ctrl,NULL); + v.start_envelope(v.instrument_ptr->get_pitch_filter_envelope(),&v.pitch_envelope_ctrl,NULL); + + } + + + } + + v.kick=KICK_NOTHING; + + if (song->has_instruments()) { + + if (!v.process_envelope(v.instrument_ptr->get_volume_envelope(),&v.volume_envelope_ctrl)) + v.volume_envelope_ctrl.value=64; + + if (!v.process_envelope(v.instrument_ptr->get_pan_envelope(),&v.panning_envelope_ctrl)) + v.panning_envelope_ctrl.value=0; + + if (!v.process_envelope(v.instrument_ptr->get_pitch_filter_envelope(),&v.pitch_envelope_ctrl)) + v.pitch_envelope_ctrl.value=0; + + + if (v.volume_envelope_ctrl.terminated) { + + if (v.volume_envelope_ctrl.kill) { + + v.fadeout_volume=0; + } else { + + v.note_end_flags|=END_NOTE_FADE; + } + } + + } + + if (song->has_instruments()) { + + tmp_volenv_value=v.volume_envelope_ctrl.value; + } else { + + tmp_volenv_value=64; + + } + + /*printf("fadeout %i\n",(int)v.fadeout_volume); + printf("channel %i\n",(int)v.channel_volume); + printf("output %i\n",(int)v.output_volume); + printf("env %i\n",(int)tmp_volenv_value); + printf("cgb %i\n",(int)v.master_channel->channel_global_volume); +*/ + + + tmpvol=(uint64_t)v.fadeout_volume; /* max 1024 - 10 bits */ + tmpvol*=(uint64_t)v.channel_volume; /* * max 64 - 6 bits */ + tmpvol*=(uint64_t)v.output_volume; /* * max 256 - 8 bits */ + tmpvol*=(uint64_t)tmp_volenv_value; /* max 64 - 6 bits*/ + tmpvol*=(uint64_t)v.master_channel->channel_global_volume; + v.display_volume=tmpvol>>22; //volume used for display purposes , 0 -- 256 + + tmpvol*=(uint64_t)song->get_mixing_volume(); /* max 128 - 7 bits */ + tmpvol*=(uint64_t)control.global_volume; /* max 128 - 7 bits*/ + /* total 10+6+8+6+7+7=44 bits */ + + tmpvol>>=43; /* Move back to 8 bits range , 44-19+8=43*/ + + if (tmpvol>CP_VOL_MAX) + tmpvol=CP_VOL_MAX; + + //printf("volume check - fade %i, channel %i, output %i, env %i, mix %i, global %i -- final %i\n",v.fadeout_volume, v.channel_volume,v.output_volume,tmp_volenv_value, song->get_mixing_volume(),control.global_volume,tmpvol); + + v.total_volume=tmpvol; + + + if ((v.master_channel!=NULL) && song->is_channel_mute( v.master_channel_index ) && !v.master_channel->reserved) { + + mixer->set_voice_volume(i,0); + } else { + mixer->set_voice_volume(i,tmpvol); + if (v.fadeout_volume>0) control.voices_used++; + } + + + if (!song->is_stereo()) { + + mixer->set_voice_panning(i,PAN_CENTER); + + } else if (v.panning==PAN_SURROUND) { + + mixer->set_voice_panning(i,PAN_SURROUND); + } else if (song->has_instruments()) { + + int newpan,real_modifier; + + + real_modifier=(v.panning_envelope_ctrl.value*(PAN_CENTER-cp_intabs(v.panning-PAN_CENTER)))/32; + + newpan=v.panning+real_modifier; + + newpan=(newpan<PAN_LEFT)?PAN_LEFT:(newpan>PAN_RIGHT)?PAN_RIGHT:newpan; + //printf("panenv val: %i, finalpan val %i\n",v.panning_envelope_ctrl.value,newpan); + + mixer->set_voice_panning(i,newpan); + } else { + mixer->set_voice_panning(i,v.panning); + } + + + + /* VIBRATO */ + + if ( (v.period>0) && (v.sample_ptr->get_vibrato_depth()>0) ) { + + switch (v.sample_ptr->get_vibrato_type()) { + case CPSample::VIBRATO_SINE: + tmp_vibrato_value=auto_vibrato_table[v.auto_vibrato_pos&127]; + if (v.auto_vibrato_pos & 0x80) tmp_vibrato_value=-tmp_vibrato_value; + break; + case CPSample::VIBRATO_SQUARE: + tmp_vibrato_value=64; + if (v.auto_vibrato_pos & 0x80) tmp_vibrato_value=-tmp_vibrato_value; + break; + case CPSample::VIBRATO_SAW: + tmp_vibrato_value=63-(((v.auto_vibrato_pos+128)&255)>>1); + break; + default: + tmp_vibrato_value=(((v.auto_vibrato_pos+128)&255)>>1)-64; + break; + } + } else { + + tmp_vibrato_value=0; + } + + if ((v.auto_vibrato_sweep_pos>>8)<v.sample_ptr->get_vibrato_depth()) { + + v.auto_vibrato_sweep_pos+=v.sample_ptr->get_vibrato_speed(); //FIXME - speed? i think so + tmp_vibrato_depth=v.auto_vibrato_sweep_pos; + + } else { + + tmp_vibrato_depth=v.sample_ptr->get_vibrato_depth()<<8; + } + + tmp_vibrato_value=(tmp_vibrato_value*tmp_vibrato_depth)>>16; + if (song->has_linear_slides()) + tmp_vibrato_value>>=1; + v.period-=tmp_vibrato_value; + + + /* update vibrato position */ + v.auto_vibrato_pos=(v.auto_vibrato_pos+v.sample_ptr->get_vibrato_rate())&0xff; + + + /* process pitch envelope */ + tmp_mixer_period=v.period; + + if (v.pitch_envelope_ctrl.active) { + + long aux_pitch_diff; + int pe_value=v.pitch_envelope_ctrl.value; + + if (!v.instrument_ptr->is_pitch_use_as_filter()) { + + + if (((uint16_t)v.note<<1)+pe_value<=0) + pe_value=-(v.note<<1); + + int smp_c5=CPSampleManager::get_singleton()->get_c5_freq( v.sample_ptr->get_sample_data()); + + int base=get_period(((uint16_t)v.note<<1),smp_c5); + int env=get_period(((uint16_t)v.note<<1)+pe_value,smp_c5); + /* + int env_next=(pe_value<0)?get_period(((uint16_t)(v.note-1)<<1)+pe_value,smp_c5):get_period(((uint16_t)(v.note+1)<<1)+pe_value,smp_c5); + + env=env+(abs(v.pitch_envelope_ctrl.value)&((1<<CPEnvelope::FX_HEIGHT_BITS)-1))*(env_next-env)/(1<<CPEnvelope::FX_HEIGHT_BITS); + + printf("env %i\n",env); + */ + aux_pitch_diff=env-base; + + + if ( ((int)tmp_mixer_period-aux_pitch_diff)<0 ) aux_pitch_diff=0; + + tmp_mixer_period+=aux_pitch_diff; + + } else { + + filter_env=pe_value+32; //max 64 +// printf("pitch envelope at %i",filter_env); + + } + } + + if (v.fadeout_volume==0 || (v.note_end_flags & END_NOTE_KILL)) { /* check for a dead note (fadevol=0) */ + + mixer->stop_voice(i); + + } else { + + + int32_t freq=get_frequency(tmp_mixer_period); + int32_t tracker_c5=get_frequency(get_period(60<<1,CPSampleManager::get_singleton()->get_c5_freq( v.sample_ptr->get_sample_data()))); + + freq=(int32_t)((uint64_t)freq*(uint64_t)C5FREQ_MIXER/(uint64_t)tracker_c5); //numbers may become very high + mixer->set_voice_frequency(i,freq); + + /* if keyfade, start substracting fadeoutspeed from fadevol: */ + if ((song->has_instruments())&&(v.note_end_flags & END_NOTE_FADE)) { + + if (v.fadeout_volume>=(v.instrument_ptr->get_volume_fadeout())) { + + v.fadeout_volume-=(v.instrument_ptr->get_volume_fadeout()); + } else { + + v.fadeout_volume=0; + } + } + + /*FILTARSSSSSSSS*/ + + + + v.filter.envelope_cutoff=filter_env; + v.filter.process(); + + if ((v.filter.final_cutoff<0xFF) && (control.filters)) { + + //int final_cutoff; + //uint8_t final_reso; + + //v.filter.set_filter_parameters( &final_cutoff, &final_reso ); + + mixer->set_voice_filter(i,true,v.filter.final_cutoff,v.filter.it_reso); + } else { + + + mixer->set_voice_filter(i,false,0,0); + } + + /* RAIVERV */ + + mixer->set_voice_reverb_send(i,v.reverb_send); + + /* CHAURUZ */ + + mixer->set_voice_chorus_send(i,v.chorus_send); + + } + } + + + switch(song->get_reverb_mode()) { + + case CPSong::REVERB_MODE_ROOM: { + + mixer->set_reverb_mode( CPMixer::REVERB_MODE_ROOM ); + } break; + case CPSong::REVERB_MODE_STUDIO_SMALL: { + + mixer->set_reverb_mode( CPMixer::REVERB_MODE_STUDIO_SMALL ); + + } break; + case CPSong::REVERB_MODE_STUDIO_MEDIUM: { + + mixer->set_reverb_mode( CPMixer::REVERB_MODE_STUDIO_MEDIUM ); + + } break; + case CPSong::REVERB_MODE_STUDIO_LARGE: { + + mixer->set_reverb_mode( CPMixer::REVERB_MODE_STUDIO_LARGE ); + + } break; + case CPSong::REVERB_MODE_HALL: { + + mixer->set_reverb_mode( CPMixer::REVERB_MODE_HALL ); + + } break; + case CPSong::REVERB_MODE_SPACE_ECHO: { + + mixer->set_reverb_mode( CPMixer::REVERB_MODE_SPACE_ECHO ); + + } break; + case CPSong::REVERB_MODE_ECHO: { + + mixer->set_reverb_mode( CPMixer::REVERB_MODE_ECHO ); + + } break; + case CPSong::REVERB_MODE_DELAY: { + + mixer->set_reverb_mode( CPMixer::REVERB_MODE_DELAY ); + + } break; + case CPSong::REVERB_MODE_HALF_ECHO: { + + mixer->set_reverb_mode( CPMixer::REVERB_MODE_HALF_ECHO ); + + } break; + + } + + mixer->set_chorus_params(song->get_chorus_delay_ms(),song->get_chorus_separation_ms(),song->get_chorus_depth_ms10(),song->get_chorus_speed_hz10() ); + + +} + + + + + + + + +void CPPlayer::handle_tick() { + + int i; + + + if ( mixer==NULL ) return; + if ( song==NULL ) return; + + + /* update time counter (sngtime is in milliseconds (in fact 2^-10)) */ + + if (control.ticks_counter>=control.speed) { // time to process... ***THE ROW***! + + /* process pattern-delay. pf->patdly2 is the counter and pf->patdly is + the command memory. */ + +// if (control.pattern_delay_1) { + +// control.pattern_delay_2=control.pattern_delay_1; +// control.pattern_delay_1=0; +// } +// if (control.pattern_delay_2) { +// patterndelay active +// if (--control.pattern_delay_2) +// so turn back pf->patpos by 1 +// if (pf->patpos) pf->patpos--; +// } + + if (control.play_mode!=PLAY_NOTHING) { + + control.ticks_counter=0; + + + if (control.position.force_next_order>=0) { + + control.position.current_order=control.position.force_next_order; + } + + control.position.force_next_order=-1; + + control.previous_position=control.position; // for those special cases... + control.position.forbid_jump=false; + + for (i=0;i<CPPattern::WIDTH;i++) { + + process_note(i,song->get_pattern(control.position.current_pattern)->get_note(i,control.position.current_row)); + } + + control.position.current_row++; + + if ( control.position.current_row>=song->get_pattern(control.position.current_pattern)->get_length() ) { + + if (control.play_mode==PLAY_SONG) { + + int next_order; + + next_order=get_song_next_order_idx(song,control.position.current_order); + + if (next_order!=-1) { + // Do we have a "next order?" + control.position.current_pattern=song->get_order(next_order); + if (next_order<=control.position.current_order) + control.reached_end=true; + control.position.current_order=next_order; + + } else { + // no, probably the user deleted the orderlist. + control.play_mode=PLAY_NOTHING; + reset(); + control.reached_end=true; + } + } + control.position.current_row=0; + } + + } + + + } + + + + pre_process_effects(); + process_NNAs(); + setup_voices(); + + /* now set up the actual hardware channel playback information */ + update_mixer(); + + control.ticks_counter++; +} diff --git a/modules/chibi/cp_player_data_filter.cpp b/modules/chibi/cp_player_data_filter.cpp new file mode 100644 index 0000000000..30db807eed --- /dev/null +++ b/modules/chibi/cp_player_data_filter.cpp @@ -0,0 +1,89 @@ +/*************************************************************************/ +/* cp_player_data_filter.cpp */ +/*************************************************************************/ +/* This file is part of: */ +/* GODOT ENGINE */ +/* http://www.godotengine.org */ +/*************************************************************************/ +/* Copyright (c) 2007-2016 Juan Linietsky, Ariel Manzur. */ +/* */ +/* Permission is hereby granted, free of charge, to any person obtaining */ +/* a copy of this software and associated documentation files (the */ +/* "Software"), to deal in the Software without restriction, including */ +/* without limitation the rights to use, copy, modify, merge, publish, */ +/* distribute, sublicense, and/or sell copies of the Software, and to */ +/* permit persons to whom the Software is furnished to do so, subject to */ +/* the following conditions: */ +/* */ +/* The above copyright notice and this permission notice shall be */ +/* included in all copies or substantial portions of the Software. */ +/* */ +/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */ +/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */ +/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/ +/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */ +/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */ +/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */ +/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ +/*************************************************************************/ + + +#include "cp_player_data.h" + +static float filter_cutoff[256] = { + 130, 132, 134, 136, 138, 140, 142, 144, + 146, 148, 151, 153, 155, 157, 160, 162, + 164, 167, 169, 172, 174, 177, 179, 182, + 184, 187, 190, 193, 195, 198, 201, 204, + 207, 210, 213, 216, 220, 223, 226, 229, + 233, 236, 239, 243, 246, 250, 254, 257, + 261, 265, 269, 273, 277, 281, 285, 289, + 293, 297, 302, 306, 311, 315, 320, 324, + 329, 334, 339, 344, 349, 354, 359, 364, + 369, 375, 380, 386, 391, 397, 403, 409, + 415, 421, 427, 433, 440, 446, 452, 459, + 466, 472, 479, 486, 493, 501, 508, 515, + 523, 530, 538, 546, 554, 562, 570, 578, + 587, 595, 604, 613, 622, 631, 640, 649, + 659, 668, 678, 688, 698, 708, 718, 729, + 739, 750, 761, 772, 783, 795, 806, 818, + 830, 842, 854, 867, 880, 892, 905, 918, + 932, 945, 959, 973, 987, 1002, 1016, 1031, + 1046, 1061, 1077, 1092, 1108, 1124, 1141, 1157, + 1174, 1191, 1209, 1226, 1244, 1262, 1280, 1299, + 1318, 1337, 1357, 1376, 1396, 1417, 1437, 1458, + 1479, 1501, 1523, 1545, 1567, 1590, 1613, 1637, + 1661, 1685, 1709, 1734, 1760, 1785, 1811, 1837, + 1864, 1891, 1919, 1947, 1975, 2004, 2033, 2062, + 2093, 2123, 2154, 2185, 2217, 2249, 2282, 2315, + 2349, 2383, 2418, 2453, 2489, 2525, 2561, 2599, + 2637, 2675, 2714, 2753, 2793, 2834, 2875, 2917, + 2959, 3003, 3046, 3091, 3135, 3181, 3227, 3274, + 3322, 3370, 3419, 3469, 3520, 3571, 3623, 3675, + 3729, 3783, 3838, 3894, 3951, 4008, 4066, 4125, + 4186, 4246, 4308, 4371, 4434, 4499, 4564, 4631, + 4698, 4766, 4836, 4906, 4978, 5050, 5123, 5198 +}; + + +void CPPlayer::Filter_Control::process() { + + + final_cutoff=it_cutoff; + if (envelope_cutoff>=0) { + + envelope_cutoff=envelope_cutoff*255/64; + final_cutoff=final_cutoff*envelope_cutoff/255; + if (final_cutoff>=0xFF) final_cutoff=0xFE; + + } + +} + +void CPPlayer::Filter_Control::set_filter_parameters(int *p_cutoff,uint8_t *p_reso) { + + + + *p_cutoff=filter_cutoff[final_cutoff]; + *p_reso=it_reso; +} diff --git a/modules/chibi/cp_player_data_nna.cpp b/modules/chibi/cp_player_data_nna.cpp new file mode 100644 index 0000000000..844f043694 --- /dev/null +++ b/modules/chibi/cp_player_data_nna.cpp @@ -0,0 +1,144 @@ +/*************************************************************************/ +/* cp_player_data_nna.cpp */ +/*************************************************************************/ +/* This file is part of: */ +/* GODOT ENGINE */ +/* http://www.godotengine.org */ +/*************************************************************************/ +/* Copyright (c) 2007-2016 Juan Linietsky, Ariel Manzur. */ +/* */ +/* Permission is hereby granted, free of charge, to any person obtaining */ +/* a copy of this software and associated documentation files (the */ +/* "Software"), to deal in the Software without restriction, including */ +/* without limitation the rights to use, copy, modify, merge, publish, */ +/* distribute, sublicense, and/or sell copies of the Software, and to */ +/* permit persons to whom the Software is furnished to do so, subject to */ +/* the following conditions: */ +/* */ +/* The above copyright notice and this permission notice shall be */ +/* included in all copies or substantial portions of the Software. */ +/* */ +/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */ +/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */ +/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/ +/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */ +/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */ +/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */ +/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ +/*************************************************************************/ + +#include "cp_player_data.h" + +void CPPlayer::process_NNAs() { + + int i; + + if (!song->has_instruments()) return; + + for (i=0;i<CPPattern::WIDTH;i++) { + + Channel_Control *aux_chn_ctrl = &control.channel[i]; + + if (aux_chn_ctrl->kick==KICK_NOTE) { + + bool k=false; + + if (aux_chn_ctrl->slave_voice!=NULL) { + + Voice_Control *aux_voc_ctrl; + + aux_voc_ctrl=aux_chn_ctrl->slave_voice; + + if (aux_chn_ctrl->instrument_index==aux_chn_ctrl->slave_voice->instrument_index) { //maybe carry + + aux_chn_ctrl->carry.pan=aux_chn_ctrl->slave_voice->panning_envelope_ctrl; + aux_chn_ctrl->carry.vol=aux_chn_ctrl->slave_voice->volume_envelope_ctrl; + aux_chn_ctrl->carry.pitch=aux_chn_ctrl->slave_voice->pitch_envelope_ctrl; + aux_chn_ctrl->carry.maybe=true; + } else + aux_chn_ctrl->carry.maybe=false; + + if (aux_voc_ctrl->NNA_type != CPInstrument::NNA_NOTE_CUT) { + /* Make sure the old MP_VOICE channel knows it has no + master now ! */ + + + + aux_chn_ctrl->slave_voice=NULL; + /* assume the channel is taken by NNA */ + aux_voc_ctrl->has_master_channel=false; + + switch (aux_voc_ctrl->NNA_type) { + case CPInstrument::NNA_NOTE_CONTINUE: { + + } break; + case CPInstrument::NNA_NOTE_OFF: { + + + aux_voc_ctrl->note_end_flags|=END_NOTE_OFF; + + if (!aux_voc_ctrl->volume_envelope_ctrl.active || aux_voc_ctrl->instrument_ptr->get_volume_envelope()->is_loop_enabled()) { + aux_voc_ctrl->note_end_flags|=END_NOTE_FADE; + } + } break; + case CPInstrument::NNA_NOTE_FADE: { + + aux_voc_ctrl->note_end_flags|=END_NOTE_FADE; + } break; + } + } + } + + if (aux_chn_ctrl->duplicate_check_type!=CPInstrument::DCT_DISABLED) { + int i; + + for (i=0;i<control.max_voices;i++) { + if (!mixer->is_voice_active(i)|| + (voice[i].master_channel!=aux_chn_ctrl) || + (aux_chn_ctrl->instrument_index!=voice[i].instrument_index)) + continue; + + Voice_Control *aux_voc_ctrl; + + aux_voc_ctrl=&voice[i]; + + k=false; + switch (aux_chn_ctrl->duplicate_check_type) { + case CPInstrument::DCT_NOTE: + if (aux_chn_ctrl->note==aux_voc_ctrl->note) + k=true; + break; + case CPInstrument::DCT_SAMPLE: + if (aux_chn_ctrl->sample_ptr==aux_voc_ctrl->sample_ptr) + k=true; + break; + case CPInstrument::DCT_INSTRUMENT: + k=true; + break; + } + if (k) { + switch (aux_chn_ctrl->duplicate_check_action) { + case CPInstrument::DCA_NOTE_CUT: { + aux_voc_ctrl->fadeout_volume=0; + } break; + case CPInstrument::DCA_NOTE_OFF: { + + aux_voc_ctrl->note_end_flags|=END_NOTE_OFF; + + if (!aux_voc_ctrl->volume_envelope_ctrl.active || aux_chn_ctrl->instrument_ptr->get_volume_envelope()->is_loop_enabled()) { + + aux_voc_ctrl->note_end_flags|=END_NOTE_FADE; + } + + } break; + case CPInstrument::DCA_NOTE_FADE: { + aux_voc_ctrl->note_end_flags|=END_NOTE_FADE; + } break; + } + } + } + + } + } /* if (aux_chn_ctrl->kick==KICK_NOTE) */ + } +} diff --git a/modules/chibi/cp_player_data_notes.cpp b/modules/chibi/cp_player_data_notes.cpp new file mode 100644 index 0000000000..621be019e1 --- /dev/null +++ b/modules/chibi/cp_player_data_notes.cpp @@ -0,0 +1,345 @@ +/*************************************************************************/ +/* cp_player_data_notes.cpp */ +/*************************************************************************/ +/* This file is part of: */ +/* GODOT ENGINE */ +/* http://www.godotengine.org */ +/*************************************************************************/ +/* Copyright (c) 2007-2016 Juan Linietsky, Ariel Manzur. */ +/* */ +/* Permission is hereby granted, free of charge, to any person obtaining */ +/* a copy of this software and associated documentation files (the */ +/* "Software"), to deal in the Software without restriction, including */ +/* without limitation the rights to use, copy, modify, merge, publish, */ +/* distribute, sublicense, and/or sell copies of the Software, and to */ +/* permit persons to whom the Software is furnished to do so, subject to */ +/* the following conditions: */ +/* */ +/* The above copyright notice and this permission notice shall be */ +/* included in all copies or substantial portions of the Software. */ +/* */ +/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */ +/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */ +/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/ +/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */ +/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */ +/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */ +/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ +/*************************************************************************/ + +#include "cp_player_data.h" +#include "cp_sample_manager.h" + +#define RANDOM_MAX 2147483647 + +static inline int32_t cp_random_generate(int32_t *seed) { + int32_t k; + int32_t s = (int32_t)(*seed); + if (s == 0) + s = 0x12345987; + k = s / 127773; + s = 16807 * (s - k * 127773) - 2836 * k; + if (s < 0) + s += 2147483647; + (*seed) = (int32_t)s; + return (int32_t)(s & RANDOM_MAX); +} + + +void CPPlayer::process_new_note(int p_track,uint8_t p_note) { // if there's really a new note.... + + if (control.channel[p_track].real_note!=255) { + control.channel[p_track].old_note=control.channel[p_track].real_note; + + } + + control.channel[p_track].real_note=p_note; + + control.channel[p_track].kick=KICK_NOTE; + + control.channel[p_track].sample_start_index=-1; + control.channel[p_track].sliding=0; + control.channel[p_track].row_has_note=true; + control.channel[p_track].last_event_usecs=song_usecs; + + if (control.channel[p_track].panbrello_type) control.channel[p_track].panbrello_position=0; +} + +bool CPPlayer::process_new_instrument(int p_track,uint8_t p_instrument) { + +// bool different_instrument=false; + ERR_FAIL_INDEX_V(p_instrument,CPSong::MAX_INSTRUMENTS,false); + + if ( song->has_instruments() ) { + + + control.channel[p_track].instrument_ptr=song->get_instrument(p_instrument); + } else { + + control.channel[p_track].instrument_ptr=NULL; + } + + control.channel[p_track].retrig_counter=0; + control.channel[p_track].tremor_position=0; + control.channel[p_track].sample_offset_fine=0; + int old_instr_index=control.channel[p_track].instrument_index; + control.channel[p_track].instrument_index=p_instrument; + + return (old_instr_index!=p_instrument); + + +} + + + // returns if it was able to process +bool CPPlayer::process_note_and_instrument(int p_track,int p_note,int p_instrument) { + + bool aux_result; + aux_result=false; + CPSample *aux_sample=0; // current sample + int dest_sample_index; + bool new_instrument=false; + + control.channel[p_track].row_has_note=false; // wise man says.. "we dont have a note... until we really know we have a note". + control.channel[p_track].new_instrument=false; + + if ( (p_note<0) && (p_instrument<0) ) return aux_result; // nothing to do here + if ( (p_note==255) && (p_instrument==255) ) return aux_result; + + if ( (p_note>=0) && (p_note<120) ) { + + process_new_note(p_track,p_note); + + } else if (p_note==CPNote::CUT) { + + control.channel[p_track].aux_volume=0; + control.channel[p_track].note_end_flags|=END_NOTE_OFF; + control.channel[p_track].note_end_flags|=END_NOTE_KILL; + return aux_result; + + } else if ((p_note==CPNote::OFF) && (song->has_instruments())) { + + if (control.channel[p_track].instrument_ptr!=NULL) { + + control.channel[p_track].note_end_flags|=END_NOTE_OFF; + + if (!control.channel[p_track].instrument_ptr->get_volume_envelope()->is_enabled() || control.channel[p_track].instrument_ptr->get_volume_envelope()->is_loop_enabled()) { + + control.channel[p_track].note_end_flags|=END_NOTE_FADE; + } + } + + return aux_result; + } else return aux_result; // invalid note! + + + if ( (p_instrument>=0) && (p_instrument<CPSong::MAX_INSTRUMENTS)) { + new_instrument=process_new_instrument(p_track,p_instrument); + + if ( song->has_instruments() ) { + // If we're in instrument mode... + if ( control.channel[p_track].instrument_ptr->get_sample_number(control.channel[p_track].real_note) >= CPSong::MAX_SAMPLES) { + + control.channel[p_track].kick=KICK_NOTHING; + return aux_result; + + } else { + dest_sample_index=control.channel[p_track].instrument_ptr->get_sample_number(control.channel[p_track].real_note); + control.channel[p_track].note=control.channel[p_track].instrument_ptr->get_note_number(control.channel[p_track].real_note); + } + + } else { + // If we're in sample mode... + dest_sample_index=control.channel[p_track].instrument_index; + control.channel[p_track].note=control.channel[p_track].real_note; + } + + control.channel[p_track].sample_index=dest_sample_index; + aux_sample=song->get_sample(dest_sample_index); + + if (!CPSampleManager::get_singleton()->check( aux_sample->get_sample_data() )) { + /* INVALID SAMPLE */ + control.channel[p_track].kick=KICK_NOTHING; + return aux_result; + + } + + aux_sample=song->get_sample(dest_sample_index); + } else { + + + if (!control.channel[p_track].sample_ptr) + return aux_result; + + if (song->has_instruments()) { + + if (!control.channel[p_track].instrument_ptr) + return aux_result; + + control.channel[p_track].note=control.channel[p_track].instrument_ptr->get_note_number(control.channel[p_track].real_note); + + } else { + + control.channel[p_track].note=control.channel[p_track].real_note; + + } + + aux_sample=control.channel[p_track].sample_ptr; + + } + + + + if (p_instrument>=CPSong::MAX_INSTRUMENTS && control.channel[p_track].sample_ptr!=aux_sample) { + + control.channel[p_track].new_instrument=(control.channel[p_track].period>0); + } + + control.channel[p_track].sample_ptr=aux_sample; + + /* channel or instrument determined panning ? */ + + control.channel[p_track].panning=control.channel[p_track].channel_panning; + + /* set filter,if any ? */ + + + if (aux_sample->is_pan_enabled()) { + + control.channel[p_track].panning=(int)aux_sample->get_pan()*255/64; + + } else if ( song->has_instruments() && (control.channel[p_track].instrument_ptr->is_pan_default_enabled()) ) { + + control.channel[p_track].panning=(int)control.channel[p_track].instrument_ptr->get_pan_default_amount()*255/64; + } + + + if (song->has_instruments()) { + + + /* Pitch-Pan Separation */ + if ((control.channel[p_track].instrument_ptr->get_pan_pitch_separation()!=0) && (control.channel[p_track].channel_panning!=PAN_SURROUND)){ + + control.channel[p_track].panning+=((control.channel[p_track].real_note-control.channel[p_track].instrument_ptr->get_pan_pitch_center())*control.channel[p_track].instrument_ptr->get_pan_pitch_separation())/8; + + if (control.channel[p_track].panning<PAN_LEFT) control.channel[p_track].panning=PAN_LEFT; + if (control.channel[p_track].panning>PAN_RIGHT) control.channel[p_track].panning=PAN_RIGHT; + } + + /* Random Volume Variation */ + if (control.channel[p_track].instrument_ptr->get_volume_random_variation()>0) { + + control.channel[p_track].random_volume_variation=100-(cp_random_generate(&control.random_seed) % control.channel[p_track].instrument_ptr->get_volume_random_variation()); + + } else { + + control.channel[p_track].random_volume_variation=100; + } + + + /* Random Pan Variation */ + if ((control.channel[p_track].instrument_ptr->get_pan_random_variation()>0) && (control.channel[p_track].panning!=PAN_SURROUND)){ + + int aux_pan_modifier; + + aux_pan_modifier=(cp_random_generate(&control.random_seed) % (control.channel[p_track].instrument_ptr->get_pan_random_variation() << 2)); + if ((cp_random_generate(&control.random_seed) % 2)==1) aux_pan_modifier=0-aux_pan_modifier; /* it's 5am, let me sleep :) */ + + control.channel[p_track].panning+=aux_pan_modifier; + + if (control.channel[p_track].panning<PAN_LEFT) control.channel[p_track].panning=PAN_LEFT; + if (control.channel[p_track].panning>PAN_RIGHT) control.channel[p_track].panning=PAN_RIGHT; + + + } + + /*filter*/ + + if (control.channel[p_track].instrument_ptr->filter_use_default_cutoff()) { + + control.channel[p_track].filter.it_cutoff=control.channel[p_track].instrument_ptr->get_filter_default_cutoff()*2; + + } + + if (control.channel[p_track].instrument_ptr->filter_use_default_resonance()) { + + control.channel[p_track].filter.it_reso=control.channel[p_track].instrument_ptr->get_filter_default_resonance()*2; + + } + + /*envelopes*/ + + + control.channel[p_track].volume_envelope_on=control.channel[p_track].instrument_ptr->get_volume_envelope()->is_enabled(); + control.channel[p_track].panning_envelope_on=control.channel[p_track].instrument_ptr->get_pan_envelope()->is_enabled(); + control.channel[p_track].pitch_envelope_on=control.channel[p_track].instrument_ptr->get_pitch_filter_envelope()->is_enabled(); + control.channel[p_track].NNA_type=control.channel[p_track].instrument_ptr->get_NNA_type(); + control.channel[p_track].duplicate_check_type=control.channel[p_track].instrument_ptr->get_DC_type(); + control.channel[p_track].duplicate_check_action=control.channel[p_track].instrument_ptr->get_DC_action(); + + + } else { + + control.channel[p_track].NNA_type=CPInstrument::NNA_NOTE_CUT; + control.channel[p_track].duplicate_check_type=CPInstrument::DCT_DISABLED; + control.channel[p_track].duplicate_check_action=CPInstrument::DCA_NOTE_CUT; + } + + + if (p_instrument<CPSong::MAX_INSTRUMENTS) { // instrument change + + control.channel[p_track].volume=control.channel[p_track].aux_volume=aux_sample->get_default_volume(); + + } + + + control.channel[p_track].slide_to_period=control.channel[p_track].aux_period=get_period((uint16_t)(control.channel[p_track].note)<<1,CPSampleManager::get_singleton()->get_c5_freq( (aux_sample->get_sample_data()))); + + control.channel[p_track].note_end_flags=END_NOTE_NOTHING; /* clears flags */ + + return true; +} + +void CPPlayer::process_volume_column(int p_track,uint8_t p_volume) { + + control.channel[p_track].current_volume_command=CPNote::EMPTY; + control.channel[p_track].current_volume_parameter=CPNote::EMPTY; + + if (p_volume<65) { // VOLUME + + control.channel[p_track].aux_volume=p_volume; + } else if (p_volume<125) { // Volume Command + + + control.channel[p_track].current_volume_command=(p_volume-65) / 10; + control.channel[p_track].current_volume_parameter=(p_volume-65) % 10; + } else if (p_volume<193) { // PAN + + control.channel[p_track].channel_panning=(p_volume-128)*PAN_RIGHT/64; + control.channel[p_track].panning=control.channel[p_track].channel_panning; + + } else if (p_volume<213) { //More volume Commands + + control.channel[p_track].current_volume_command=((p_volume-193) / 10)+6; + control.channel[p_track].current_volume_parameter=(p_volume-193) % 10; + } +} + + +void CPPlayer::process_note(int p_track,CPNote p_note) { + + if ( p_note.note!=CPNote::SCRIPT ) { + + process_note_and_instrument(p_track,p_note.note,p_note.instrument); + process_volume_column(p_track,p_note.volume); + control.channel[p_track].current_command=p_note.command; + control.channel[p_track].current_parameter=p_note.parameter; + + } else { + + CPNote n = song->get_pattern( control.position.current_pattern )->get_transformed_script_note( p_track, control.position.current_row ); + process_note( p_track, n ); + + song->get_pattern( control.position.current_pattern )->scripted_clone( p_track, control.position.current_row ); + } +} diff --git a/modules/chibi/cp_player_data_utils.cpp b/modules/chibi/cp_player_data_utils.cpp new file mode 100644 index 0000000000..170a849863 --- /dev/null +++ b/modules/chibi/cp_player_data_utils.cpp @@ -0,0 +1,138 @@ +/*************************************************************************/ +/* cp_player_data_utils.cpp */ +/*************************************************************************/ +/* This file is part of: */ +/* GODOT ENGINE */ +/* http://www.godotengine.org */ +/*************************************************************************/ +/* Copyright (c) 2007-2016 Juan Linietsky, Ariel Manzur. */ +/* */ +/* Permission is hereby granted, free of charge, to any person obtaining */ +/* a copy of this software and associated documentation files (the */ +/* "Software"), to deal in the Software without restriction, including */ +/* without limitation the rights to use, copy, modify, merge, publish, */ +/* distribute, sublicense, and/or sell copies of the Software, and to */ +/* permit persons to whom the Software is furnished to do so, subject to */ +/* the following conditions: */ +/* */ +/* The above copyright notice and this permission notice shall be */ +/* included in all copies or substantial portions of the Software. */ +/* */ +/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */ +/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */ +/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/ +/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */ +/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */ +/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */ +/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ +/*************************************************************************/ + +#include "cp_player_data.h" +uint8_t CPPlayer::vibrato_table[32]={ + 0, 24, 49, 74, 97,120,141,161,180,197,212,224,235,244,250,253, + 255,253,250,244,235,224,212,197,180,161,141,120, 97, 74, 49, 24 +}; + +uint8_t CPPlayer::auto_vibrato_table[128]={ + 0, 1, 3, 4, 6, 7, 9,10,12,14,15,17,18,20,21,23, + 24,25,27,28,30,31,32,34,35,36,38,39,40,41,42,44, + 45,46,47,48,49,50,51,52,53,54,54,55,56,57,57,58, + 59,59,60,60,61,61,62,62,62,63,63,63,63,63,63,63, + 64,63,63,63,63,63,63,63,62,62,62,61,61,60,60,59, + 59,58,57,57,56,55,54,54,53,52,51,50,49,48,47,46, + 45,44,42,41,40,39,38,36,35,34,32,31,30,28,27,25, + 24,23,21,20,18,17,15,14,12,10, 9, 7, 6, 4, 3, 1 +}; + + +int8_t CPPlayer::panbrello_table[256]={ + 0, 2, 3, 5, 6, 8, 9, 11, 12, 14, 16, 17, 19, 20, 22, 23, + 24, 26, 27, 29, 30, 32, 33, 34, 36, 37, 38, 39, 41, 42, 43, 44, + 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 56, 57, 58, 59, + 59, 60, 60, 61, 61, 62, 62, 62, 63, 63, 63, 64, 64, 64, 64, 64, + 64, 64, 64, 64, 64, 64, 63, 63, 63, 62, 62, 62, 61, 61, 60, 60, + 59, 59, 58, 57, 56, 56, 55, 54, 53, 52, 51, 50, 49, 48, 47, 46, + 45, 44, 43, 42, 41, 39, 38, 37, 36, 34, 33, 32, 30, 29, 27, 26, + 24, 23, 22, 20, 19, 17, 16, 14, 12, 11, 9, 8, 6, 5, 3, 2, + 0,- 2,- 3,- 5,- 6,- 8,- 9,-11,-12,-14,-16,-17,-19,-20,-22,-23, + -24,-26,-27,-29,-30,-32,-33,-34,-36,-37,-38,-39,-41,-42,-43,-44, + -45,-46,-47,-48,-49,-50,-51,-52,-53,-54,-55,-56,-56,-57,-58,-59, + -59,-60,-60,-61,-61,-62,-62,-62,-63,-63,-63,-64,-64,-64,-64,-64, + -64,-64,-64,-64,-64,-64,-63,-63,-63,-62,-62,-62,-61,-61,-60,-60, + -59,-59,-58,-57,-56,-56,-55,-54,-53,-52,-51,-50,-49,-48,-47,-46, + -45,-44,-43,-42,-41,-39,-38,-37,-36,-34,-33,-32,-30,-29,-27,-26, + -24,-23,-22,-20,-19,-17,-16,-14,-12,-11,- 9,- 8,- 6,- 5,- 3,- 2 +}; + + + + + + +int32_t CPPlayer::get_period(uint16_t p_note,int32_t p_c5speed) { + + if (song->has_linear_slides()) { + + return CPTables::get_linear_period(p_note,0); + } else { + + + return CPTables::get_log_period(p_note>>1,p_c5speed >>1); + } +} + + +int32_t CPPlayer::get_frequency(int32_t period) { + + if (song->has_linear_slides()) { + + return CPTables::get_linear_frequency(period); + } else { + + return CPTables::get_old_frequency(period); + } +} + +int CPPlayer::find_empty_voice() { + + int i; + int min_priority,min_priority_chan=0,priority; + + for (i=0;i<control.max_voices;i++) { + + if ( ((voice[i].kick==KICK_NOTHING)||(voice[i].kick==KICK_ENVELOPE))&&!mixer->is_voice_active(i) ) { + + return i; + + } + } + + // todo more + + for (i=0;i<control.max_voices;i++) { + /* allow us to take over a nonexisting sample */ +// if ((voice[i].s==NULL) +// return k; + + if ((voice[i].kick==KICK_NOTHING)||(voice[i].kick==KICK_ENVELOPE)) { + + priority=voice[i].total_volume<<((CPSampleManager::get_singleton()->get_loop_type( voice[i].sample_ptr->get_sample_data())!=CP_LOOP_NONE)?1:0); + + if ((voice[i].has_master_channel)&&(&voice[i]==voice[i].master_channel->slave_voice)) { + + priority<<=2; + + } + + if ((i==0) || (priority<min_priority)) { + min_priority=priority; + min_priority_chan=i; + } + } + } + + if (min_priority>8000*7) return -1; /* what the fuck is this? */ + + return min_priority_chan; +} + diff --git a/modules/chibi/cp_sample.cpp b/modules/chibi/cp_sample.cpp new file mode 100644 index 0000000000..55c2c910a5 --- /dev/null +++ b/modules/chibi/cp_sample.cpp @@ -0,0 +1,203 @@ +/*************************************************************************/ +/* cp_sample.cpp */ +/*************************************************************************/ +/* This file is part of: */ +/* GODOT ENGINE */ +/* http://www.godotengine.org */ +/*************************************************************************/ +/* Copyright (c) 2007-2016 Juan Linietsky, Ariel Manzur. */ +/* */ +/* Permission is hereby granted, free of charge, to any person obtaining */ +/* a copy of this software and associated documentation files (the */ +/* "Software"), to deal in the Software without restriction, including */ +/* without limitation the rights to use, copy, modify, merge, publish, */ +/* distribute, sublicense, and/or sell copies of the Software, and to */ +/* permit persons to whom the Software is furnished to do so, subject to */ +/* the following conditions: */ +/* */ +/* The above copyright notice and this permission notice shall be */ +/* included in all copies or substantial portions of the Software. */ +/* */ +/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */ +/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */ +/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/ +/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */ +/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */ +/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */ +/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ +/*************************************************************************/ +#include "cp_sample.h" + +const char * CPSample::get_name() const { + + return name; +} +void CPSample::set_name(const char *p_name) { + + if (p_name==NULL) { + name[0]=0; + return; + } + + + bool done=false; + for (int i=0;i<NAME_MAX_LEN;i++) { + + + name[i]=done?0:p_name[i]; + if (!done && p_name[i]==0) + done=true; + } + + name[NAME_MAX_LEN-1]=0; /* just in case */ + +} + +void CPSample::set_default_volume(uint8_t p_vol) { + + default_volume=p_vol; +} +uint8_t CPSample::get_default_volume() const{ + + return default_volume; +} + +void CPSample::set_global_volume(uint8_t p_vol) { + + global_volume=p_vol; +} +uint8_t CPSample::get_global_volume() const{ + + return global_volume; +} + +void CPSample::set_pan_enabled(bool p_vol) { + + pan_enabled=p_vol; +} +bool CPSample::is_pan_enabled() const{ + + return pan_enabled; +} + +void CPSample::set_pan(uint8_t p_pan) { + + pan=p_pan; + +} +uint8_t CPSample::get_pan() const{ + + return pan; +} + + +void CPSample::set_vibrato_type(VibratoType p_vibrato_type) { + + vibrato_type=p_vibrato_type; +} +CPSample::VibratoType CPSample::get_vibrato_type() const{ + + return vibrato_type; +} + +void CPSample::set_vibrato_speed(uint8_t p_vibrato_speed) { + + vibrato_speed=p_vibrato_speed; +} +uint8_t CPSample::get_vibrato_speed() const { + + return vibrato_speed; +} + +void CPSample::set_vibrato_depth(uint8_t p_vibrato_depth) { + + vibrato_depth=p_vibrato_depth; +} +uint8_t CPSample::get_vibrato_depth() const{ + + return vibrato_depth; +} + +void CPSample::set_vibrato_rate(uint8_t p_vibrato_rate) { + + vibrato_rate=p_vibrato_rate; +} +uint8_t CPSample::get_vibrato_rate() const{ + + return vibrato_rate; +} + +void CPSample::set_sample_data(CPSample_ID p_ID) { + + id=p_ID; +} +CPSample_ID CPSample::get_sample_data() const{ + + return id; +} + +void CPSample::operator=(const CPSample &p_sample) { + + copy_from(p_sample); +} +void CPSample::copy_from(const CPSample &p_sample) { + + reset(); + set_name(p_sample.get_name()); + + default_volume=p_sample.default_volume; + global_volume=p_sample.global_volume; + + pan_enabled=p_sample.pan_enabled; + pan=p_sample.pan; + + vibrato_type=p_sample.vibrato_type; + vibrato_speed=p_sample.vibrato_speed; + vibrato_depth=p_sample.vibrato_depth; + vibrato_rate=p_sample.vibrato_rate; + + if (CPSampleManager::get_singleton() && !p_sample.id.is_null()) + CPSampleManager::get_singleton()->copy_to( p_sample.id, id ); +} + + + + + +void CPSample::reset() { + + + name[0]=0; + + default_volume=64; + global_volume=64; + + pan_enabled=false; + pan=32; + + vibrato_type=VIBRATO_SINE; + vibrato_speed=0; + vibrato_depth=0; + vibrato_rate=0; + + if (!id.is_null() && CPSampleManager::get_singleton()) + CPSampleManager::get_singleton()->destroy( id ); + + id=CPSample_ID(); + +} + +CPSample::CPSample(const CPSample&p_from) { + + reset(); + copy_from(p_from); +} +CPSample::CPSample() { + + reset(); +} + +CPSample::~CPSample() { + + reset(); +} diff --git a/modules/chibi/cp_sample.h b/modules/chibi/cp_sample.h new file mode 100644 index 0000000000..4b3d218106 --- /dev/null +++ b/modules/chibi/cp_sample.h @@ -0,0 +1,112 @@ +/*************************************************************************/ +/* cp_sample.h */ +/*************************************************************************/ +/* This file is part of: */ +/* GODOT ENGINE */ +/* http://www.godotengine.org */ +/*************************************************************************/ +/* Copyright (c) 2007-2016 Juan Linietsky, Ariel Manzur. */ +/* */ +/* Permission is hereby granted, free of charge, to any person obtaining */ +/* a copy of this software and associated documentation files (the */ +/* "Software"), to deal in the Software without restriction, including */ +/* without limitation the rights to use, copy, modify, merge, publish, */ +/* distribute, sublicense, and/or sell copies of the Software, and to */ +/* permit persons to whom the Software is furnished to do so, subject to */ +/* the following conditions: */ +/* */ +/* The above copyright notice and this permission notice shall be */ +/* included in all copies or substantial portions of the Software. */ +/* */ +/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */ +/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */ +/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/ +/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */ +/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */ +/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */ +/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ +/*************************************************************************/ +#ifndef CPSAMPLE_H +#define CPSAMPLE_H + + +#include "cp_config.h" +#include "cp_sample_manager.h" +class CPSample { + +public: + enum VibratoType { + VIBRATO_SINE, + VIBRATO_SAW, + VIBRATO_SQUARE, + VIBRATO_RANDOM + + }; + +private: + + enum { NAME_MAX_LEN=26 }; + + char name[NAME_MAX_LEN]; + + uint8_t default_volume; /* 0.. 64 */ + uint8_t global_volume; /* 0.. 64 */ + + bool pan_enabled; + uint8_t pan; /* 0.. 64 */ + + VibratoType vibrato_type; + uint8_t vibrato_speed; /* 0.. 64 */ + uint8_t vibrato_depth; /* 0.. 64 */ + uint8_t vibrato_rate; /* 0.. 64 */ + + CPSample_ID id; + + void copy_from(const CPSample &p_sample); +public: + + + void operator=(const CPSample &p_sample); + + const char * get_name() const; + void set_name(const char *p_name); + + void set_default_volume(uint8_t p_vol); + uint8_t get_default_volume() const; + + void set_global_volume(uint8_t p_vol); + uint8_t get_global_volume() const; + + void set_pan_enabled(bool p_vol); + bool is_pan_enabled() const; + + void set_pan(uint8_t p_pan); + uint8_t get_pan() const; + + void set_vibrato_type(VibratoType p_vibrato_type); + VibratoType get_vibrato_type() const; + + void set_vibrato_speed(uint8_t p_vibrato_speed) ; + uint8_t get_vibrato_speed() const; + + void set_vibrato_depth(uint8_t p_vibrato_depth); + uint8_t get_vibrato_depth() const; + + void set_vibrato_rate(uint8_t p_vibrato_rate); + uint8_t get_vibrato_rate() const; + + void set_sample_data(CPSample_ID); + CPSample_ID get_sample_data() const; + + void reset(); + + CPSample(const CPSample&p_from); + CPSample(); + ~CPSample(); + +}; + + + + +#endif diff --git a/modules/chibi/cp_sample_defs.h b/modules/chibi/cp_sample_defs.h new file mode 100644 index 0000000000..169963c98e --- /dev/null +++ b/modules/chibi/cp_sample_defs.h @@ -0,0 +1,97 @@ +/*************************************************************************/ +/* cp_sample_defs.h */ +/*************************************************************************/ +/* This file is part of: */ +/* GODOT ENGINE */ +/* http://www.godotengine.org */ +/*************************************************************************/ +/* Copyright (c) 2007-2016 Juan Linietsky, Ariel Manzur. */ +/* */ +/* Permission is hereby granted, free of charge, to any person obtaining */ +/* a copy of this software and associated documentation files (the */ +/* "Software"), to deal in the Software without restriction, including */ +/* without limitation the rights to use, copy, modify, merge, publish, */ +/* distribute, sublicense, and/or sell copies of the Software, and to */ +/* permit persons to whom the Software is furnished to do so, subject to */ +/* the following conditions: */ +/* */ +/* The above copyright notice and this permission notice shall be */ +/* included in all copies or substantial portions of the Software. */ +/* */ +/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */ +/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */ +/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/ +/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */ +/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */ +/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */ +/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ +/*************************************************************************/ +#ifndef CP_SAMPLE_DEFS_H +#define CP_SAMPLE_DEFS_H + +#include "cp_config.h" + +enum CPSample_Loop_Type { + + CP_LOOP_NONE, + CP_LOOP_FORWARD, + CP_LOOP_BIDI +}; + +//#define INVALID_SAMPLE_ID -1 + +#define CP_MIXING_FRAC_BITS_MACRO 13 +#define CP_MIXING_FRAC_BITS_TEXT "13" +// 1<<9 - 1 +#define CP_MIXING_FRAC_BITS_MASK_TEXT "8191" + +enum CPMixConstants { + CP_MIXING_FRAC_BITS=CP_MIXING_FRAC_BITS_MACRO, + CP_MIXING_FRAC_LENGTH=(1<<CP_MIXING_FRAC_BITS), + CP_MIXING_FRAC_MASK=CP_MIXING_FRAC_LENGTH-1, + CP_MIXING_VOL_FRAC_BITS=8, + CP_MIXING_FREQ_FRAC_BITS=8 +}; + +enum CPFilterConstants { + CP_FILTER_SHIFT=16, + CP_FILTER_LENGTH=(1<<CP_FILTER_SHIFT) +}; + + +enum CPInterpolationType { + CP_INTERPOLATION_RAW, + CP_INTERPOLATION_LINEAR, + CP_INTERPOLATION_CUBIC +}; + +enum CPPanConstants { + + CP_PAN_BITS=8, // 0 .. 256 + CP_PAN_LEFT=0, + CP_PAN_RIGHT=((1<<CP_PAN_BITS)-1), // 255 + CP_PAN_CENTER=CP_PAN_RIGHT/2, // 128 + CP_PAN_SURROUND=512 +}; + +enum CPMixerVolConstants { + CP_VOL_MAX=512, + CP_VOL_RAMP_BITS=9, + CP_VOL_SHIFT=2 + + +}; + +enum CPStereoCannels { + CP_CHAN_LEFT, + CP_CHAN_RIGHT +}; + +#define CP_FIRST_SAMPLE_DECLICK_THRESHOLD 1000 +#define CP_FIRST_SAMPLE_RAMP_LEN 32 + +typedef signed char CPFrame8; +typedef signed short CPFrame16; + + +#endif diff --git a/modules/chibi/cp_sample_manager.cpp b/modules/chibi/cp_sample_manager.cpp new file mode 100644 index 0000000000..5c2988e3f9 --- /dev/null +++ b/modules/chibi/cp_sample_manager.cpp @@ -0,0 +1,78 @@ +/*************************************************************************/ +/* cp_sample_manager.cpp */ +/*************************************************************************/ +/* This file is part of: */ +/* GODOT ENGINE */ +/* http://www.godotengine.org */ +/*************************************************************************/ +/* Copyright (c) 2007-2016 Juan Linietsky, Ariel Manzur. */ +/* */ +/* Permission is hereby granted, free of charge, to any person obtaining */ +/* a copy of this software and associated documentation files (the */ +/* "Software"), to deal in the Software without restriction, including */ +/* without limitation the rights to use, copy, modify, merge, publish, */ +/* distribute, sublicense, and/or sell copies of the Software, and to */ +/* permit persons to whom the Software is furnished to do so, subject to */ +/* the following conditions: */ +/* */ +/* The above copyright notice and this permission notice shall be */ +/* included in all copies or substantial portions of the Software. */ +/* */ +/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */ +/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */ +/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/ +/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */ +/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */ +/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */ +/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ +/*************************************************************************/ +#include "cp_sample_manager.h" + + +CPSampleManager * CPSampleManager::singleton=NULL; + + +void CPSampleManager::copy_to(CPSample_ID p_from,CPSample_ID &p_to) { + + ERR_FAIL_COND(!check( p_from )); + + + if (p_to.is_null()) { + + p_to=create( is_16bits( p_from), is_stereo( p_from), get_size(p_from)); + } else { + + recreate( p_to, is_16bits( p_from), is_stereo( p_from), get_size(p_from)); + + } + + int len=get_size( p_from ); + int ch=is_stereo( p_from ) ? 2 : 1; + + for (int c=0;c<ch;c++) { + + for (int i=0;i<len;i++) { + + int16_t s=get_data( p_from, i, c ); + set_data( p_to, i, s, c ); + } + } + + set_loop_type( p_to, get_loop_type( p_from ) ); + set_loop_begin( p_to, get_loop_begin( p_from ) ); + set_loop_end( p_to, get_loop_end( p_from ) ); + set_c5_freq( p_to, get_c5_freq( p_from ) ); + + + +} + +CPSampleManager::CPSampleManager() { + + singleton=this; +} + +CPSampleManager *CPSampleManager::get_singleton() { + + return singleton; +} diff --git a/modules/chibi/cp_sample_manager.h b/modules/chibi/cp_sample_manager.h new file mode 100644 index 0000000000..74bcafc0cf --- /dev/null +++ b/modules/chibi/cp_sample_manager.h @@ -0,0 +1,99 @@ +/*************************************************************************/ +/* cp_sample_manager.h */ +/*************************************************************************/ +/* This file is part of: */ +/* GODOT ENGINE */ +/* http://www.godotengine.org */ +/*************************************************************************/ +/* Copyright (c) 2007-2016 Juan Linietsky, Ariel Manzur. */ +/* */ +/* Permission is hereby granted, free of charge, to any person obtaining */ +/* a copy of this software and associated documentation files (the */ +/* "Software"), to deal in the Software without restriction, including */ +/* without limitation the rights to use, copy, modify, merge, publish, */ +/* distribute, sublicense, and/or sell copies of the Software, and to */ +/* permit persons to whom the Software is furnished to do so, subject to */ +/* the following conditions: */ +/* */ +/* The above copyright notice and this permission notice shall be */ +/* included in all copies or substantial portions of the Software. */ +/* */ +/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */ +/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */ +/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/ +/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */ +/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */ +/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */ +/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ +/*************************************************************************/ +#ifndef CP_SAMPLE_MANAGER_H +#define CP_SAMPLE_MANAGER_H + +#include "cp_config.h" +#include "cp_sample_defs.h" + + + +/** +@author Juan Linietsky +*/ + + +/* abstract base CPSample_ID class */ + +struct CPSample_ID { + + void *_private; + + bool operator==(const CPSample_ID&p_other) const { return _private==p_other._private; } + bool operator!=(const CPSample_ID&p_other) const { return _private!=p_other._private; } + bool is_null() const { return _private==0; } + CPSample_ID(void *p_private=0) { _private=p_private; }; +}; + + +class CPSampleManager { + + static CPSampleManager * singleton; + +public: + + /* get the singleton instance */ + static CPSampleManager *get_singleton(); + + virtual void copy_to(CPSample_ID p_from,CPSample_ID &p_to); ///< if p_to is null, it gets created + + virtual CPSample_ID create(bool p_16bits,bool p_stereo,int32_t p_len)=0; + virtual void recreate(CPSample_ID p_id,bool p_16bits,bool p_stereo,int32_t p_len)=0; + virtual void destroy(CPSample_ID p_id)=0; + virtual bool check(CPSample_ID p_id)=0; // return false if invalid + + virtual void set_c5_freq(CPSample_ID p_id,int32_t p_freq)=0; + virtual void set_loop_begin(CPSample_ID p_id,int32_t p_begin)=0; + virtual void set_loop_end(CPSample_ID p_id,int32_t p_end)=0; + virtual void set_loop_type(CPSample_ID p_id,CPSample_Loop_Type p_type)=0; + virtual void set_chunk(CPSample_ID p_id,int32_t p_index,void *p_data,int p_data_len)=0; + + + virtual int32_t get_loop_begin(CPSample_ID p_id)=0; + virtual int32_t get_loop_end(CPSample_ID p_id)=0; + virtual CPSample_Loop_Type get_loop_type(CPSample_ID p_id)=0; + virtual int32_t get_c5_freq(CPSample_ID p_id)=0; + virtual int32_t get_size(CPSample_ID p_id)=0; + virtual bool is_16bits(CPSample_ID p_id)=0; + virtual bool is_stereo(CPSample_ID p_id)=0; + virtual bool lock_data(CPSample_ID p_id)=0; + virtual void *get_data(CPSample_ID p_id)=0; /* WARNING: Not all sample managers +may be able to implement this, it depends on the mixer in use! */ + virtual int16_t get_data(CPSample_ID p_id, int p_sample, int p_channel=0)=0; /// Does not need locking + virtual void set_data(CPSample_ID p_id, int p_sample, int16_t p_data,int p_channel=0)=0; /// Does not need locking + virtual void unlock_data(CPSample_ID p_id)=0; + + virtual void get_chunk(CPSample_ID p_id,int32_t p_index,void *p_data,int p_data_len)=0; + + CPSampleManager(); + virtual ~CPSampleManager(){} + +}; + +#endif diff --git a/modules/chibi/cp_song.cpp b/modules/chibi/cp_song.cpp new file mode 100644 index 0000000000..4aa1a4228d --- /dev/null +++ b/modules/chibi/cp_song.cpp @@ -0,0 +1,957 @@ +/*************************************************************************/ +/* cp_song.cpp */ +/*************************************************************************/ +/* This file is part of: */ +/* GODOT ENGINE */ +/* http://www.godotengine.org */ +/*************************************************************************/ +/* Copyright (c) 2007-2016 Juan Linietsky, Ariel Manzur. */ +/* */ +/* Permission is hereby granted, free of charge, to any person obtaining */ +/* a copy of this software and associated documentation files (the */ +/* "Software"), to deal in the Software without restriction, including */ +/* without limitation the rights to use, copy, modify, merge, publish, */ +/* distribute, sublicense, and/or sell copies of the Software, and to */ +/* permit persons to whom the Software is furnished to do so, subject to */ +/* the following conditions: */ +/* */ +/* The above copyright notice and this permission notice shall be */ +/* included in all copies or substantial portions of the Software. */ +/* */ +/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */ +/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */ +/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/ +/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */ +/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */ +/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */ +/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ +/*************************************************************************/ +#include "cp_song.h" + +void CPSong::set_name(const char *p_name) { + + if (p_name==NULL) { + variables.name[0]=0; + return; + } + + + bool done=false; + for (int i=0;i<MAX_SONG_NAME;i++) { + + + variables.name[i]=done?0:p_name[i]; + if (!done && p_name[i]==0) + done=true; + } + + variables.name[MAX_SONG_NAME-1]=0; /* just in case */ +} + +const char * CPSong::get_name() { + + return variables.name; + +} + +void CPSong::set_message(const char *p_message) { + + if (p_message==NULL) { + variables.message[0]=0; + return; + } + + bool done=false; + for (int i=0;i<MAX_MESSAGE_LEN;i++) { + + + variables.message[i]=done?0:p_message[i]; + if (!done && p_message[i]==0) + done=true; + } + + variables.message[MAX_MESSAGE_LEN-1]=0; /* just in case */ +} + +const char * CPSong::get_message() { + + return variables.message; + +} + +void CPSong::set_row_highlight_minor(int p_hl_minor) { + + variables.row_highlight_minor=p_hl_minor; +} +int CPSong::get_row_highlight_minor() { + + return variables.row_highlight_minor; +} + +void CPSong::set_row_highlight_major(int p_hl_major) { + + variables.row_highlight_major=p_hl_major; + + +} /* 0 .. 256 */ +int CPSong::get_row_highlight_major() { + + return variables.row_highlight_major; + + +} /* 0 .. 256 */ + +void CPSong::set_mixing_volume(int p_mix_volume) { + + + variables.mixing_volume=p_mix_volume; +} /* 0 .. 128 */ +int CPSong::get_mixing_volume() { + + return variables.mixing_volume; + +} /* 0 .. 128 */ + +void CPSong::set_global_volume(int p_global_volume) { + + + initial_variables.global_volume=p_global_volume; + +} /* 0 .. 128 */ +int CPSong::get_global_volume() { + + return initial_variables.global_volume; + +} /* 0 .. 128 */ + +void CPSong::set_stereo_separation(int p_separation) { + + variables.stereo_separation=p_separation; + +} /* 0 .. 128 */ +int CPSong::get_stereo_separation() { + + return variables.stereo_separation; +} /* 0 .. 128 */ + +void CPSong::set_stereo(bool p_stereo) { + + variables.use_stereo=p_stereo; + +} +bool CPSong::is_stereo() { + + return variables.use_stereo; +} + +void CPSong::set_instruments(bool p_instruments) { + + variables.use_instruments=p_instruments; + + +} +bool CPSong::has_instruments() { + + + return variables.use_instruments; + +} + +void CPSong::set_linear_slides(bool p_linear_slides) { + + variables.use_linear_slides=p_linear_slides; + + +} +bool CPSong::has_linear_slides() { + + return variables.use_linear_slides; + + +} + +void CPSong::set_old_effects(bool p_old_effects) { + + variables.old_effects=p_old_effects; + + +} +bool CPSong::has_old_effects() { + + return variables.old_effects; +} + +void CPSong::set_compatible_gxx(bool p_compatible_gxx) { + + + variables.compatible_gxx=p_compatible_gxx; +} +bool CPSong::has_compatible_gxx() { + + return variables.compatible_gxx; + +} + +void CPSong::set_speed(int p_speed) { + + CP_ERR_COND(p_speed<MIN_SPEED); + CP_ERR_COND(p_speed>MAX_SPEED); + + initial_variables.speed=p_speed; + +} /* 1 .. 255 */ +int CPSong::get_speed() { + + return initial_variables.speed; + +} /* 1 .. 255 */ + +void CPSong::set_tempo(int p_tempo) { + + CP_ERR_COND( p_tempo<MIN_TEMPO ); + CP_ERR_COND( p_tempo>MAX_TEMPO ); + + initial_variables.tempo=p_tempo; + +} /* MIN_TEMPO .. MAX_TEMPO */ +int CPSong::get_tempo() { + + return initial_variables.tempo; + + +} /* MIN_TEMPO .. MAX_TEMPO */ + +void CPSong::set_channel_pan(int p_channel,int p_pan) { + + CP_FAIL_INDEX(p_channel,CPPattern::WIDTH); + CP_FAIL_INDEX(p_pan,CHANNEL_MAX_PAN+1); + + initial_variables.channel[p_channel].pan=p_pan; + +} /* 0 .. CHANNEL_MAX_PAN */ +int CPSong::get_channel_pan(int p_channel) { + + CP_FAIL_INDEX_V(p_channel,CPPattern::WIDTH,-1); + + return initial_variables.channel[p_channel].pan; +} + +void CPSong::set_channel_volume(int p_channel,int p_volume) { + + CP_FAIL_INDEX(p_channel,CPPattern::WIDTH); + CP_FAIL_INDEX(p_volume,CHANNEL_MAX_VOLUME+1); + + + initial_variables.channel[p_channel].volume=p_volume; + + +} /* 0 .. CHANNEL_MAX_VOLUME */ + + +int CPSong::get_channel_volume(int p_channel) { + + CP_FAIL_INDEX_V(p_channel,CPPattern::WIDTH,-1); + + return initial_variables.channel[p_channel].volume; + +} + +void CPSong::set_channel_chorus(int p_channel,int p_chorus) { + + CP_FAIL_INDEX(p_channel,CPPattern::WIDTH); + CP_FAIL_INDEX(p_chorus,CHANNEL_MAX_CHORUS+1); + + + initial_variables.channel[p_channel].chorus=p_chorus; + + +} /* 0 .. CHANNEL_MAX_CHORUS */ + + +int CPSong::get_channel_chorus(int p_channel) { + + CP_FAIL_INDEX_V(p_channel,CPPattern::WIDTH,-1); + + return initial_variables.channel[p_channel].chorus; + +} + +void CPSong::set_channel_reverb(int p_channel,int p_reverb) { + + CP_FAIL_INDEX(p_channel,CPPattern::WIDTH); + CP_FAIL_INDEX(p_reverb,CHANNEL_MAX_REVERB+1); + + + initial_variables.channel[p_channel].reverb=p_reverb; + + +} /* 0 .. CHANNEL_MAX_CHORUS */ + + +int CPSong::get_channel_reverb(int p_channel) { + + CP_FAIL_INDEX_V(p_channel,CPPattern::WIDTH,-1); + + return initial_variables.channel[p_channel].reverb; + +} + +void CPSong::set_channel_surround(int p_channel,bool p_surround) { + + CP_FAIL_INDEX(p_channel,CPPattern::WIDTH); + initial_variables.channel[p_channel].surround=p_surround; + +} +bool CPSong::is_channel_surround(int p_channel) { + + CP_FAIL_INDEX_V(p_channel,CPPattern::WIDTH,false); + + return initial_variables.channel[p_channel].surround; + + +} + +void CPSong::set_channel_mute(int p_channel,bool p_mute) { + + CP_FAIL_INDEX(p_channel,CPPattern::WIDTH); + + initial_variables.channel[p_channel].mute=p_mute; + +} +bool CPSong::is_channel_mute(int p_channel) { + + CP_FAIL_INDEX_V(p_channel,CPPattern::WIDTH,false); + + return initial_variables.channel[p_channel].mute; + +} + +/* arrays of stuff */ + +CPPattern* CPSong::get_pattern(int p_pattern) { + + CP_FAIL_INDEX_V(p_pattern,MAX_PATTERNS, NULL); + + return &pattern[p_pattern]; + +} +CPSample* CPSong::get_sample(int p_sample) { + + CP_FAIL_INDEX_V(p_sample,MAX_SAMPLES,NULL); + + return &sample[p_sample]; + + +} +CPInstrument* CPSong::get_instrument(int p_instrument) { + + + CP_FAIL_INDEX_V(p_instrument,MAX_INSTRUMENTS,NULL); + + return &instrument[p_instrument]; + +} + +int CPSong::get_order(int p_order) { + + CP_FAIL_INDEX_V(p_order,MAX_ORDERS,CP_ORDER_NONE); + + + return order[p_order]; + +} +void CPSong::set_order(int p_order,int p_pattern) { + + CP_FAIL_INDEX(p_order,MAX_ORDERS); + + order[p_order]=p_pattern; + +} + + +void CPSong::clear_instrument_with_samples(int p_instrument) { + + CPInstrument *ins = get_instrument( p_instrument ); + if (!ins) + return; + + for (int i=0;i<CPNote::NOTES;i++) { + + CPSample *s=get_sample( ins->get_sample_number( i ) ); + + if (!s) + continue; + + if (s->get_sample_data().is_null()) + continue; + + s->reset(); + } + ins->reset(); +} + +void CPSong::make_instrument_from_sample(int p_sample) { + + if (!has_instruments()) + return; + CP_ERR_COND(!get_sample( p_sample )); + + for (int i=0;i<MAX_INSTRUMENTS;i++) { + + + CPInstrument *ins=get_instrument(i); + + bool empty_slot=true; + for (int n=0;n<CPNote::NOTES;n++) { + + if (ins->get_sample_number(n)<MAX_SAMPLES) { + + empty_slot=false; + break; + } + } + + if (!empty_slot) + continue; + + for (int n=0;n<CPNote::NOTES;n++) { + + ins->set_sample_number(n,p_sample); + ins->set_note_number(n,n); + } + + ins->set_name( get_sample( p_sample )->get_name() ); + break; + } + +} + +void CPSong::make_instruments_from_samples() { + + for (int i=0;i<MAX_SAMPLES;i++) { + + CPInstrument *ins=get_instrument( i ); + + if (!ins) + continue; + + ins->reset(); + + CPSample *s=get_sample( i ); + + if (!s) + continue; + + ins->set_name( s->get_name() ); + + if (s->get_sample_data().is_null()) + continue; + + + + + for(int j=0;j<CPNote::NOTES;j++) + ins->set_sample_number( j, i ); + + + + } +} + +void CPSong::reset(bool p_clear_patterns,bool p_clear_samples,bool p_clear_instruments,bool p_clear_variables) { + + if (p_clear_variables) { + variables.name[0]=0; + variables.message[0]=0; + variables.row_highlight_major=16; + variables.row_highlight_minor=4; + variables.mixing_volume=48; + variables.old_effects=false; + if (p_clear_instruments) //should not be cleared, if not clearing instruments!! + variables.use_instruments=false; + variables.stereo_separation=128; + variables.use_linear_slides=true; + variables.use_stereo=true; + + initial_variables.global_volume=128; + initial_variables.speed=6; + initial_variables.tempo=125; + + for (int i=0;i<CPPattern::WIDTH;i++) { + + initial_variables.channel[i].pan=32; + initial_variables.channel[i].volume=CHANNEL_MAX_VOLUME; + initial_variables.channel[i].mute=false; + initial_variables.channel[i].surround=false; + initial_variables.channel[i].chorus=0; + initial_variables.channel[i].reverb=0; + + } + + effects.chorus.delay_ms=6; + effects.chorus.separation_ms=3; + effects.chorus.depth_ms10=6, + effects.chorus.speed_hz10=5; + effects.reverb_mode=REVERB_MODE_ROOM; + } + + if (p_clear_samples) { + for (int i=0;i<MAX_SAMPLES;i++) + get_sample(i)->reset(); + } + + if (p_clear_instruments) { + for (int i=0;i<MAX_INSTRUMENTS;i++) + get_instrument(i)->reset(); + } + + if (p_clear_patterns) { + for (int i=0;i<MAX_PATTERNS;i++) + get_pattern(i)->clear(); + + for (int i=0;i<MAX_ORDERS;i++) + set_order( i, CP_ORDER_NONE ); + } + + +} + + +CPSong::ReverbMode CPSong::get_reverb_mode() { + + return effects.reverb_mode; +} +void CPSong::set_reverb_mode(ReverbMode p_mode) { + + effects.reverb_mode=p_mode; +} + +void CPSong::set_chorus_delay_ms(int p_amount) { + + effects.chorus.delay_ms=p_amount; +} +void CPSong::set_chorus_separation_ms(int p_amount) { + + effects.chorus.separation_ms=p_amount; + +} +void CPSong::set_chorus_depth_ms10(int p_amount) { + + effects.chorus.depth_ms10=p_amount; + +} +void CPSong::set_chorus_speed_hz10(int p_amount) { + + effects.chorus.speed_hz10=p_amount; + +} + +int CPSong::get_chorus_delay_ms() { + + return effects.chorus.delay_ms; + +} +int CPSong::get_chorus_separation_ms() { + + return effects.chorus.separation_ms; +} +int CPSong::get_chorus_depth_ms10() { + + return effects.chorus.depth_ms10; + +} +int CPSong::get_chorus_speed_hz10() { + + return effects.chorus.speed_hz10; + +} + +void CPSong::cleanup_unused_patterns() { + + for (int i=0;i<MAX_PATTERNS;i++) { + + bool used=false; + if (get_pattern(i)->is_empty()) + continue; + + for (int j=0;j<MAX_ORDERS;j++) { + + if (get_order(j)==i) { + used=true; + + } + } + + if (!used) + get_pattern(i)->clear(); + } + +} +void CPSong::cleanup_unused_instruments(){ + + if (!has_instruments()) + return; + + bool instr_found[MAX_INSTRUMENTS]; + for (int i=0;i<MAX_INSTRUMENTS;i++) + instr_found[i]=false; + + for (int i=0;i<MAX_PATTERNS;i++) { + + if (get_pattern(i)->is_empty()) + continue; + + for (int row=0;row<get_pattern(i)->get_length();row++) { + + + for (int col=0;col<CPPattern::WIDTH;col++) { + + CPNote n; + n=get_pattern(i)->get_note( col,row ); + + if (n.instrument<MAX_INSTRUMENTS) + instr_found[n.instrument]=true; + + } + + } + + } + + for (int i=0;i<MAX_INSTRUMENTS;i++) + if (!instr_found[i]) + get_instrument(i)->reset(); + + +} +void CPSong::cleanup_unused_samples(){ + + if (!has_instruments()) + return; + + bool sample_found[MAX_SAMPLES]; + for (int i=0;i<MAX_INSTRUMENTS;i++) + sample_found[i]=false; + + for (int i=0;i<MAX_PATTERNS;i++) { + + if (get_pattern(i)->is_empty()) + continue; + + + for (int row=0;row<get_pattern(i)->get_length();row++) { + + + for (int col=0;col<CPPattern::WIDTH;col++) { + + CPNote n; + n=get_pattern(i)->get_note( col,row ); + + if (n.instrument>=MAX_SAMPLES) + continue; + + if (has_instruments()) { + + for (int nt=0;nt<CPNote::NOTES;nt++) { + + int smp=get_instrument(n.instrument)->get_sample_number(nt); + if (smp<MAX_SAMPLES) + sample_found[smp]=true; + } + + } else { + if (n.instrument<MAX_SAMPLES) + sample_found[n.instrument]=true; + } + + } + + } + + } + + for (int i=0;i<MAX_SAMPLES;i++) + if (!sample_found[i]) + get_sample(i)->reset(); + +} +void CPSong::cleanup_unused_orders(){ + + bool finito=false; + for (int j=0;j<MAX_ORDERS;j++) { + + + if (get_order(j)==CP_ORDER_NONE) + finito=true; + if (finito) + set_order(j,CP_ORDER_NONE); + + } + +} + +void CPSong::clear_all_default_pan() { + + for (int i=0;i<MAX_INSTRUMENTS;i++) + get_instrument(i)->set_pan_default_enabled( false ); //die! + + for (int i=0;i<MAX_SAMPLES;i++) + get_sample(i)->set_pan_enabled( false ); //die! + +} + + +void CPSong::clear_all_default_vol(){ + + for (int i=0;i<MAX_SAMPLES;i++) + get_sample(i)->set_default_volume( 64 ); //die! + for (int i=0;i<MAX_INSTRUMENTS;i++) + get_instrument(i)->set_volume_global_amount( CPInstrument::MAX_VOLUME ); + +} + + +int CPSong::get_order_in_use_count() { + + + int order_count = 0; + + for (int i=(MAX_ORDERS-1);i>=0;i--) { + + + if (get_order(i)!=CP_ORDER_NONE) { + order_count=i+1; + break; + } + } + + return order_count; +} +int CPSong::get_pattern_in_use_count() { + + + int pattern_count=0; + + for (int i=(CPSong::MAX_PATTERNS-1);i>=0;i--) { + + + if (!get_pattern(i)->is_empty()) { + pattern_count=i+1; + break; + } + } + + return pattern_count; +} + +int CPSong::get_instrument_in_use_count() { + + int instrument_count=0; + + for (int i=(CPSong::MAX_INSTRUMENTS-1);i>=0;i--) { + + CPInstrument *ins = get_instrument(i); + bool in_use=false; + + for (int s = 0 ; s < CPNote::NOTES ; s++ ) { + + int smp_idx = ins->get_sample_number(s); + if (smp_idx<0 || smp_idx>=CPSong::MAX_SAMPLES) + continue; + + if (!get_sample(smp_idx)->get_sample_data().is_null()) { + in_use=true; + break; + } + + } + + if (in_use) { + instrument_count=i+1; + break; + } + } + + return instrument_count; +} +#include <stdio.h> +int CPSong::get_channels_in_use() { + + int max=0; + + for (int p=0;p<CPSong::MAX_PATTERNS;p++) { + + CPPattern *pat = get_pattern(p); + if (pat->is_empty()) + continue; + + + for (int c=(CPPattern::WIDTH-1);c>=0;c--) { + + if (c<max) + break; + + bool has_note=false; + for (int r=0;r<pat->get_length();r++) { + + CPNote n = pat->get_note( c, r ); + if (!n.is_empty()) { + has_note=true; + break; + } + } + + if (has_note) { + + max=c+1; + } + } + } + + return max; +} + + +void CPSong::separate_in_one_sample_instruments(int p_instrument) { + + CP_ERR_COND( !variables.use_instruments ); + CP_FAIL_INDEX( p_instrument, MAX_INSTRUMENTS ); + + int remapped_count=0; + + signed char remap[MAX_SAMPLES]; + + for (int i=0;i<MAX_SAMPLES;i++) { + + remap[i]=-1; + } + + /* Find remaps */ + CPInstrument *ins=get_instrument(p_instrument); + for (int i=0;i<CPNote::NOTES;i++) { + + int sn = ins->get_sample_number(i); + + // check for unusable sample + if (sn<0 || sn>=MAX_SAMPLES || get_sample(sn)->get_sample_data().is_null()) + continue; + printf("sample %i\n",sn); + if ( remap[sn] !=-1 ) { + printf("already mapped to %i\n",remap[sn]); + continue; + } + + printf("isn't remapped\n"); + + // find remap + + for (int j=0;j<MAX_INSTRUMENTS;j++) { + + if (!get_instrument(j)->is_empty()) + continue; + + printf("map to %i\n",j); + + //copy + *get_instrument(j)=*ins; + + // assign samples + for (int k=0;k<CPNote::NOTES;k++) { + + get_instrument(j)->set_note_number(k,k); + get_instrument(j)->set_sample_number(k,sn); + } + remap[sn]=j; + remapped_count++; + break; + } + + CP_ERR_COND(remap[sn]==-1); // no more free instruments + } + + printf("remapped %i\n",remapped_count); + + if (remapped_count<2) { + //undo if only one is remapped + for (int i=0;i<MAX_SAMPLES;i++) { + + if (remap[i]!=-1) { + + get_instrument(remap[i])->reset(); + } + } + return; + } + + /* remap all song */ + + for (int p=0;p<CPSong::MAX_PATTERNS;p++) { + + CPPattern *pat = get_pattern(p); + if (pat->is_empty()) + continue; + + + for (int c=0;c<CPPattern::WIDTH;c++) { + + for (int r=0;r<pat->get_length();r++) { + + CPNote n = pat->get_note(c,r); + if (n.note<CPNote::NOTES && n.instrument==p_instrument) { + + int sn = ins->get_sample_number(n.note); + if (remap[sn]==-1) + pat->set_note(c,r,CPNote()); + else { + + n.instrument=remap[sn]; + pat->set_note(c,r,n); + } + } + } + } + } + + ins->reset(); + +} + + +CPSong::CPSong() { + + reset(); +} +CPSong::~CPSong() { + +} + + + + +int get_song_next_order_idx(CPSong *p_song, int p_order_idx) { + + int baseorder,order_counter; + + order_counter=-1; + + baseorder=p_order_idx; + + do { + + baseorder++; + if ( baseorder>(CPSong::MAX_ORDERS-1) ) baseorder=0; + order_counter++; + + } while ( (p_song->get_order(baseorder)>=(CPSong::MAX_PATTERNS) ) && (order_counter<CPSong::MAX_ORDERS) ); + + + if (order_counter==CPSong::MAX_ORDERS) { + + return -1; + + } else { + + return baseorder; + } + +} diff --git a/modules/chibi/cp_song.h b/modules/chibi/cp_song.h new file mode 100644 index 0000000000..da5d106a63 --- /dev/null +++ b/modules/chibi/cp_song.h @@ -0,0 +1,261 @@ +/*************************************************************************/ +/* cp_song.h */ +/*************************************************************************/ +/* This file is part of: */ +/* GODOT ENGINE */ +/* http://www.godotengine.org */ +/*************************************************************************/ +/* Copyright (c) 2007-2016 Juan Linietsky, Ariel Manzur. */ +/* */ +/* Permission is hereby granted, free of charge, to any person obtaining */ +/* a copy of this software and associated documentation files (the */ +/* "Software"), to deal in the Software without restriction, including */ +/* without limitation the rights to use, copy, modify, merge, publish, */ +/* distribute, sublicense, and/or sell copies of the Software, and to */ +/* permit persons to whom the Software is furnished to do so, subject to */ +/* the following conditions: */ +/* */ +/* The above copyright notice and this permission notice shall be */ +/* included in all copies or substantial portions of the Software. */ +/* */ +/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */ +/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */ +/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/ +/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */ +/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */ +/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */ +/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ +/*************************************************************************/ +#ifndef CPSONG_H +#define CPSONG_H + + +/**CPSong Class + *@author Juan Linietsky + */ + +#include "cp_order.h" +#include "cp_pattern.h" +#include "cp_sample.h" +#include "cp_instrument.h" + +class CPSong { +public: + enum { + MAX_SONG_NAME=26, + MAX_ORDERS=200, + MAX_PATTERNS=200, + MAX_SAMPLES=99, + MAX_INSTRUMENTS=99, + + CHANNEL_MAX_PAN=64, + CHANNEL_MAX_VOLUME=64, + CHANNEL_MAX_CHORUS=64, + CHANNEL_MAX_REVERB=64, + + MIN_TEMPO=31, + MAX_TEMPO=255, + MIN_SPEED=1, + MAX_SPEED=255, + MAX_MESSAGE_LEN=8000, + + + + }; + + enum ReverbMode { + REVERB_MODE_ROOM, + REVERB_MODE_STUDIO_SMALL, + REVERB_MODE_STUDIO_MEDIUM, + REVERB_MODE_STUDIO_LARGE, + REVERB_MODE_HALL, + REVERB_MODE_SPACE_ECHO, + REVERB_MODE_ECHO, + REVERB_MODE_DELAY, + REVERB_MODE_HALF_ECHO + }; + +private: + CPOrder order[MAX_ORDERS]; + CPPattern pattern[MAX_PATTERNS]; + CPSample sample[MAX_SAMPLES]; + CPInstrument instrument[MAX_INSTRUMENTS]; + + + + struct Song_Variables { // variables that wont change in playback + + char name[MAX_SONG_NAME]; + char message[MAX_MESSAGE_LEN]; + /* string message; */ + + int row_highlight_minor; + int row_highlight_major; + + int mixing_volume; + int stereo_separation; + + bool use_stereo; + bool use_instruments; + bool use_linear_slides; + + bool old_effects; + bool compatible_gxx; + + } variables; + + struct Initial_Variables { // Initial values used for playback + + struct Channel_State { + + int pan,volume; // 0-- CHANNEL_MAX_PAN, CHANNEL_MAX_VOLUME + bool surround; + bool mute; + int chorus; //0 - 64 + int reverb; //0 - 64 + }; + + int global_volume; + int speed; + int tempo; + + Channel_State channel[CPPattern::WIDTH]; + } initial_variables; + + struct Effects { + + ReverbMode reverb_mode; + + struct Chorus { + + int delay_ms; + int separation_ms; + int depth_ms10; + int speed_hz10; + } chorus; + + } effects; + +public: + + /* Properties */ + + const char *get_name(); + void set_name(const char *p_name); + + const char *get_message(); + void set_message(const char *p_message); + + void set_row_highlight_minor(int p_hl_minor); /* 0 .. 256 */ + int get_row_highlight_minor(); /* 0 .. 256 */ + + void set_row_highlight_major(int p_hl_major); /* 0 .. 256 */ + int get_row_highlight_major(); /* 0 .. 256 */ + + void set_mixing_volume(int p_mix_volume); /* 0 .. 128 */ + int get_mixing_volume(); /* 0 .. 128 */ + + void set_global_volume(int p_global_volume); /* 0 .. 128 */ + int get_global_volume(); /* 0 .. 128 */ + + void set_stereo_separation(int p_separation); /* 0 .. 128 */ + int get_stereo_separation(); /* 0 .. 128 */ + + void set_stereo(bool p_stereo); + bool is_stereo(); + + void set_instruments(bool p_instruments); + bool has_instruments(); + + void set_linear_slides(bool p_linear_slides); + bool has_linear_slides(); + + void set_old_effects(bool p_old_effects); + bool has_old_effects(); + + void set_compatible_gxx(bool p_compatible_gxx); + bool has_compatible_gxx(); + + void set_speed(int p_speed); /* 1 .. 255 */ + int get_speed(); /* 1 .. 255 */ + + void set_tempo(int p_tempo); /* 31 .. 255 */ + int get_tempo(); /* 31 .. 255 */ + + void set_channel_pan(int p_channel,int p_pan); /* 0 .. 64 */ + int get_channel_pan(int p_channel); + + void set_channel_volume(int p_channel,int p_volume); /* 0 .. 64 */ + int get_channel_volume(int p_channel); + + void set_channel_surround(int p_channel,bool p_surround); + bool is_channel_surround(int p_channel); + + void set_channel_mute(int p_channel,bool p_mute); + bool is_channel_mute(int p_channel); + + void set_channel_chorus(int p_channel,int p_chorus); /* 0 .. 64 */ + int get_channel_chorus(int p_channel); + + void set_channel_reverb(int p_channel,int p_reverb); /* 0 .. 64 */ + int get_channel_reverb(int p_channel); + + /* arrays of stuff */ + + CPPattern* get_pattern(int p_pattern); + CPSample* get_sample(int p_sample); + CPInstrument* get_instrument(int p_instrument); + + int get_order(int p_position); + void set_order(int p_position,int p_order); + + + /* Effects */ + + ReverbMode get_reverb_mode(); + void set_reverb_mode(ReverbMode p_mode); + + void set_chorus_delay_ms(int p_amount); + void set_chorus_separation_ms(int p_amount); + void set_chorus_depth_ms10(int p_amount); + void set_chorus_speed_hz10(int p_amount); + + int get_chorus_delay_ms(); + int get_chorus_separation_ms(); + int get_chorus_depth_ms10(); + int get_chorus_speed_hz10(); + + /* utils */ + + void reset(bool p_clear_patterns=true,bool p_clear_samples=true,bool p_clear_instruments=true,bool p_clear_variables=true); + + void cleanup_unused_patterns(); + void cleanup_unused_instruments(); + void cleanup_unused_samples(); + void cleanup_unused_orders(); + void clear_all_default_pan(); + void clear_all_default_vol(); + + void clear_instrument_with_samples(int p_instrument); + + void make_instruments_from_samples(); + void make_instrument_from_sample(int p_sample); + + void separate_in_one_sample_instruments(int p_instrument); + + int get_order_in_use_count(); + int get_pattern_in_use_count(); + int get_instrument_in_use_count(); + int get_channels_in_use(); + + CPSong(); + ~CPSong(); + +}; + + +/* Some helper for something used a lot */ + +int get_song_next_order_idx(CPSong *p_song, int p_order_idx); + +#endif diff --git a/modules/chibi/cp_tables.cpp b/modules/chibi/cp_tables.cpp new file mode 100644 index 0000000000..8c62150f31 --- /dev/null +++ b/modules/chibi/cp_tables.cpp @@ -0,0 +1,254 @@ +/*************************************************************************/ +/* cp_tables.cpp */ +/*************************************************************************/ +/* This file is part of: */ +/* GODOT ENGINE */ +/* http://www.godotengine.org */ +/*************************************************************************/ +/* Copyright (c) 2007-2016 Juan Linietsky, Ariel Manzur. */ +/* */ +/* Permission is hereby granted, free of charge, to any person obtaining */ +/* a copy of this software and associated documentation files (the */ +/* "Software"), to deal in the Software without restriction, including */ +/* without limitation the rights to use, copy, modify, merge, publish, */ +/* distribute, sublicense, and/or sell copies of the Software, and to */ +/* permit persons to whom the Software is furnished to do so, subject to */ +/* the following conditions: */ +/* */ +/* The above copyright notice and this permission notice shall be */ +/* included in all copies or substantial portions of the Software. */ +/* */ +/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */ +/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */ +/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/ +/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */ +/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */ +/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */ +/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ +/*************************************************************************/ + +#include "cp_tables.h" + +int32_t CPTables::linear_period_to_freq_tab[768]={ + + 535232,534749,534266,533784,533303,532822,532341,531861, + 531381,530902,530423,529944,529466,528988,528511,528034, + 527558,527082,526607,526131,525657,525183,524709,524236, + 523763,523290,522818,522346,521875,521404,520934,520464, + 519994,519525,519057,518588,518121,517653,517186,516720, + 516253,515788,515322,514858,514393,513929,513465,513002, + 512539,512077,511615,511154,510692,510232,509771,509312, + 508852,508393,507934,507476,507018,506561,506104,505647, + 505191,504735,504280,503825,503371,502917,502463,502010, + 501557,501104,500652,500201,499749,499298,498848,498398, + 497948,497499,497050,496602,496154,495706,495259,494812, + 494366,493920,493474,493029,492585,492140,491696,491253, + 490809,490367,489924,489482,489041,488600,488159,487718, + 487278,486839,486400,485961,485522,485084,484647,484210, + 483773,483336,482900,482465,482029,481595,481160,480726, + 480292,479859,479426,478994,478562,478130,477699,477268, + 476837,476407,475977,475548,475119,474690,474262,473834, + 473407,472979,472553,472126,471701,471275,470850,470425, + 470001,469577,469153,468730,468307,467884,467462,467041, + 466619,466198,465778,465358,464938,464518,464099,463681, + 463262,462844,462427,462010,461593,461177,460760,460345, + 459930,459515,459100,458686,458272,457859,457446,457033, + 456621,456209,455797,455386,454975,454565,454155,453745, + 453336,452927,452518,452110,451702,451294,450887,450481, + 450074,449668,449262,448857,448452,448048,447644,447240, + 446836,446433,446030,445628,445226,444824,444423,444022, + 443622,443221,442821,442422,442023,441624,441226,440828, + 440430,440033,439636,439239,438843,438447,438051,437656, + 437261,436867,436473,436079,435686,435293,434900,434508, + 434116,433724,433333,432942,432551,432161,431771,431382, + 430992,430604,430215,429827,429439,429052,428665,428278, + 427892,427506,427120,426735,426350,425965,425581,425197, + 424813,424430,424047,423665,423283,422901,422519,422138, + 421757,421377,420997,420617,420237,419858,419479,419101, + 418723,418345,417968,417591,417214,416838,416462,416086, + 415711,415336,414961,414586,414212,413839,413465,413092, + 412720,412347,411975,411604,411232,410862,410491,410121, + 409751,409381,409012,408643,408274,407906,407538,407170, + 406803,406436,406069,405703,405337,404971,404606,404241, + 403876,403512,403148,402784,402421,402058,401695,401333, + 400970,400609,400247,399886,399525,399165,398805,398445, + 398086,397727,397368,397009,396651,396293,395936,395579, + 395222,394865,394509,394153,393798,393442,393087,392733, + 392378,392024,391671,391317,390964,390612,390259,389907, + 389556,389204,388853,388502,388152,387802,387452,387102, + 386753,386404,386056,385707,385359,385012,384664,384317, + 383971,383624,383278,382932,382587,382242,381897,381552, + 381208,380864,380521,380177,379834,379492,379149,378807, + 378466,378124,377783,377442,377102,376762,376422,376082, + 375743,375404,375065,374727,374389,374051,373714,373377, + 373040,372703,372367,372031,371695,371360,371025,370690, + 370356,370022,369688,369355,369021,368688,368356,368023, + 367691,367360,367028,366697,366366,366036,365706,365376, + 365046,364717,364388,364059,363731,363403,363075,362747, + 362420,362093,361766,361440,361114,360788,360463,360137, + 359813,359488,359164,358840,358516,358193,357869,357547, + 357224,356902,356580,356258,355937,355616,355295,354974, + 354654,354334,354014,353695,353376,353057,352739,352420, + 352103,351785,351468,351150,350834,350517,350201,349885, + 349569,349254,348939,348624,348310,347995,347682,347368, + 347055,346741,346429,346116,345804,345492,345180,344869, + 344558,344247,343936,343626,343316,343006,342697,342388, + 342079,341770,341462,341154,340846,340539,340231,339924, + 339618,339311,339005,338700,338394,338089,337784,337479, + 337175,336870,336566,336263,335959,335656,335354,335051, + 334749,334447,334145,333844,333542,333242,332941,332641, + 332341,332041,331741,331442,331143,330844,330546,330247, + 329950,329652,329355,329057,328761,328464,328168,327872, + 327576,327280,326985,326690,326395,326101,325807,325513, + 325219,324926,324633,324340,324047,323755,323463,323171, + 322879,322588,322297,322006,321716,321426,321136,320846, + 320557,320267,319978,319690,319401,319113,318825,318538, + 318250,317963,317676,317390,317103,316817,316532,316246, + 315961,315676,315391,315106,314822,314538,314254,313971, + 313688,313405,313122,312839,312557,312275,311994,311712, + 311431,311150,310869,310589,310309,310029,309749,309470, + 309190,308911,308633,308354,308076,307798,307521,307243, + 306966,306689,306412,306136,305860,305584,305308,305033, + 304758,304483,304208,303934,303659,303385,303112,302838, + 302565,302292,302019,301747,301475,301203,300931,300660, + 300388,300117,299847,299576,299306,299036,298766,298497, + 298227,297958,297689,297421,297153,296884,296617,296349, + 296082,295815,295548,295281,295015,294749,294483,294217, + 293952,293686,293421,293157,292892,292628,292364,292100, + 291837,291574,291311,291048,290785,290523,290261,289999, + 289737,289476,289215,288954,288693,288433,288173,287913, + 287653,287393,287134,286875,286616,286358,286099,285841, + 285583,285326,285068,284811,284554,284298,284041,283785, + 283529,283273,283017,282762,282507,282252,281998,281743, + 281489,281235,280981,280728,280475,280222,279969,279716, + 279464,279212,278960,278708,278457,278206,277955,277704, + 277453,277203,276953,276703,276453,276204,275955,275706, + 275457,275209,274960,274712,274465,274217,273970,273722, + 273476,273229,272982,272736,272490,272244,271999,271753, + 271508,271263,271018,270774,270530,270286,270042,269798, + 269555,269312,269069,268826,268583,268341,268099,267857 +}; + +uint16_t CPTables::old_period_table[OCTAVE*2]={ + + 0x6b00, 0x6800, 0x6500, 0x6220, 0x5f50, 0x5c80, + 0x5a00, 0x5740, 0x54d0, 0x5260, 0x5010, 0x4dc0, + 0x4b90, 0x4960, 0x4750, 0x4540, 0x4350, 0x4160, + 0x3f90, 0x3dc0, 0x3c10, 0x3a40, 0x38b0, 0x3700 +}; + +#define LOGFAC 2*16 + +uint16_t CPTables::log_table[104]= { + LOGFAC*907,LOGFAC*900,LOGFAC*894,LOGFAC*887, + LOGFAC*881,LOGFAC*875,LOGFAC*868,LOGFAC*862, + LOGFAC*856,LOGFAC*850,LOGFAC*844,LOGFAC*838, + LOGFAC*832,LOGFAC*826,LOGFAC*820,LOGFAC*814, + LOGFAC*808,LOGFAC*802,LOGFAC*796,LOGFAC*791, + LOGFAC*785,LOGFAC*779,LOGFAC*774,LOGFAC*768, + LOGFAC*762,LOGFAC*757,LOGFAC*752,LOGFAC*746, + LOGFAC*741,LOGFAC*736,LOGFAC*730,LOGFAC*725, + LOGFAC*720,LOGFAC*715,LOGFAC*709,LOGFAC*704, + LOGFAC*699,LOGFAC*694,LOGFAC*689,LOGFAC*684, + LOGFAC*678,LOGFAC*675,LOGFAC*670,LOGFAC*665, + LOGFAC*660,LOGFAC*655,LOGFAC*651,LOGFAC*646, + LOGFAC*640,LOGFAC*636,LOGFAC*632,LOGFAC*628, + LOGFAC*623,LOGFAC*619,LOGFAC*614,LOGFAC*610, + LOGFAC*604,LOGFAC*601,LOGFAC*597,LOGFAC*592, + LOGFAC*588,LOGFAC*584,LOGFAC*580,LOGFAC*575, + LOGFAC*570,LOGFAC*567,LOGFAC*563,LOGFAC*559, + LOGFAC*555,LOGFAC*551,LOGFAC*547,LOGFAC*543, + LOGFAC*538,LOGFAC*535,LOGFAC*532,LOGFAC*528, + LOGFAC*524,LOGFAC*520,LOGFAC*516,LOGFAC*513, + LOGFAC*508,LOGFAC*505,LOGFAC*502,LOGFAC*498, + LOGFAC*494,LOGFAC*491,LOGFAC*487,LOGFAC*484, + LOGFAC*480,LOGFAC*477,LOGFAC*474,LOGFAC*470, + LOGFAC*467,LOGFAC*463,LOGFAC*460,LOGFAC*457, + LOGFAC*453,LOGFAC*450,LOGFAC*447,LOGFAC*443, + LOGFAC*440,LOGFAC*437,LOGFAC*434,LOGFAC*431 +}; + + + +int32_t CPTables::get_linear_period(uint16_t note,int32_t fine) { + + int32_t t; + + t=(24L*OCTAVE-(int32_t)note)*32L-(fine>>1); + return t; +} + +static int s3m_period_table[12]={1712,1616,1524,1440,1356,1280,1208,1140,1076,1016,960,907}; + + +int32_t CPTables::get_log_period(uint16_t note,int32_t p_c5freq) { + + return (8363L * 16 * s3m_period_table[note%12] >> (note/12)) / p_c5freq; + +} + +/* +int32_t CPTables::get_log_period(uint16_t note,int32_t p_c5freq) +{ + uint16_t n,o; + uint16_t p1,p2; + int32_t i; + + n=note%(2*OCTAVE); + o=note/(2*OCTAVE); + i=(n<<2); // n*8 + fine/16 + + if (i<0) + i=0; + + if (i>102) + i=102; + + + p1=log_table[i]; + p2=log_table[i+1]; + + + return (Interpolate(fine>>4,0,15,p1,p2)>>o); + +} */ + +int32_t CPTables::get_old_period(uint16_t note,int32_t speed) { + + uint16_t n,o,res; + +// if (!speed) { + + // return 4242; /* <- prevent divide overflow */ + // } + + n=note%(2*OCTAVE); + o=note/(2*OCTAVE); + + res=((8363L*(int32_t)old_period_table[n])>>o)/((old_period_table[17]>>1)+(speed<<2)); /*/(128-speed)*/; + + return res; +} + +int32_t CPTables::get_linear_frequency(int32_t period) { + + int32_t shift_value=(((int32_t)period/768)-2); + if (shift_value>0) { + + return linear_period_to_freq_tab[period%768]>>shift_value; + } else { + shift_value=0-shift_value; + return linear_period_to_freq_tab[period%768]<<shift_value; + } +} + +int32_t CPTables::get_old_frequency(int32_t period) { + + return (8363L*1712L)/(period?period:1); + +} + +CPTables::CPTables(){ +} +CPTables::~CPTables(){ +} diff --git a/modules/chibi/cp_tables.h b/modules/chibi/cp_tables.h new file mode 100644 index 0000000000..ac7ee562b7 --- /dev/null +++ b/modules/chibi/cp_tables.h @@ -0,0 +1,67 @@ +/*************************************************************************/ +/* cp_tables.h */ +/*************************************************************************/ +/* This file is part of: */ +/* GODOT ENGINE */ +/* http://www.godotengine.org */ +/*************************************************************************/ +/* Copyright (c) 2007-2016 Juan Linietsky, Ariel Manzur. */ +/* */ +/* Permission is hereby granted, free of charge, to any person obtaining */ +/* a copy of this software and associated documentation files (the */ +/* "Software"), to deal in the Software without restriction, including */ +/* without limitation the rights to use, copy, modify, merge, publish, */ +/* distribute, sublicense, and/or sell copies of the Software, and to */ +/* permit persons to whom the Software is furnished to do so, subject to */ +/* the following conditions: */ +/* */ +/* The above copyright notice and this permission notice shall be */ +/* included in all copies or substantial portions of the Software. */ +/* */ +/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */ +/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */ +/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/ +/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */ +/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */ +/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */ +/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ +/*************************************************************************/ + +#ifndef CPTABLES_H +#define CPTABLES_H + +#include "cp_config.h" + +/**conversion CPTables/functions + *@author Juan Linietsky + */ + +/****************************** + CPTables.h + -------- + +CPTables methods for miscelaneous +conversion utilities +********************************/ + +class CPTables { +public: + + enum { OCTAVE=12 }; + + static uint16_t old_period_table[OCTAVE*2]; + static uint16_t log_table[104]; + static int32_t linear_period_to_freq_tab[768]; + + static int32_t get_old_period(uint16_t note,int32_t speed); + static int32_t get_amiga_period(uint16_t note,int32_t fine); + static int32_t get_linear_period(uint16_t note,int32_t fine); + static int32_t get_linear_frequency(int32_t period); + static int32_t get_old_frequency(int32_t period); + static int32_t get_log_period(uint16_t note,int32_t p_c5freq); + + CPTables(); + ~CPTables(); +}; + +#endif diff --git a/modules/chibi/event_stream_chibi.cpp b/modules/chibi/event_stream_chibi.cpp new file mode 100644 index 0000000000..b88f4ee70e --- /dev/null +++ b/modules/chibi/event_stream_chibi.cpp @@ -0,0 +1,872 @@ +/*************************************************************************/ +/* event_stream_chibi.cpp */ +/*************************************************************************/ +/* This file is part of: */ +/* GODOT ENGINE */ +/* http://www.godotengine.org */ +/*************************************************************************/ +/* Copyright (c) 2007-2016 Juan Linietsky, Ariel Manzur. */ +/* */ +/* Permission is hereby granted, free of charge, to any person obtaining */ +/* a copy of this software and associated documentation files (the */ +/* "Software"), to deal in the Software without restriction, including */ +/* without limitation the rights to use, copy, modify, merge, publish, */ +/* distribute, sublicense, and/or sell copies of the Software, and to */ +/* permit persons to whom the Software is furnished to do so, subject to */ +/* the following conditions: */ +/* */ +/* The above copyright notice and this permission notice shall be */ +/* included in all copies or substantial portions of the Software. */ +/* */ +/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */ +/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */ +/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/ +/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */ +/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */ +/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */ +/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ +/*************************************************************************/ +#include "event_stream_chibi.h" +#include "cp_loader_it.h" +#include "cp_loader_xm.h" +#include "cp_loader_s3m.h" +#include "cp_loader_mod.h" + +static CPSampleManagerImpl *sample_manager; +static ResourceFormatLoaderChibi *resource_loader; + +CPSample_ID CPSampleManagerImpl::create(bool p_16bits,bool p_stereo,int32_t p_len) { + + AudioServer::SampleFormat sf=p_16bits?AudioServer::SAMPLE_FORMAT_PCM16:AudioServer::SAMPLE_FORMAT_PCM8; + + SampleData *sd = memnew( SampleData ); + sd->rid = AudioServer::get_singleton()->sample_create(sf,p_stereo,p_len); + sd->stereo=p_stereo; + sd->len=p_len; + sd->is16=p_16bits; + sd->mixfreq=44100; + sd->loop_begin=0; + sd->loop_end=0; + sd->loop_type=CP_LOOP_NONE; + sd->locks=0; +#ifdef DEBUG_ENABLED + valid.insert(sd); +#endif + CPSample_ID sid; + sid._private=sd; + return sid; +} + +void CPSampleManagerImpl::recreate(CPSample_ID p_id,bool p_16bits,bool p_stereo,int32_t p_len){ + + AudioServer::SampleFormat sf=p_16bits?AudioServer::SAMPLE_FORMAT_PCM16:AudioServer::SAMPLE_FORMAT_PCM8; + SampleData *sd=_getsd(p_id); +#ifdef DEBUG_ENABLED + ERR_FAIL_COND(!valid.has(sd)); +#endif + AudioServer::get_singleton()->free(sd->rid); + sd->rid = AudioServer::get_singleton()->sample_create(sf,p_stereo,p_len); + sd->stereo=p_stereo; + sd->len=p_len; + sd->is16=p_16bits; + sd->mixfreq=44100; + sd->loop_begin=0; + sd->loop_end=0; + sd->loop_type=CP_LOOP_NONE; +} +void CPSampleManagerImpl::destroy(CPSample_ID p_id){ + + SampleData *sd=_getsd(p_id); +#ifdef DEBUG_ENABLED + ERR_FAIL_COND(!valid.has(sd)); + valid.erase(sd); +#endif + AudioServer::get_singleton()->free(sd->rid); + + memdelete(sd); +} +bool CPSampleManagerImpl::check(CPSample_ID p_id){ + + SampleData *sd=_getsd(p_id); +#ifdef DEBUG_ENABLED + return valid.has(sd); +#else + return _getsd(p_id)!=NULL; +#endif +} + +void CPSampleManagerImpl::set_c5_freq(CPSample_ID p_id,int32_t p_freq){ + + SampleData *sd=_getsd(p_id); +#ifdef DEBUG_ENABLED + ERR_FAIL_COND(!valid.has(sd)); +#endif + sd->mixfreq=p_freq; + AudioServer::get_singleton()->sample_set_mix_rate(sd->rid,p_freq); + +} +void CPSampleManagerImpl::set_loop_begin(CPSample_ID p_id,int32_t p_begin){ + + SampleData *sd=_getsd(p_id); +#ifdef DEBUG_ENABLED + ERR_FAIL_COND(!valid.has(sd)); +#endif + sd->loop_begin=p_begin; + AudioServer::get_singleton()->sample_set_loop_begin(sd->rid,p_begin); + +} +void CPSampleManagerImpl::set_loop_end(CPSample_ID p_id,int32_t p_end){ + + SampleData *sd=_getsd(p_id); +#ifdef DEBUG_ENABLED + ERR_FAIL_COND(!valid.has(sd)); +#endif + sd->loop_end=p_end; + AudioServer::get_singleton()->sample_set_loop_end(sd->rid,p_end); + +} +void CPSampleManagerImpl::set_loop_type(CPSample_ID p_id,CPSample_Loop_Type p_type){ + + SampleData *sd=_getsd(p_id); +#ifdef DEBUG_ENABLED + ERR_FAIL_COND(!valid.has(sd)); +#endif + + sd->loop_type=p_type; + AudioServer::get_singleton()->sample_set_loop_format(sd->rid,AudioServer::SampleLoopFormat(p_type)); + + +} +void CPSampleManagerImpl::set_chunk(CPSample_ID p_id,int32_t p_index,void *p_data,int p_data_len){ + + SampleData *sd=_getsd(p_id); +#ifdef DEBUG_ENABLED + ERR_FAIL_COND(!valid.has(sd)); +#endif + + ERR_FAIL(); +} + + +int32_t CPSampleManagerImpl::get_loop_begin(CPSample_ID p_id){ + + SampleData *sd=_getsd(p_id); +#ifdef DEBUG_ENABLED + ERR_FAIL_COND_V(!valid.has(sd),0); +#endif + + return sd->loop_begin; + +} +int32_t CPSampleManagerImpl::get_loop_end(CPSample_ID p_id){ + + SampleData *sd=_getsd(p_id); +#ifdef DEBUG_ENABLED + ERR_FAIL_COND_V(!valid.has(sd),0); +#endif + + return sd->loop_end; +} +CPSample_Loop_Type CPSampleManagerImpl::get_loop_type(CPSample_ID p_id){ + + SampleData *sd=_getsd(p_id); +#ifdef DEBUG_ENABLED + ERR_FAIL_COND_V(!valid.has(sd),CP_LOOP_NONE); +#endif + + return sd->loop_type; +} +int32_t CPSampleManagerImpl::get_c5_freq(CPSample_ID p_id){ + + SampleData *sd=_getsd(p_id); +#ifdef DEBUG_ENABLED + ERR_FAIL_COND_V(!valid.has(sd),0); +#endif + + return sd->mixfreq; +} +int32_t CPSampleManagerImpl::get_size(CPSample_ID p_id){ + + SampleData *sd=_getsd(p_id); +#ifdef DEBUG_ENABLED + ERR_FAIL_COND_V(!valid.has(sd),0); +#endif + + return sd->len; + +} +bool CPSampleManagerImpl::is_16bits(CPSample_ID p_id){ + + SampleData *sd=_getsd(p_id); +#ifdef DEBUG_ENABLED + ERR_FAIL_COND_V(!valid.has(sd),false); +#endif + + return sd->is16; + +} +bool CPSampleManagerImpl::is_stereo(CPSample_ID p_id){ + + SampleData *sd=_getsd(p_id); +#ifdef DEBUG_ENABLED + ERR_FAIL_COND_V(!valid.has(sd),false); +#endif + return sd->stereo; + + +} +bool CPSampleManagerImpl::lock_data(CPSample_ID p_id){ + + SampleData *sd=_getsd(p_id); +#ifdef DEBUG_ENABLED + ERR_FAIL_COND_V(!valid.has(sd),0); +#endif + + sd->locks++; + if (sd->locks==1) { + sd->lock=AudioServer::get_singleton()->sample_get_data(sd->rid); + sd->w=sd->lock.write(); + } + + return true; +} +void *CPSampleManagerImpl::get_data(CPSample_ID p_id){ + + SampleData *sd=_getsd(p_id); +#ifdef DEBUG_ENABLED + ERR_FAIL_COND_V(!valid.has(sd),0); +#endif + + ERR_FAIL_COND_V(sd->locks==0,0); + return sd->w.ptr(); +} + +int16_t CPSampleManagerImpl::get_data(CPSample_ID p_id, int p_sample, int p_channel){ + + SampleData *sd=_getsd(p_id); +#ifdef DEBUG_ENABLED + ERR_FAIL_COND_V(!valid.has(sd),0); +#endif + + ERR_FAIL_V(0); + lock_data(p_id); + + int sofs = sd->stereo ? 2:1; + uint16_t v=0; + if (sd->is16) { + int16_t *p=(int16_t*)sd->w.ptr(); + v=p[p_sample*sofs+p_channel]; + } else { + int8_t *p=(int8_t*)sd->w.ptr(); + v=p[p_sample*sofs+p_channel]; + } + + unlock_data(p_id); + + return v; +} +void CPSampleManagerImpl::set_data(CPSample_ID p_id, int p_sample, int16_t p_data,int p_channel){ + + SampleData *sd=_getsd(p_id); +#ifdef DEBUG_ENABLED + ERR_FAIL_COND(!valid.has(sd)); +#endif + + ERR_FAIL(); + lock_data(p_id); + + int sofs = sd->stereo ? 2:1; + if (sd->is16) { + int16_t *p=(int16_t*)sd->w.ptr(); + p[p_sample*sofs+p_channel]=p_data; + } else { + int8_t *p=(int8_t*)sd->w.ptr(); + p[p_sample*sofs+p_channel]=p_data; + } + + unlock_data(p_id); + +} +void CPSampleManagerImpl::unlock_data(CPSample_ID p_id){ + + SampleData *sd=_getsd(p_id); +#ifdef DEBUG_ENABLED + ERR_FAIL_COND(!valid.has(sd)); +#endif + + ERR_FAIL_COND(sd->locks==0); + + sd->locks--; + if (sd->locks==0) { + sd->w=DVector<uint8_t>::Write(); + AudioServer::get_singleton()->sample_set_data(sd->rid,sd->lock); + sd->lock=DVector<uint8_t>(); + } +} + +void CPSampleManagerImpl::get_chunk(CPSample_ID p_id,int32_t p_index,void *p_data,int p_data_len) { + + SampleData *sd=_getsd(p_id); +#ifdef DEBUG_ENABLED + ERR_FAIL_COND(!valid.has(sd)); +#endif + + ERR_FAIL(); +} + + +/** MIXER **/ + +void CPMixerImpl::set_callback_interval(int p_interval_us) { + + callback_interval=p_interval_us; +} + +void CPMixerImpl::set_callback(void (*p_callback)(void*),void *p_userdata) { + + callback=p_callback; + userdata=p_userdata; +} + +void CPMixerImpl::setup_voice(int p_voice_index,CPSample_ID p_sample_id,int32_t p_start_index) { + + Voice &v=voices[p_voice_index]; + if (v.channel!=AudioMixer::INVALID_CHANNEL) { + mixer->channel_free(v.channel); + } + v.channel=mixer->channel_alloc(sample_manager->get_rid(p_sample_id)); + v.freq_mult = sample_manager->get_c5_freq(p_sample_id)/261.6255653006; + v.sample = p_sample_id; +} + +void CPMixerImpl::stop_voice(int p_voice_index) { + + Voice &v=voices[p_voice_index]; + if (v.channel==AudioMixer::INVALID_CHANNEL) + return; + + mixer->channel_free(v.channel); + v.channel=AudioMixer::INVALID_CHANNEL; + +} + +void CPMixerImpl::set_voice_frequency(int p_voice_index,int32_t p_freq) { + + Voice &v=voices[p_voice_index]; + ERR_FAIL_COND(v.channel==AudioMixer::INVALID_CHANNEL); + float f = p_freq / 256.0; + f*=pitch_scale; + mixer->channel_set_mix_rate(v.channel,f * v.freq_mult ); +} + +void CPMixerImpl::set_voice_panning(int p_voice_index,int p_pan) { + + Voice &v=voices[p_voice_index]; + ERR_FAIL_COND(v.channel==AudioMixer::INVALID_CHANNEL); + if (p_pan==CP_PAN_SURROUND) + p_pan=CP_PAN_CENTER; + float p = p_pan / 256.0; + mixer->channel_set_pan(v.channel,p); + +} + +void CPMixerImpl::set_voice_volume(int p_voice_index,int p_vol) { + + + Voice &v=voices[p_voice_index]; + ERR_FAIL_COND(v.channel==AudioMixer::INVALID_CHANNEL); + float vol = p_vol/512.0; + vol*=voice_scale; + mixer->channel_set_volume(v.channel,vol); + mixer->channel_set_reverb(v.channel,reverb_type,vol*v.reverb); +} + +void CPMixerImpl::set_voice_filter(int p_voice_index,bool p_enabled,uint8_t p_cutoff, uint8_t p_resonance ){ + + Voice &v=voices[p_voice_index]; + ERR_FAIL_COND(v.channel==AudioMixer::INVALID_CHANNEL); + +} + +void CPMixerImpl::set_voice_reverb_send(int p_voice_index,int p_reverb){ + + Voice &v=voices[p_voice_index]; + ERR_FAIL_COND(v.channel==AudioMixer::INVALID_CHANNEL); + v.reverb=p_reverb/255.0; + //mixer->channel_set_reverb(v.channel,reverb_type,p_reverb/255.0); + +} + +void CPMixerImpl::set_voice_chorus_send(int p_voice_index,int p_chorus){ + + Voice &v=voices[p_voice_index]; + ERR_FAIL_COND(v.channel==AudioMixer::INVALID_CHANNEL); + mixer->channel_set_chorus(v.channel,p_chorus/255.0); + +} + + +void CPMixerImpl::set_reverb_mode(ReverbMode p_mode){ + +// Voice &v=voices[p_voice_index]; +// ERR_FAIL_COND(v.channel==AudioMixer::INVALID_CHANNEL); + switch(p_mode) { + case CPMixer::REVERB_MODE_STUDIO_SMALL: reverb_type=AudioMixer::REVERB_SMALL; break; + case CPMixer::REVERB_MODE_STUDIO_MEDIUM: reverb_type=AudioMixer::REVERB_MEDIUM; break; + case CPMixer::REVERB_MODE_STUDIO_LARGE: reverb_type=AudioMixer::REVERB_LARGE; break; + case CPMixer::REVERB_MODE_HALL: reverb_type=AudioMixer::REVERB_HALL; break; + default: reverb_type=AudioMixer::REVERB_SMALL; break; + } + +} + +void CPMixerImpl::set_chorus_params(unsigned int p_delay_ms,unsigned int p_separation_ms,unsigned int p_depth_ms10,unsigned int p_speed_hz10){ + +// Voice &v=voices[p_voice_index]; +// ERR_FAIL_COND(v.channel==AudioMixer::INVALID_CHANNEL); + +} + + + +/* Info retrieving */ + +int32_t CPMixerImpl::get_voice_sample_pos_index(int p_voice_index) { + + Voice &v=voices[p_voice_index]; + ERR_FAIL_COND_V(v.channel==AudioMixer::INVALID_CHANNEL,0); + return 0; + +} + +int CPMixerImpl::get_voice_panning(int p_voice_index) { + + Voice &v=voices[p_voice_index]; + ERR_FAIL_COND_V(!is_voice_active(p_voice_index),0); + return mixer->channel_get_pan(v.channel)*CP_PAN_RIGHT; + +} + +int CPMixerImpl::get_voice_volume(int p_voice_index) { + + Voice &v=voices[p_voice_index]; + ERR_FAIL_COND_V(!is_voice_active(p_voice_index),0); + return mixer->channel_get_volume(v.channel); + + +} + +CPSample_ID CPMixerImpl::get_voice_sample_id(int p_voice_index) { + + Voice &v=voices[p_voice_index]; + ERR_FAIL_COND_V(v.channel==AudioMixer::INVALID_CHANNEL,CPSample_ID()); + return v.sample; + + +} + +bool CPMixerImpl::is_voice_active(int p_voice_index){ + + Voice &v=voices[p_voice_index]; + if (v.channel==AudioMixer::INVALID_CHANNEL) + return false; + if (!mixer->channel_is_valid(v.channel)) + v.channel=AudioMixer::INVALID_CHANNEL; + + return v.channel!=AudioMixer::INVALID_CHANNEL; +} + +void CPMixerImpl::process_usecs(int p_usec,float p_volume,float p_pitch_scale,float p_tempo_scale) { + + ERR_FAIL_COND(callback_interval==0); + //update this somewhere + pitch_scale=p_pitch_scale; + tempo_scale=p_tempo_scale; + voice_scale = AudioServer::get_singleton()->get_event_voice_global_volume_scale()*p_volume; + while(p_usec) { + + if (p_usec>=callback_timeout) { + + p_usec-=callback_timeout; + callback_timeout=0; + if (callback) { + callback(userdata); + } + callback_timeout=callback_interval*(1.0/p_tempo_scale); + + } else { + + callback_timeout-=p_usec; + p_usec=0; + } + } +} + + +CPMixerImpl::CPMixerImpl(AudioMixer *p_mixer) { + + callback_interval=1; + callback_timeout=0; + userdata=0; + callback=0; + tempo_scale=1.0; + pitch_scale=1.0; + mixer=p_mixer; + voice_scale = AudioServer::get_singleton()->get_event_voice_global_volume_scale(); + reverb_type = AudioMixer::REVERB_SMALL; + +} + +/** FILE ACCESS WRAPPER **/ + + +CPFileAccessWrapperImpl::Error CPFileAccessWrapperImpl::open(const char *p_filename, int p_mode_flags) { + + ERR_FAIL_COND_V(p_mode_flags&WRITE,ERROR_WRITING_FILE); + close(); + f = FileAccess::open(String::utf8(p_filename),p_mode_flags); + if (!f) + return ERROR_FILE_NOT_FOUND; + return OK; +} + +void CPFileAccessWrapperImpl::close(){ + + if (f) + memdelete(f); + f=NULL; + + +} + +void CPFileAccessWrapperImpl::seek(uint32_t p_position){ + + f->seek(p_position); +} +void CPFileAccessWrapperImpl::seek_end(){ + + f->seek_end(); +} +uint32_t CPFileAccessWrapperImpl::get_pos(){ + + return f->get_pos(); +} + +bool CPFileAccessWrapperImpl::eof_reached(){ + + return f->eof_reached(); +} + +uint8_t CPFileAccessWrapperImpl::get_byte(){ + + return f->get_8(); +} +void CPFileAccessWrapperImpl::get_byte_array(uint8_t *p_dest,int p_elements){ + + f->get_buffer(p_dest,p_elements); +} +void CPFileAccessWrapperImpl::get_word_array(uint16_t *p_dest,int p_elements){ + + for(int i=0;i<p_elements;i++) { + p_dest[i]=f->get_16(); + } + +} + +uint16_t CPFileAccessWrapperImpl::get_word(){ + + return f->get_16(); +} +uint32_t CPFileAccessWrapperImpl::get_dword(){ + + return f->get_32(); +} + +void CPFileAccessWrapperImpl::set_endian_conversion(bool p_swap){ + + f->set_endian_swap(p_swap); +} +bool CPFileAccessWrapperImpl::is_open(){ + + return f!=NULL; +} + +CPFileAccessWrapperImpl::Error CPFileAccessWrapperImpl::get_error(){ + + return (f->get_error()!=::OK)?ERROR_READING_FILE:OK; +} + +void CPFileAccessWrapperImpl::store_byte(uint8_t p_dest){ + +} +void CPFileAccessWrapperImpl::store_byte_array(const uint8_t *p_dest,int p_elements){ + +} + +void CPFileAccessWrapperImpl::store_word(uint16_t p_dest){ + +} +void CPFileAccessWrapperImpl::store_dword(uint32_t p_dest){ + +} + +//////////////////////////////////////////////// + + +Error EventStreamPlaybackChibi::_play() { + + last_order=0; + loops=0; + player->play_start_song(); + total_usec=0; + + return OK; +} + +bool EventStreamPlaybackChibi::_update(AudioMixer* p_mixer, uint64_t p_usec){ + + total_usec+=p_usec; + mixer.process_usecs(p_usec,volume,pitch_scale,tempo_scale); + int order=player->get_current_order(); + if (order<last_order) { + if (!loop) { + stop(); + } else { + loops++; + } + } + last_order=order; + return false; +} +void EventStreamPlaybackChibi::_stop(){ + + player->play_stop(); +} + +void EventStreamPlaybackChibi::set_paused(bool p_paused){ + +} +bool EventStreamPlaybackChibi::is_paused() const{ + + return false; +} +void EventStreamPlaybackChibi::set_loop(bool p_loop){ + + loop=p_loop; + +} +bool EventStreamPlaybackChibi::is_loop_enabled() const{ + + return loop; +} + +int EventStreamPlaybackChibi::get_loop_count() const{ + + //return player->is + return loops; +} + +float EventStreamPlaybackChibi::get_pos() const{ + + return double(total_usec)/1000000.0; +} +void EventStreamPlaybackChibi::seek_pos(float p_time){ + + WARN_PRINT("seek_pos unimplemented."); +} + +void EventStreamPlaybackChibi::set_volume(float p_volume) { + + volume=p_volume; +} + +float EventStreamPlaybackChibi::get_volume() const{ + + return volume; +} + +void EventStreamPlaybackChibi::set_pitch_scale(float p_pitch_scale) { + + pitch_scale=p_pitch_scale; +} + +float EventStreamPlaybackChibi::get_pitch_scale() const{ + + return pitch_scale; +} + +void EventStreamPlaybackChibi::set_tempo_scale(float p_tempo_scale) { + + tempo_scale=p_tempo_scale; +} + +float EventStreamPlaybackChibi::get_tempo_scale() const{ + + return tempo_scale; +} + + +void EventStreamPlaybackChibi::set_channel_volume(int p_channel,float p_volume) { + + + if (p_channel>=64) + return; + player->set_channel_global_volume(p_channel,p_volume*256); +} + + + +float EventStreamPlaybackChibi::get_channel_volume(int p_channel) const{ + + return player->get_channel_global_volume(p_channel)/256.0; + +} + +float EventStreamPlaybackChibi::get_last_note_time(int p_channel) const { + + + double v = (player->get_channel_last_note_time_usec(p_channel))/1000000.0; + if (v<0) + v=-1; + return v; +} + +EventStreamPlaybackChibi::EventStreamPlaybackChibi(Ref<EventStreamChibi> p_stream) : mixer(_get_mixer()) { + + stream=p_stream; + player = memnew( CPPlayer(&mixer,&p_stream->song) ); + loop=false; + last_order=0; + loops=0; + volume=1.0; + pitch_scale=1.0; + tempo_scale=1.0; +} +EventStreamPlaybackChibi::~EventStreamPlaybackChibi(){ + + player->play_stop(); + memdelete(player); +} + +//////////////////////////////////////////////////// + +Ref<EventStreamPlayback> EventStreamChibi::instance_playback() { + + return Ref<EventStreamPlayback>( memnew(EventStreamPlaybackChibi(Ref<EventStreamChibi>(this))) ); +} + +String EventStreamChibi::get_stream_name() const{ + + return song.get_name(); + +} + + + +float EventStreamChibi::get_length() const{ + + return 1; +} + + +EventStreamChibi::EventStreamChibi() { + + +} + + + +////////////////////////////////////////////////////////////////// + + + + +RES ResourceFormatLoaderChibi::load(const String &p_path, const String& p_original_path, Error *r_error) { + + if (r_error) + *r_error=ERR_FILE_CANT_OPEN; + String el = p_path.extension().to_lower(); + + CPFileAccessWrapperImpl f; + + if (el=="it") { + + Ref<EventStreamChibi> esc( memnew( EventStreamChibi ) ); + CPLoader_IT loader(&f); + CPLoader::Error err = loader.load_song(p_path.utf8().get_data(),&esc->song,false); + ERR_FAIL_COND_V(err!=CPLoader::FILE_OK,RES()); + if (r_error) + *r_error=OK; + + return esc; + + } else if (el=="xm") { + + Ref<EventStreamChibi> esc( memnew( EventStreamChibi ) ); + CPLoader_XM loader(&f); + CPLoader::Error err=loader.load_song(p_path.utf8().get_data(),&esc->song,false); + ERR_FAIL_COND_V(err!=CPLoader::FILE_OK,RES()); + if (r_error) + *r_error=OK; + return esc; + + } else if (el=="s3m") { + + Ref<EventStreamChibi> esc( memnew( EventStreamChibi ) ); + CPLoader_S3M loader(&f); + CPLoader::Error err=loader.load_song(p_path.utf8().get_data(),&esc->song,false); + ERR_FAIL_COND_V(err!=CPLoader::FILE_OK,RES()); + if (r_error) + *r_error=OK; + + return esc; + + } else if (el=="mod") { + + Ref<EventStreamChibi> esc( memnew( EventStreamChibi ) ); + CPLoader_MOD loader(&f); + CPLoader::Error err=loader.load_song(p_path.utf8().get_data(),&esc->song,false); + ERR_FAIL_COND_V(err!=CPLoader::FILE_OK,RES()); + if (r_error) + *r_error=OK; + return esc; + } + + return RES(); + +} + +void ResourceFormatLoaderChibi::get_recognized_extensions(List<String> *p_extensions) const { + + p_extensions->push_back("it"); + p_extensions->push_back("xm"); + p_extensions->push_back("s3m"); + p_extensions->push_back("mod"); +} +bool ResourceFormatLoaderChibi::handles_type(const String& p_type) const { + + return (p_type=="EventStreamChibi" || p_type=="EventStream"); +} + +String ResourceFormatLoaderChibi::get_resource_type(const String &p_path) const { + String el = p_path.extension().to_lower(); + if (el=="it" || el=="s3m" || el=="xm" || el=="mod") + return "EventStreamChibi"; + return ""; +} + +///////////////////////////////////////////////////////////////// +void initialize_chibi() { + + sample_manager = memnew( CPSampleManagerImpl ); + resource_loader = memnew( ResourceFormatLoaderChibi ); + ObjectTypeDB::register_type<EventStreamChibi>(); + ResourceLoader::add_resource_format_loader( resource_loader ); +} + +void finalize_chibi() { + + memdelete( sample_manager ); + memdelete( resource_loader ); +} + diff --git a/modules/chibi/event_stream_chibi.h b/modules/chibi/event_stream_chibi.h new file mode 100644 index 0000000000..cc7b0ace86 --- /dev/null +++ b/modules/chibi/event_stream_chibi.h @@ -0,0 +1,314 @@ +/*************************************************************************/ +/* event_stream_chibi.h */ +/*************************************************************************/ +/* This file is part of: */ +/* GODOT ENGINE */ +/* http://www.godotengine.org */ +/*************************************************************************/ +/* Copyright (c) 2007-2016 Juan Linietsky, Ariel Manzur. */ +/* */ +/* Permission is hereby granted, free of charge, to any person obtaining */ +/* a copy of this software and associated documentation files (the */ +/* "Software"), to deal in the Software without restriction, including */ +/* without limitation the rights to use, copy, modify, merge, publish, */ +/* distribute, sublicense, and/or sell copies of the Software, and to */ +/* permit persons to whom the Software is furnished to do so, subject to */ +/* the following conditions: */ +/* */ +/* The above copyright notice and this permission notice shall be */ +/* included in all copies or substantial portions of the Software. */ +/* */ +/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */ +/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */ +/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/ +/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */ +/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */ +/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */ +/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ +/*************************************************************************/ +#ifndef EVENT_STREAM_CHIBI_H +#define EVENT_STREAM_CHIBI_H + +#include "scene/resources/event_stream.h" +#include "cp_sample_manager.h" +#include "cp_mixer.h" +#include "cp_song.h" +#include "cp_file_access_wrapper.h" +#include "cp_player_data.h" +#include "resource.h" +#include "servers/audio_server.h" +#include "os/file_access.h" +#include "io/resource_loader.h" + +/** SAMPLE MANAGER **/ + +class CPSampleManagerImpl : public CPSampleManager { + + struct SampleData { + + RID rid; + bool stereo; + bool is16; + int len; + int mixfreq; + int loop_begin; + int loop_end; + int locks; + DVector<uint8_t> lock; + DVector<uint8_t>::Write w; + CPSample_Loop_Type loop_type; + }; + + + _FORCE_INLINE_ SampleData* _getsd(CPSample_ID p_id) { + + return ((SampleData*)p_id._private); + } + Set<SampleData*> valid; + +public: + + _FORCE_INLINE_ RID get_rid(CPSample_ID p_id) { return _getsd(p_id)->rid; } + virtual CPSample_ID create(bool p_16bits,bool p_stereo,int32_t p_len); + virtual void recreate(CPSample_ID p_id,bool p_16bits,bool p_stereo,int32_t p_len); + virtual void destroy(CPSample_ID p_id); + virtual bool check(CPSample_ID p_id); // return false if invalid + + virtual void set_c5_freq(CPSample_ID p_id,int32_t p_freq); + virtual void set_loop_begin(CPSample_ID p_id,int32_t p_begin); + virtual void set_loop_end(CPSample_ID p_id,int32_t p_end); + virtual void set_loop_type(CPSample_ID p_id,CPSample_Loop_Type p_type); + virtual void set_chunk(CPSample_ID p_id,int32_t p_index,void *p_data,int p_data_len); + + + virtual int32_t get_loop_begin(CPSample_ID p_id); + virtual int32_t get_loop_end(CPSample_ID p_id); + virtual CPSample_Loop_Type get_loop_type(CPSample_ID p_id); + virtual int32_t get_c5_freq(CPSample_ID p_id); + virtual int32_t get_size(CPSample_ID p_id); + virtual bool is_16bits(CPSample_ID p_id); + virtual bool is_stereo(CPSample_ID p_id); + virtual bool lock_data(CPSample_ID p_id); + virtual void *get_data(CPSample_ID p_id); /* WARNING: Not all sample managers +may be able to implement this, it depends on the mixer in use! */ + virtual int16_t get_data(CPSample_ID p_id, int p_sample, int p_channel=0); /// Does not need locking + virtual void set_data(CPSample_ID p_id, int p_sample, int16_t p_data,int p_channel=0); /// Does not need locking + virtual void unlock_data(CPSample_ID p_id); + + virtual void get_chunk(CPSample_ID p_id,int32_t p_index,void *p_data,int p_data_len); + +}; + + +/** MIXER **/ + +class CPMixerImpl : public CPMixer { + + enum { + MAX_VOICES=64 + }; + + struct Voice { + + AudioMixer::ChannelID channel; + CPSample_ID sample; + float freq_mult; + float reverb; + Voice() { reverb=0.0; } + }; + + Voice voices[MAX_VOICES]; + + + int callback_interval; + int callback_timeout; + void (*callback)(void*); + void *userdata; + float voice_scale; + float tempo_scale; + float pitch_scale; + AudioMixer::ReverbRoomType reverb_type; + AudioMixer *mixer; +public: + + void process_usecs(int p_usec,float p_volume,float p_pitch_scale,float p_tempo_scale); + + /* Callback */ + + virtual void set_callback_interval(int p_interval_us); //in usecs, for tracker it's 2500000/tempo + virtual void set_callback(void (*p_callback)(void*),void *p_userdata); + + /* Voice Control */ + + virtual void setup_voice(int p_voice_index,CPSample_ID p_sample_id,int32_t p_start_index) ; + virtual void stop_voice(int p_voice_index) ; + virtual void set_voice_frequency(int p_voice_index,int32_t p_freq) ; //in freq*FREQUENCY_BITS + virtual void set_voice_panning(int p_voice_index,int p_pan) ; + virtual void set_voice_volume(int p_voice_index,int p_vol) ; + virtual void set_voice_filter(int p_filter,bool p_enabled,uint8_t p_cutoff, uint8_t p_resonance ); + virtual void set_voice_reverb_send(int p_voice_index,int p_reverb); + virtual void set_voice_chorus_send(int p_voice_index,int p_chorus); /* 0 - 255 */ + + virtual void set_reverb_mode(ReverbMode p_mode); + virtual void set_chorus_params(unsigned int p_delay_ms,unsigned int p_separation_ms,unsigned int p_depth_ms10,unsigned int p_speed_hz10); + + + /* Info retrieving */ + + virtual int32_t get_voice_sample_pos_index(int p_voice_index) ; + virtual int get_voice_panning(int p_voice_index) ; + virtual int get_voice_volume(int p_voice_index) ; + virtual CPSample_ID get_voice_sample_id(int p_voice_index) ; + virtual bool is_voice_active(int p_voice_index); + virtual int get_active_voice_count() { return 0; } + virtual int get_total_voice_count() { return MAX_VOICES; } + + + virtual uint32_t get_mix_frequency() { return 0; } + + /* Methods below only work with software mixers, meant for software-based sound drivers, hardware mixers ignore them */ + virtual int32_t process(int32_t p_frames) { return 0; } + virtual int32_t *get_mixdown_buffer_ptr() { return NULL; } + virtual void set_mix_frequency(int32_t p_mix_frequency) {}; + + CPMixerImpl(AudioMixer *p_mixer=NULL); + virtual ~CPMixerImpl() {} +}; + +/** FILE ACCESS **/ + +class CPFileAccessWrapperImpl : public CPFileAccessWrapper { + + FileAccess *f; +public: + + + virtual Error open(const char *p_filename, int p_mode_flags); + virtual void close(); + + virtual void seek(uint32_t p_position); + virtual void seek_end(); + virtual uint32_t get_pos(); + + virtual bool eof_reached(); + + virtual uint8_t get_byte(); + virtual void get_byte_array(uint8_t *p_dest,int p_elements); + virtual void get_word_array(uint16_t *p_dest,int p_elements); + + virtual uint16_t get_word(); + virtual uint32_t get_dword(); + + virtual void set_endian_conversion(bool p_swap); + virtual bool is_open(); + + virtual Error get_error(); + + virtual void store_byte(uint8_t p_dest); + virtual void store_byte_array(const uint8_t *p_dest,int p_elements); + + virtual void store_word(uint16_t p_dest); + virtual void store_dword(uint32_t p_dest); + + CPFileAccessWrapperImpl() { f=NULL; } + virtual ~CPFileAccessWrapperImpl(){ if (f) memdelete(f); } + +}; + + + +///////////////////// + +class EventStreamChibi; + +class EventStreamPlaybackChibi : public EventStreamPlayback { + + OBJ_TYPE(EventStreamPlaybackChibi,EventStreamPlayback); + + CPMixerImpl mixer; + uint64_t total_usec; + Ref<EventStreamChibi> stream; + mutable CPPlayer *player; + bool loop; + int last_order; + int loops; + virtual Error _play(); + virtual bool _update(AudioMixer* p_mixer, uint64_t p_usec); + virtual void _stop(); + float volume; + float tempo_scale; + float pitch_scale; + + +public: + + + virtual void set_paused(bool p_paused); + virtual bool is_paused() const; + + virtual void set_loop(bool p_loop); + virtual bool is_loop_enabled() const; + + virtual int get_loop_count() const; + + virtual float get_pos() const; + virtual void seek_pos(float p_time); + + virtual void set_volume(float p_vol); + virtual float get_volume() const; + + virtual void set_pitch_scale(float p_pitch_scale); + virtual float get_pitch_scale() const; + + virtual void set_tempo_scale(float p_tempo_scale); + virtual float get_tempo_scale() const; + + virtual void set_channel_volume(int p_channel,float p_volume); + virtual float get_channel_volume(int p_channel) const; + + virtual float get_last_note_time(int p_channel) const; + + EventStreamPlaybackChibi(Ref<EventStreamChibi> p_stream=Ref<EventStreamChibi>()); + ~EventStreamPlaybackChibi(); +}; + + +class EventStreamChibi : public EventStream { + + OBJ_TYPE(EventStreamChibi,EventStream); + +friend class ResourceFormatLoaderChibi; +friend class EventStreamPlaybackChibi; + //I think i didn't know what const was when i wrote this more than a decade ago + //so it goes mutable :( + mutable CPSong song; + + +public: + + virtual Ref<EventStreamPlayback> instance_playback(); + + virtual String get_stream_name() const; + + virtual float get_length() const; + + virtual int get_channel_count() const { return 64; } //tracker limit + + EventStreamChibi(); +}; + + +class ResourceFormatLoaderChibi : public ResourceFormatLoader { + +public: + virtual RES load(const String &p_path,const String& p_original_path="",Error *r_error=NULL); + virtual void get_recognized_extensions(List<String> *p_extensions) const; + virtual bool handles_type(const String& p_type) const; + virtual String get_resource_type(const String &p_path) const; + +}; + +void initialize_chibi(); +void finalize_chibi(); + +#endif // EVENT_STREAM_CHIBI_H diff --git a/modules/chibi/register_types.cpp b/modules/chibi/register_types.cpp new file mode 100644 index 0000000000..b2ba16fa03 --- /dev/null +++ b/modules/chibi/register_types.cpp @@ -0,0 +1,41 @@ +/*************************************************************************/ +/* register_types.cpp */ +/*************************************************************************/ +/* This file is part of: */ +/* GODOT ENGINE */ +/* http://www.godotengine.org */ +/*************************************************************************/ +/* Copyright (c) 2007-2016 Juan Linietsky, Ariel Manzur. */ +/* */ +/* Permission is hereby granted, free of charge, to any person obtaining */ +/* a copy of this software and associated documentation files (the */ +/* "Software"), to deal in the Software without restriction, including */ +/* without limitation the rights to use, copy, modify, merge, publish, */ +/* distribute, sublicense, and/or sell copies of the Software, and to */ +/* permit persons to whom the Software is furnished to do so, subject to */ +/* the following conditions: */ +/* */ +/* The above copyright notice and this permission notice shall be */ +/* included in all copies or substantial portions of the Software. */ +/* */ +/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */ +/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */ +/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/ +/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */ +/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */ +/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */ +/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ +/*************************************************************************/ +#include "register_types.h" + +#include "event_stream_chibi.h" + +void register_chibi_types() { + + initialize_chibi(); +} + +void unregister_chibi_types() { + + finalize_chibi(); +} diff --git a/modules/chibi/register_types.h b/modules/chibi/register_types.h new file mode 100644 index 0000000000..159823b85d --- /dev/null +++ b/modules/chibi/register_types.h @@ -0,0 +1,30 @@ +/*************************************************************************/ +/* register_types.h */ +/*************************************************************************/ +/* This file is part of: */ +/* GODOT ENGINE */ +/* http://www.godotengine.org */ +/*************************************************************************/ +/* Copyright (c) 2007-2016 Juan Linietsky, Ariel Manzur. */ +/* */ +/* Permission is hereby granted, free of charge, to any person obtaining */ +/* a copy of this software and associated documentation files (the */ +/* "Software"), to deal in the Software without restriction, including */ +/* without limitation the rights to use, copy, modify, merge, publish, */ +/* distribute, sublicense, and/or sell copies of the Software, and to */ +/* permit persons to whom the Software is furnished to do so, subject to */ +/* the following conditions: */ +/* */ +/* The above copyright notice and this permission notice shall be */ +/* included in all copies or substantial portions of the Software. */ +/* */ +/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */ +/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */ +/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/ +/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */ +/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */ +/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */ +/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ +/*************************************************************************/ +void register_chibi_types(); +void unregister_chibi_types(); |