path: root/drivers/chibi/cp_player_data.h

/*************************************************************************/
/*  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