static void show_gui(struct SoundPlugin *plugin){
#if JUCE_LINUX
const MessageManagerLock mmLock;
#endif
Data *data = (Data*)plugin->data;
if (data->window==NULL) {
const char *title = strdup(plugin->patch==NULL ? talloc_format("%s %s",plugin->type->type_name, plugin->type->name) : plugin->patch->name);
data->window = new PluginWindow(title, data);
if (data->x < 0 || data->y < 0)
data->window->centreWithSize (data->window->getWidth(), data->window->getHeight());
else {
data->window->setTopLeftPosition(data->x, data->y);
}
AudioProcessorEditor *editor = data->audio_instance->createEditor(); //IfNeeded();
editor->setName (data->audio_instance->getName());
data->window->setContentOwned(editor, true);
data->window->setUsingNativeTitleBar(true);
}
data->window->setVisible(true);
}
static void Undo_ChipPos(
struct Tracker_Windows *window,
struct WBlocks *wblock,
struct Patch *patch
)
{
struct Undo_ChipPos *undo_ae=talloc(sizeof(struct Undo_ChipPos));
undo_ae->patch = patch;
undo_ae->x = CHIP_get_pos_x(patch);
undo_ae->y = CHIP_get_pos_y(patch);
printf("********* Storing chipos undo. value: %f\n",undo_ae->x);
Undo_Add_dont_stop_playing(
window->l.num,
wblock->l.num,
wblock->wtrack->l.num,
wblock->curr_realline,
undo_ae,
Undo_Do_ChipPos,
talloc_format("Chip position %s",patch->name)
);
}
static const char *chroma_to_string(int chroma){
switch(chroma){
case 0:
return "c";
case 1:
return "c#";
case 2:
return "d";
case 3:
return "d#";
case 4:
return "e";
case 5:
return "f";
case 6:
return "f#";
case 7:
return "g";
case 8:
return "g#";
case 9:
return "a";
case 10:
return "a#";
case 11:
return "b";
default:
return talloc_format("<error: \"%d\" is outside note range>", chroma);
}
}
static const char *octave_to_string(int octave){
switch(octave){
case 0:
return "0";
case 1:
return "1";
case 2:
return "2";
case 3:
return "3";
case 4:
return "4";
case 5:
return "5";
case 6:
return "6";
case 7:
return "7";
case 8:
return "8";
case 9:
return "9";
case 10:
return "a";
case 11:
return "b";
case 12:
return "c";
default:
return talloc_format("<error: \"%d\" is outside octave range>", octave);
}
}
static QColor get_config_qcolor(enum ColorNums colornum){
if (g_config_colors[colornum]!=NULL)
return *g_config_colors[colornum];
QColor col;
const char *colorname = get_color_config(colornum).config_name;
if (colorname==NULL)
return col;
if (!QString(colorname).contains("color"))
colorname = talloc_format("%s_color", colorname);
const char *colorstring = SETTINGS_read_string(colorname, "");
if (strlen(colorstring) <= 1) {
enum ColorNums replacement_colornum = get_replacement_colornum(colornum);
if (replacement_colornum != ILLEGAL_COLOR_NUM)
col = get_config_qcolor(replacement_colornum);
else
col = get_replacement_color(colornum);
} else {
col = QColor(colorstring);
}
g_config_colors[colornum] = new QColor(col);
return col;
}
int main(void){
assert(notenum_from_notetext("") < 0);
assert(notenum_from_notetext("y5") < 0);
assert(notenum_from_notetext("cd") < 0);
assert(notenum_from_notetext("cb0") < 0);
cmp("c0,1",0.01);
cmp("c0,10",0.1);
cmp("c#0",1);
cmp("c#0,99",1.99);
cmp("ga",127);
cmp("ga,99",127.99);
cmp("g-a",127);
cmp("g-a,99",127.99);
cmp("C0,1",0.01);
cmp("C0,10",0.1);
cmp("C#0",1);
cmp("C#0,99",1.99);
cmp("G-A",127);
cmp("G-A,99",127.99);
int cents;
for(cents=0;cents<100;cents++){
char *a = talloc_format("c9,%d",cents);
cmp(a,108.0 + (float)cents/100.0f);
}
printf("Success, no errors\n");
return 0;
}
void GFX_SetBrightness(struct Tracker_Windows *tvisual, float how_much){
EditorWidget *editorwidget=(EditorWidget *)tvisual->os_visual.widget;
if(is_starting_up)
return;
return;
#if 0
float threshold = QColor(SETTINGS_read_string(talloc_format("color%d",15),"#d0d5d0")).valueF();
for(int i=0;i<15;i++){
QColor color = QColor(SETTINGS_read_string(talloc_format("color%d",i),"#d0d5d0"));
//QColor color = editorwidget->colors[i];
float value = color.valueF();
if (value > threshold)
color = color.lighter(scale(how_much, 0, 1, 0, 200));
else
color = color.darker(scale(how_much, 0, 1, 0, 200));
if (i!=11)
setColor((enum ColorNums)i, color.rgb());
printf("value for %d: %f\n",i,value);
//color.setLightntess(lightness
}
#else
how_much = scale(how_much,0,1,-1,1);
for(int i=0;i<16;i++){
QColor color = QColor(SETTINGS_read_string(talloc_format("color%d",i),"#d0d5d0"));
qreal h,s,v,a;
color.getHsvF(&h,&s,&v,&a);
float value = R_BOUNDARIES(0,v+how_much,1);
color.setHsvF(h, s, value, a);
//QColor color = editorwidget->colors[i];
setColor((enum ColorNums)i, color.rgb());
printf("value for %d: %f. s: %f, how_much: %f\n",i,value,s,how_much);
//color.setLightntess(lightness
}
#endif
updateAll(editorwidget);
tvisual->must_redraw = true;
}
wchar_t *FLUIDSYNTH_get_filename_display(struct SoundPlugin *plugin){
Data *data=(Data*)plugin->data;
char *s2 = talloc_format(", b: %d, p: %d", data->bank_num, data->preset_num);
return STRING_append(data->filename,
STRING_create(s2));
}
static struct FX *selectFX(
struct Tracker_Windows *window,
struct WBlocks *wblock,
struct WTracks *wtrack
){
struct Tracks *track = wtrack->track;
struct Patch *patch = track->patch;
if(patch==NULL) {
PATCH_select_patch_for_track(window,wtrack,true);
//GFX_Message(NULL, "No instrument set for track %d\n",wtrack->l.num);
return NULL;
}
struct FX *fx;
int num_usedFX=getNumUsedFX(track);
if(num_usedFX>0){
int lokke;
vector_t v={0};
for(lokke=0;lokke<num_usedFX;lokke++)
VECTOR_push_back(&v,getTrackFX(track,lokke)->name);
#if 0
for(lokke=0;lokke<10000;lokke++)
VECTOR_push_back(&v,talloc_format("extra %d",lokke));
#endif
VECTOR_push_back(&v,"New FX");
int selection=GFX_Menu(window,NULL,"Select FX",&v);
if(selection==-1) return NULL;
if(selection<num_usedFX) return getTrackFX(track,selection);
}
fx=talloc(sizeof(struct FX));
fx->color = newFXColor();
fx->patch = patch;
if(
patch->instrument->getFX(window,track,fx)
==
FX_FAILED
){
return NULL;
}
fx->slider_automation_value = OS_SLIDER_obtain_automation_value_pointer(patch,fx->effect_num);
fx->slider_automation_color = OS_SLIDER_obtain_automation_color_pointer(patch,fx->effect_num);
return fx;
}
char *notetext_from_notenum(float notenumf){
int notenum = notenumf;
int cents = 0;
if (notenumf!=floorf(notenum)){
float decimals = notenumf - floorf(notenum);
printf("___ decimals: %f\n",decimals);
cents = roundf(decimals*100.0f);
}
int octave = notenum / 12;
int chroma = notenum - (octave*12);
printf("************************************************************************** octave: %d, chroma: %d, cents: %d\n",octave,chroma,cents);
char *wholenotestring = talloc_format("%s%s",chroma_to_string(chroma), octave_to_string(octave));
if (cents != 0)
return talloc_format("%s,%d", wholenotestring, cents);
else
return wholenotestring;
}
static void set_plugin_type_data(AudioPluginInstance *audio_instance, SoundPluginType *plugin_type){
TypeData *type_data = (struct TypeData*)plugin_type->data;
if (audio_instance->hasEditor()==false) {
plugin_type->show_gui = NULL;
plugin_type->hide_gui = NULL;
}
plugin_type->num_inputs = audio_instance->getNumInputChannels();
plugin_type->num_outputs = audio_instance->getNumOutputChannels();
plugin_type->plugin_takes_care_of_savable_values = true;
const char *wrapper_info = "";
if (type_data->wrapper_type == AudioProcessor::wrapperType_VST) {
AEffect *aeffect = (AEffect*)audio_instance->getPlatformSpecificData();
{
char vendor[1024] = {0};
aeffect->dispatcher(aeffect, effGetVendorString, 0, 0, vendor, 0.0f);
char product[1024] = {0};
aeffect->dispatcher(aeffect, effGetProductString, 0, 0, product, 0.0f);
if(strlen(vendor)>0 || strlen(product)>0)
wrapper_info = talloc_format("Vendor: %s\nProduct: %s\n",vendor,product);
}
}
plugin_type->info = strdup(talloc_format("%sAccepts MIDI: %s\nProduces MIDI: %s\n",wrapper_info, audio_instance->acceptsMidi()?"Yes":"No", audio_instance->producesMidi()?"Yes":"No"));
plugin_type->is_instrument = audio_instance->acceptsMidi(); // doesn't seem like this field ("is_instrument") is ever read...
plugin_type->num_effects = audio_instance->getNumParameters();
type_data->effect_names = (const char**)calloc(sizeof(char*),plugin_type->num_effects);
for(int i = 0 ; i < plugin_type->num_effects ; i++)
type_data->effect_names[i] = strdup(audio_instance->getParameterName(i).toRawUTF8());
}
static void run_program(QString program, QString arg1, QString arg2, QString arg3, QString arg4, bool wait_until_finished){
#if defined(FOR_WINDOWS)
char *p = strdup(program.toAscii());
char *a1 = strdup(arg1.toAscii());
char *a2 = strdup(arg2.toAscii());
char *a3 = strdup(arg3.toAscii());
char *a4 = strdup(arg4.toAscii());
if(_spawnl(wait_until_finished ? _P_WAIT : _P_DETACH, p, p, a1, a2, a3, a4, NULL)==-1){
fprintf(stderr,"Couldn't launch crashreporter: \"%s\" \"%s\"\n",p,a1);
SYSTEM_show_message(strdup(talloc_format("Couldn't launch crashreporter: \"%s\" \"%s\"\n",p,a1)));
Sleep(3000);
}
#elif defined(FOR_LINUX) || defined(FOR_MACOSX)
//if(system(QString(QCoreApplication::applicationDirPath() + "/crashreporter " + key + " " + QString::number(getpid()) + "&").toAscii())==-1) { // how to fix utf-8 here ?
QString a = "LD_LIBRARY_PATH=" + QString(getenv("LD_LIBRARY_PATH"));
QString full_command = a + " " + program + " " + arg1 + " " + arg2 + " " + arg3 + " " + arg4;
if (wait_until_finished==false)
full_command += "&";
fprintf(stderr, "Executing -%s-\n",full_command.toUtf8().constData());
if(system(strdup(full_command.toUtf8().constData()))==-1) {
SYSTEM_show_message(strdup(talloc_format("Couldn't start crashreporter. command: -%s-\n",full_command.toUtf8().constData())));
}
#else
#error "unknown system"
#endif
}
void CutRange(
struct Blocks *block,
NInt starttrack,
NInt endtrack,
Place *p1,
Place *p2
){
struct Tracks *track;
int lokke;
endtrack = R_MIN(block->num_tracks-1, endtrack);
if (endtrack < starttrack)
return;
track=ListFindElement1(&block->tracks->l,starttrack);
PC_Pause();{
for(lokke=0;lokke<=endtrack-starttrack;lokke++){
CutRange_notes(&track->notes,track->notes,p1,p2);
CutRange_stops(&track->stops,track->stops,p1,p2);
track=NextTrack(track);
if(track==NULL) break;
}
Place *startplace = p1;
Place *endplace = p2;
SCHEME_eval(
talloc_format("(cut-fx-range! %d %d %d (+ %d (/ %d %d)) (+ %d (/ %d %d)))",
block->l.num,
starttrack,
endtrack,
startplace->line, startplace->counter, startplace->dividor,
endplace->line, endplace->counter, endplace->dividor
)
);
}PC_StopPause(NULL);
}
static bool load_sf2_instrument(Data *data, const wchar_t *filename, int preset_bag_number, bool set_loop_on_off){
EVENTLOG_add_event(talloc_format("load_sf2_instrument -%S-", filename));
hash_t *info = SF2_get_info(filename);
if(info==NULL){
GFX_Message(NULL, "Unable to open soundfont file \"%S\"\n", filename);
return false;
}
//HASH_save(info,stdout);
hash_t *sample_infos = HASH_get_hash(info,"samples");
hash_t *presets = HASH_get_hash(info,"presets");
hash_t *preset = HASH_get_hash_at(presets, "", preset_bag_number);
if(preset==NULL){
GFX_Message(NULL, "No such preset number %d in instrument \"%S\"\n", preset_bag_number, filename);
return false;
}
int bank_num = HASH_get_int32(preset,"bank");
hash_t *instrument = NULL;
// Try to find an instrument from the region. A preset may use several instruments, but that's not supported yet. We just use the first and best/worst.
{
hash_t *instruments = HASH_get_hash(info,"instruments");
hash_t *regions = HASH_get_hash(preset,"regions");
int i;
for(i=0;i<HASH_get_array_size(regions, "");i++){
hash_t *region = HASH_get_hash_at(regions,"",i);
if(HASH_has_key(region,"instrument")==true){
instrument = HASH_get_hash(instruments,HASH_get_chars(region,"instrument"));
break;
}
}
}
if(instrument==NULL){
GFX_Message(NULL, "load_sf2_instrument: Preset \"%S\" (bank %d / preset %d) in \"%S\" doesn't point to an instrument\n",
HASH_get_string(preset,"name"), bank_num, HASH_get_int32(preset,"num"), filename
);
return false;
}
hash_t *regions = HASH_get_hash(instrument, "regions");
for(int i=0;i<128;i++){
Note *note = new Note;
data->notes[i] = note;
data->note_storage.push_back(note);
}
int num_samples=0;
int i;
for(i=0;i<HASH_get_array_size(regions, "");i++){
hash_t *region = HASH_get_hash_at(regions,"",i);
const char *sample_name = HASH_get_chars(region, "sample_name");
if(strcmp(sample_name,"<no sample!>")){
hash_t *sample_info = HASH_get_hash(sample_infos, sample_name);
int sample_num = HASH_get_int32(sample_info,"num");
Sample &sample = data->samples[num_samples++];
new (&sample) Sample();
sample.data = data;
sample.volume = 1.0f;
sample.num_frames = HASH_get_int(sample_info,"num_frames");
set_legal_loop_points(sample,-1,-1, set_loop_on_off); // By default, loop all.
set_legal_loop_points(sample,
HASH_get_int(sample_info,"loop start"),
HASH_get_int(sample_info,"loop end"),
set_loop_on_off
);
printf("Loop start / end: %d %d\n",(int)sample.loop_start,(int)sample.loop_end);
{
sample.ch = -1;
const char *type = HASH_get_chars(sample_info,"type");
if(!strcmp(type,"Left Sample") || !strcmp(type,"ROM Left Sample"))
sample.ch = 0;
if(!strcmp(type,"Right Sample") || !strcmp(type,"ROM Right Sample"))
sample.ch = 1;
}
sample.sound = SF2_load_sample(filename, sample_num);
int root_key = HASH_get_int32(region, "root key");
int coarsetune = HASH_get_int32(region, "coarse tune");
int finetune = HASH_get_int32(region, "fine tune");
printf("root: %d, coarse: %d, fine: %d, sample pitch: %d\n",root_key,coarsetune,finetune,(int)HASH_get_int(sample_info,"pitch"));
int note;
for(note=0;note<128;note++)
if(HASH_get_int(sample_info,"pitch")==255)
sample.frequency_table[note] = HASH_get_int(sample_info, "samplerate");
else
sample.frequency_table[note] = HASH_get_int(sample_info, "samplerate") * midi_to_hz(note+coarsetune+(float)finetune/100.0) / midi_to_hz(root_key);
int note_num;
for(note_num=HASH_get_int32(region,"key start");note_num<=HASH_get_int32(region,"key end");note_num++){
Note *note = const_cast<Note*>(data->notes[note_num]);
note->samples.push_back(&sample);
//printf("%d: %f. middle_note: %d, finetune: %f. Sample: %p. Frequency: %f\n",i,dest->ratio,dest->middle_note,dest->finetune,dest->interleaved_samples,get_frequency(i,dest->finetune));
}
}
}
// Optimize data->notes so that as few Note objects as possible are used (better for cache)
for(int i=0;i<128;i++){
Note *old_note = const_cast<Note*>(data->notes[i]);
old_note->sort_samples();
for(int i2=0;i2<i;i2++){
if(data->notes[i]->is_equal(data->notes[i2])){
data->notes[i] = data->notes[i2];
data->note_storage.remove(old_note);
delete old_note;
printf(" Load SF2: Move notes %d to %d. Size of note_storage: %d\n", i, i2, data->note_storage.size());
break;
}
}
}
return true;
}
