virtualx-engine/modules/chibi/cp_pattern.cpp

/*************************************************************************/
/*  cp_pattern.cpp                                                       */
/*************************************************************************/
/*                       This file is part of:                           */
/*                           GODOT ENGINE                                */
/*                    http://www.godotengine.org                         */
/*************************************************************************/
/* Copyright (c) 2007-2017 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();
}