#include "mustang.h"
#include <iostream>

Mustang::Mustang()
{
    amp_hand = NULL;

    // "apply efect" command
    memset(execute, 0x00, LENGTH);
    execute[0] = 0x1c;
    execute[1] = 0x03;

    memset(prev_array, 0x00, LENGTH*4);
    for(int i = 0; i < 4; i++)
    {
        prev_array[i][0] = 0x1c;
        prev_array[i][1] = 0x03;
        prev_array[i][6] = prev_array[i][7] = prev_array[i][21] = 0x01;
        prev_array[i][20] = 0x08;
        prev_array[i][FXSLOT] = 0xff;
    }
}

Mustang::~Mustang()
{
    this->stop_amp();
}

int Mustang::start_amp(char list[][32], char *name, struct amp_settings *amp_set, struct fx_pedal_settings *effects_set)
{
    int ret, received;
    unsigned char array[LENGTH];
    unsigned char received_data[296][LENGTH], data[7][LENGTH];
    memset(received_data, 0x00, 296*LENGTH);

    if(amp_hand == NULL)
    {
        // initialize libusb
        ret = libusb_init(NULL);
        if (ret)
            return ret;

        // get handle for the device
        if((amp_hand = libusb_open_device_with_vid_pid(NULL, USB_VID, OLD_USB_PID)) == NULL)
            if((amp_hand = libusb_open_device_with_vid_pid(NULL, USB_VID, NEW_USB_PID)) == NULL)
                if((amp_hand = libusb_open_device_with_vid_pid(NULL, USB_VID, V2_USB_PID)) == NULL)
                  if((amp_hand = libusb_open_device_with_vid_pid(NULL, USB_VID, MINI_USB_PID)) == NULL)
                    if((amp_hand = libusb_open_device_with_vid_pid(NULL, USB_VID, FLOOR_USB_PID)) == NULL)
                        if((amp_hand = libusb_open_device_with_vid_pid(NULL, USB_VID, BRONCO40_USB_PID)) == NULL)
                          if((amp_hand = libusb_open_device_with_vid_pid(NULL, USB_VID, V2_III_PID)) == NULL)
                            if((amp_hand = libusb_open_device_with_vid_pid(NULL, USB_VID, V2_IV_PID)) == NULL)
                    {
                      libusb_exit(NULL);
                      return -100;
                    }

        // detach kernel driver
        ret = libusb_kernel_driver_active(amp_hand, 0);
        if(ret)
        {
            ret = libusb_detach_kernel_driver(amp_hand, 0);
            if(ret)
            {
                stop_amp();
                return ret;
            }
        }

        // claim the device
        ret = libusb_claim_interface(amp_hand, 0);
        if(ret)
        {
            stop_amp();
            return ret;
        }
    }

    // initialization which is needed if you want
    // to get any replies from the amp in the future
    memset(array, 0x00, LENGTH);
    array[1] = 0xc3;
    libusb_interrupt_transfer(amp_hand, 0x01, array, LENGTH, &received, TMOUT);
    libusb_interrupt_transfer(amp_hand, 0x81, array, LENGTH, &received, TMOUT);

    memset(array, 0x00, LENGTH);
    array[0] = 0x1a;
    array[1] = 0x03;
    libusb_interrupt_transfer(amp_hand, 0x01, array, LENGTH, &received, TMOUT);
    libusb_interrupt_transfer(amp_hand, 0x81, array, LENGTH, &received, TMOUT);

    if(list != NULL || name != NULL || amp_set != NULL || effects_set != NULL)
    {
        int i = 0, j = 0;
        memset(array, 0x00, LENGTH);
        array[0] = 0xff;
        array[1] = 0xc1;
        libusb_interrupt_transfer(amp_hand, 0x01, array, LENGTH, &received, TMOUT);

        for(i = 0; received; i++)
        {
            libusb_interrupt_transfer(amp_hand, 0x81, array, LENGTH, &received, TMOUT);
            memcpy(received_data[i], array, LENGTH);
        }

        int max_to_receive;
        i > 143 ? max_to_receive = 200 : max_to_receive = 48;
        if(list != NULL)
            for(i = 0, j = 0; i<max_to_receive; i+=2, j++)
                memcpy(list[j], received_data[i]+16, 32);

        if(name != NULL || amp_set != NULL || effects_set != NULL)
        {
            for(j = 0; j < 7; i++, j++)
                memcpy(data[j], received_data[i], LENGTH);
            decode_data(data, name, amp_set, effects_set);
        }
    }

    return 0;
}

int Mustang::stop_amp()
{
    int ret;

    if(amp_hand != NULL)
    {
        // release claimed interface
        ret = libusb_release_interface(amp_hand, 0);
        if(ret && (ret != LIBUSB_ERROR_NO_DEVICE))
            return ret;

        if(ret != LIBUSB_ERROR_NO_DEVICE)
        {
            // re-attach kernel driver
            ret = libusb_attach_kernel_driver(amp_hand, 0);
            if(ret)
                return ret;
        }

        // close opened interface
        libusb_close(amp_hand);
        amp_hand = NULL;

        // stop using libusb
        libusb_exit(NULL);
    }

    return 0;
}

int Mustang::set_effect(struct fx_pedal_settings value)
{
    int ret, received;    // variables used when sending
    unsigned char slot;    // where to put the effect
    unsigned char temp[LENGTH], array[LENGTH] = {
        0x1c, 0x03, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
    };

    // clear effect on previous DSP before setting a new one
    int k=0;
    for (int i = 0; i < 4; i++)
    {
        if (prev_array[i][FXSLOT] == value.fx_slot || prev_array[i][FXSLOT] == (value.fx_slot+4))
        {
            memcpy(array, prev_array[i], LENGTH);
            prev_array[i][FXSLOT] = 0xff;
            k++;
            break;
        }
    }
    array[EFFECT] = 0x00;
    array[KNOB1] = 0x00;
    array[KNOB2] = 0x00;
    array[KNOB3] = 0x00;
    array[KNOB4] = 0x00;
    array[KNOB5] = 0x00;
    array[KNOB6] = 0x00;
    ret = libusb_interrupt_transfer(amp_hand, 0x01, array, LENGTH, &received, TMOUT);
    libusb_interrupt_transfer(amp_hand, 0x81, temp, LENGTH, &received, TMOUT);
    ret = libusb_interrupt_transfer(amp_hand, 0x01, execute, LENGTH, &received, TMOUT);
    libusb_interrupt_transfer(amp_hand, 0x81, temp, LENGTH, &received, TMOUT);
    //DEBUG
//    qDebug("set: DSP: %d, slot: %d, effect: %d, EMPTY", array[DSP], array[FXSLOT], array[EFFECT]);
    if(value.effect_num == EMPTY)
        return ret;

    if(value.put_post_amp)    // put effect in a slot after amplifier
        slot = value.fx_slot + 4;
    else
        slot = value.fx_slot;

    // fill the form with data
    array[FXSLOT] = slot;
    array[KNOB1] = value.knob1;
    array[KNOB2] = value.knob2;
    array[KNOB3] = value.knob3;
    array[KNOB4] = value.knob4;
    array[KNOB5] = value.knob5;
    // some effects have more knobs
    if (value.effect_num == MONO_ECHO_FILTER ||
            value.effect_num == STEREO_ECHO_FILTER ||
            value.effect_num == TAPE_DELAY ||
            value.effect_num == STEREO_TAPE_DELAY)
    {
        array[KNOB6] = value.knob6;
    }

    // fill the form with missing data
    switch (value.effect_num) {
    case OVERDRIVE:
        array[DSP] = 0x06;
        array[EFFECT] = 0x3c;
        break;

    case WAH:
        array[DSP] = 0x06;
        array[EFFECT] = 0x49;
        array[19] = 0x01;
        break;

    case TOUCH_WAH:
        array[DSP] = 0x06;
        array[EFFECT] = 0x4a;
        array[19] = 0x01;
        break;

    case FUZZ:
        array[DSP] = 0x06;
        array[EFFECT] = 0x1a;
        break;

    case FUZZ_TOUCH_WAH:
        array[DSP] = 0x06;
        array[EFFECT] = 0x1c;
        break;

    case SIMPLE_COMP:
        array[DSP] = 0x06;
        array[EFFECT] = 0x88;
        array[19] = 0x08;
        if(array[KNOB1] > 0x03)
        {
            array[KNOB1] = 0x03;
        }
        array[KNOB2] = 0x00;
        array[KNOB3] = 0x00;
        array[KNOB4] = 0x00;
        array[KNOB5] = 0x00;
        break;

    case COMPRESSOR:
        array[DSP] = 0x06;
        array[EFFECT] = 0x07;
        break;

    case SINE_CHORUS:
        array[DSP] = 0x07;
        array[EFFECT] = 0x12;
        array[19] = 0x01;
        array[20] = 0x01;
        break;

    case TRIANGLE_CHORUS:
        array[DSP] = 0x07;
        array[EFFECT] = 0x13;
        array[19] = 0x01;
        array[20] = 0x01;
        break;

    case SINE_FLANGER:
        array[DSP] = 0x07;
        array[EFFECT] = 0x18;
        array[19] = 0x01;
        array[20] = 0x01;
        break;

    case TRIANGLE_FLANGER:
        array[DSP] = 0x07;
        array[EFFECT] = 0x19;
        array[19] = 0x01;
        array[20] = 0x01;
        break;

    case VIBRATONE:
        array[DSP] = 0x07;
        array[EFFECT] = 0x2d;
        array[19] = 0x01;
        array[20] = 0x01;
        break;

    case VINTAGE_TREMOLO:
        array[DSP] = 0x07;
        array[EFFECT] = 0x40;
        array[19] = 0x01;
        array[20] = 0x01;
        break;

    case SINE_TREMOLO:
        array[DSP] = 0x07;
        array[EFFECT] = 0x41;
        array[19] = 0x01;
        array[20] = 0x01;
        break;

    case RING_MODULATOR:
        array[DSP] = 0x07;
        array[EFFECT] = 0x22;
        array[19] = 0x01;
        if(array[KNOB4] > 0x01)
        {
            array[KNOB4] = 0x01;
        }
        break;

    case STEP_FILTER:
        array[DSP] = 0x07;
        array[EFFECT] = 0x29;
        array[19] = 0x01;
        array[20] = 0x01;
        break;

    case PHASER:
        array[DSP] = 0x07;
        array[EFFECT] = 0x4f;
        array[19] = 0x01;
        array[20] = 0x01;
        if(array[KNOB5] > 0x01)
        {
            array[KNOB5] = 0x01;
        }
        break;

    case PITCH_SHIFTER:
        array[DSP] = 0x07;
        array[EFFECT] = 0x1f;
        array[19] = 0x01;
        break;

    case MONO_DELAY:
        array[DSP] = 0x08;
        array[EFFECT] = 0x16;
        array[19] = 0x02;
        array[20] = 0x01;
        break;

    case MONO_ECHO_FILTER:
        array[DSP] = 0x08;
        array[EFFECT] = 0x43;
        array[19] = 0x02;
        array[20] = 0x01;
        break;

    case STEREO_ECHO_FILTER:
        array[DSP] = 0x08;
        array[EFFECT] = 0x48;
        array[19] = 0x02;
        array[20] = 0x01;
        break;

    case MULTITAP_DELAY:
        array[DSP] = 0x08;
        array[EFFECT] = 0x44;
        array[19] = 0x02;
        array[20] = 0x01;
        if(array[KNOB5] > 0x03)
        {
            array[KNOB5] = 0x03;
        }
        break;

    case PING_PONG_DELAY:
        array[DSP] = 0x08;
        array[EFFECT] = 0x45;
        array[19] = 0x02;
        array[20] = 0x01;
        break;

    case DUCKING_DELAY:
        array[DSP] = 0x08;
        array[EFFECT] = 0x15;
        array[19] = 0x02;
        array[20] = 0x01;
        break;

    case REVERSE_DELAY:
        array[DSP] = 0x08;
        array[EFFECT] = 0x46;
        array[19] = 0x02;
        array[20] = 0x01;
        break;

    case TAPE_DELAY:
        array[DSP] = 0x08;
        array[EFFECT] = 0x2b;
        array[19] = 0x02;
        array[20] = 0x01;
        break;

    case STEREO_TAPE_DELAY:
        array[DSP] = 0x08;
        array[EFFECT] = 0x2a;
        array[19] = 0x02;
        array[20] = 0x01;
        break;

    case SMALL_HALL_REVERB:
        array[DSP] = 0x09;
        array[EFFECT] = 0x24;
        break;

    case LARGE_HALL_REVERB:
        array[DSP] = 0x09;
        array[EFFECT] = 0x3a;
        break;

    case SMALL_ROOM_REVERB:
        array[DSP] = 0x09;
        array[EFFECT] = 0x26;
        break;

    case LARGE_ROOM_REVERB:
        array[DSP] = 0x09;
        array[EFFECT] = 0x3b;
        break;

    case SMALL_PLATE_REVERB:
        array[DSP] = 0x09;
        array[EFFECT] = 0x4e;
        break;

    case LARGE_PLATE_REVERB:
        array[DSP] = 0x09;
        array[EFFECT] = 0x4b;
        break;

    case AMBIENT_REVERB:
        array[DSP] = 0x09;
        array[EFFECT] = 0x4c;
        break;

    case ARENA_REVERB:
        array[DSP] = 0x09;
        array[EFFECT] = 0x4d;
        break;

    case FENDER_63_SPRING_REVERB:
        array[DSP] = 0x09;
        array[EFFECT] = 0x21;
        break;

    case FENDER_65_SPRING_REVERB:
        array[DSP] = 0x09;
        array[EFFECT] = 0x0b;
        break;
    }

    // send packet to the amp
    ret = libusb_interrupt_transfer(amp_hand, 0x01, array, LENGTH, &received, TMOUT);
    libusb_interrupt_transfer(amp_hand, 0x81, temp, LENGTH, &received, TMOUT);
    ret = libusb_interrupt_transfer(amp_hand, 0x01, execute, LENGTH, &received, TMOUT);
    libusb_interrupt_transfer(amp_hand, 0x81, temp, LENGTH, &received, TMOUT);
    //DEBUG
//    qDebug("set: DSP: %d, slot: %d, effect: %d", array[DSP], array[FXSLOT], array[EFFECT]);

    // save current settings
    memcpy(prev_array[array[DSP]-6], array, LENGTH);


    //DEBUG
//    FILE *f;
//    static char trynum=0;
//    char mes[16];
//    sprintf(mes, "test%d.bin",trynum);
//    f=fopen(mes,"w");
//    fwrite(array, sizeof(array), 1, f);
//    //fwrite(execute, sizeof(execute), 1, f);
//    fclose(f);
//    trynum++;


    return ret;
}

int Mustang::effect_toggle(int category, int state)
{
    int ret, received;
    unsigned char array[LENGTH];

    memset(array, 0x00, LENGTH);
    array[0] = 0x19;
    array[1] = 0xc3;
    // Translate DSP to internal effect category 
    array[2] = prev_array[category][DSP] - 3;
    array[3] = state;
    array[FXSLOT] = prev_array[category][FXSLOT];
    
    ret = libusb_interrupt_transfer(amp_hand, 0x01, array, LENGTH, &received, TMOUT);
    // flush reply data
    for (int i=0; received; i++) {
        libusb_interrupt_transfer(amp_hand, 0x81, array, LENGTH, &received, TMOUT);
    }

    return ret;
}


int Mustang::set_amplifier(struct amp_settings value)
{
    int ret, received;
    unsigned char array[LENGTH] = {
        0x1c, 0x03, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
        0xaa, 0xa2, 0x80, 0x63, 0x99, 0x80, 0xb0, 0x00,
        0x80, 0x80, 0x80, 0x80, 0x07, 0x07, 0x07, 0x05,
        0x00, 0x07, 0x07, 0x01, 0x00, 0x01, 0x5e, 0x00,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
    };

    array[DSP] = 0x05;
    array[GAIN] = value.gain;
    array[VOLUME] = value.volume;
    array[TREBLE] = value.treble;
    array[MIDDLE] = value.middle;
    array[BASS] = value.bass;

    if(value.cabinet > 0x0c)
        array[CABINET] = 0x00;
    else
        array[CABINET] = value.cabinet;

    if(value.noise_gate > 0x05)
        array[NOISE_GATE] = 0x00;
    else
        array[NOISE_GATE] = value.noise_gate;

    array[MASTER_VOL] = value.master_vol;
    array[GAIN2] = value.gain2;
    array[PRESENCE] = value.presence;

    if(value.noise_gate == 0x05)
    {
        if(value.threshold > 0x09)
            array[THRESHOLD] = 0x00;
        else
            array[THRESHOLD] = value.threshold;

        array[DEPTH] = value.depth;
    }
    array[BIAS] = value.bias;

    if(value.sag > 0x02)
        array[SAG] = 0x01;
    else
        array[SAG] = value.sag;

    array[BRIGHTNESS] = value.brightness?1:0;

    switch (value.amp_num)
    {
    case STUDIO_PREAMP:
        array[AMPLIFIER] = 0xf1;
        array[44] = array[45] = array[46] = 0x0d;
        array[50] = 0x0d;
        array[54] = 0xf6;
        break;

    case FENDER_57_CHAMP:
        array[AMPLIFIER] = 0x7c;
        array[44] = array[45] = array[46] = 0x0c;
        array[50] = 0x0c;
        array[54] = 0x00;
        break;

     case FENDER_57_DELUXE:
        array[AMPLIFIER] = 0x67;
        array[44] = array[45] = array[46] = 0x01;
        array[50] = 0x01;
        array[54] = 0x53;
        break;

    case FENDER_57_TWIN:
       array[AMPLIFIER] = 0xf6;
       array[44] = array[45] = array[46] = 0x0e;
       array[50] = 0x0e;
       array[54] = 0xf9;
       break;

    case FENDER_59_BASSMAN:
        array[AMPLIFIER] = 0x64;
        array[44] = array[45] = array[46] = 0x02;
        array[50] = 0x02;
        array[54] = 0x67;
        break;

    case FENDER_65_PRINCETON:
        array[AMPLIFIER] = 0x6a;
        array[44] = array[45] = array[46] = 0x04;
        array[50] = 0x04;
        array[54] = 0x61;
        break;

    case FENDER_65_DELUXE_REVERB:
        array[AMPLIFIER] = 0x53;
        array[40] = array[43] = 0x00;
        array[44] = array[45] = array[46] = 0x03;
        array[50] = 0x03;
        array[54] = 0x6a;
        break;

    case FENDER_65_TWIN_REVERB:
        array[AMPLIFIER] = 0x75;
        array[44] = array[45] = array[46] = 0x05;
        array[50] = 0x05;
        array[54] = 0x72;
        break;

    case S60S_THRIFT:
        array[AMPLIFIER] = 0xf9;
        array[44] = array[45] = array[46] = 0x0f;
        array[50] = 0x0f;
        array[54] = 0xfc;
        break;

    case BRITISH_WATTS:
        array[AMPLIFIER] = 0xff;
        array[44] = array[45] = array[46] = 0x11;
        array[50] = 0x11;
        array[54] = 0x00;
        break;

    case BRITISH_60S:
        array[AMPLIFIER] = 0x61;
        array[44] = array[45] = array[46] = 0x07;
        array[50] = 0x07;
        array[54] = 0x5e;
        break;

    case BRITISH_70S:
        array[AMPLIFIER] = 0x79;
        array[44] = array[45] = array[46] = 0x0b;
        array[50] = 0x0b;
        array[54] = 0x7c;
        break;

    case BRITISH_80S:
        array[AMPLIFIER] = 0x5e;
        array[44] = array[45] = array[46] = 0x09;
        array[50] = 0x09;
        array[54] = 0x5d;
        break;
    case BRITISH_COLOUR:
        array[AMPLIFIER] = 0xfc;
        array[44] = array[45] = array[46] = 0x10;
        array[50] = 0x10;
        array[54] = 0xff;
        break;

    case FENDER_SUPER_SONIC:
        array[AMPLIFIER] = 0x72;
        array[44] = array[45] = array[46] = 0x06;
        array[50] = 0x06;
        array[54] = 0x79;
        break;

    case AMERICAN_90S:
        array[AMPLIFIER] = 0x5d;
        array[44] = array[45] = array[46] = 0x0a;
        array[50] = 0x0a;
        array[54] = 0x6d;
        break;

    case METAL_2000:
        array[AMPLIFIER] = 0x6d;
        array[44] = array[45] = array[46] = 0x08;
        array[50] = 0x08;
        array[54] = 0x75;
        break;


    }

    ret = libusb_interrupt_transfer(amp_hand, 0x01, array, LENGTH, &received, TMOUT);
    libusb_interrupt_transfer(amp_hand, 0x81, array, LENGTH, &received, TMOUT);
    ret = libusb_interrupt_transfer(amp_hand, 0x01, execute, LENGTH, &received, TMOUT);
    libusb_interrupt_transfer(amp_hand, 0x81, array, LENGTH, &received, TMOUT);

    memset(array, 0x00, LENGTH);
    array[0] = 0x1c;
    array[1] = 0x03;
    array[2] = 0x0d;
    array[6] = 0x01;
    array[7] = 0x01;
    array[16] = value.usb_gain;

    ret = libusb_interrupt_transfer(amp_hand, 0x01, array, LENGTH, &received, TMOUT);
    libusb_interrupt_transfer(amp_hand, 0x81, array, LENGTH, &received, TMOUT);
    ret = libusb_interrupt_transfer(amp_hand, 0x01, execute, LENGTH, &received, TMOUT);
    libusb_interrupt_transfer(amp_hand, 0x81, array, LENGTH, &received, TMOUT);

    return ret;
}

int Mustang::save_on_amp(char *name, int slot)
{
    int ret, received;
    unsigned char array[LENGTH];

    memset(array, 0x00, LENGTH);
    array[0] = 0x1c;
    array[1] = 0x01;
    array[2] = 0x03;
    array[SAVE_SLOT] = slot;
    array[6] = 0x01;
    array[7] = 0x01;

    if(strlen(name) > 31)
        name[31] = 0x00;

    for(unsigned int i = 16, j = 0; name[j] != 0x00; i++,j++)
        array[i] = name[j];

    ret = libusb_interrupt_transfer(amp_hand, 0x01, array, LENGTH, &received, TMOUT);
    libusb_interrupt_transfer(amp_hand, 0x81, array, LENGTH, &received, TMOUT);
    load_memory_bank(slot, NULL, NULL, NULL);

    return ret;
}

int Mustang::load_memory_bank(int slot, char *name, struct amp_settings *amp_set, struct fx_pedal_settings *effects_set)
{
    int ret, received;
    unsigned char array[LENGTH], data[7][LENGTH];

    memset(array, 0x00, LENGTH);
    array[0] = 0x1c;
    array[1] = 0x01;
    array[2] = 0x01;
    array[SAVE_SLOT] = slot;
    array[6] = 0x01;

    ret = libusb_interrupt_transfer(amp_hand, 0x01, array, LENGTH, &received, TMOUT);

    for(int i = 0; received; i++) {
        libusb_interrupt_transfer(amp_hand, 0x81, array, LENGTH, &received, TMOUT);
        if(i < 7)
            memcpy(data[i], array, LENGTH);
    }

    if(name != NULL || amp_set != NULL || effects_set != NULL)
        decode_data(data, name, amp_set, effects_set);

    return ret;
}

int Mustang::decode_data(unsigned char data[6][LENGTH], char *name, struct amp_settings *amp_set, struct fx_pedal_settings *effects_set)
{
    if(name != NULL)
    {
        // NAME
        memset(name, 0x00, 32);
        for(int i = 0, j = 16; data[0][j] != 0x00; i++, j++)
            name[i] = data[0][j];
    }


    if(amp_set != NULL)
    {
        // AMPLIFIER
        switch(data[1][AMPLIFIER])
        {
        case 0xf1:
            amp_set->amp_num = STUDIO_PREAMP;
            break;

        case 0x7c:
            amp_set->amp_num = FENDER_57_CHAMP;
            break;

        case 0x67:
            amp_set->amp_num = FENDER_57_DELUXE;
            break;

        case 0xf6:
            amp_set->amp_num = FENDER_57_TWIN;
            break;

        case 0x64:
            amp_set->amp_num = FENDER_59_BASSMAN;
            break;

        case 0x6a:
            amp_set->amp_num = FENDER_65_PRINCETON;
            break;

        case 0x53:
            amp_set->amp_num = FENDER_65_DELUXE_REVERB;
            break;

        case 0x75:
            amp_set->amp_num = FENDER_65_TWIN_REVERB;
            break;

        case 0xf9:
            amp_set->amp_num = S60S_THRIFT;
            break;

        case 0xff:
            amp_set->amp_num = BRITISH_WATTS;
            break;

        case 0x61:
            amp_set->amp_num = BRITISH_60S;
            break;

        case 0x79:
            amp_set->amp_num = BRITISH_70S;
            break;

        case 0x5e:
            amp_set->amp_num = BRITISH_80S;
            break;

        case 0xfc:
            amp_set->amp_num = BRITISH_COLOUR;
            break;

        case 0x72:
            amp_set->amp_num = FENDER_SUPER_SONIC;
            break;

        case 0x5d:
            amp_set->amp_num = AMERICAN_90S;
            break;

        case 0x6d:
            amp_set->amp_num = METAL_2000;
            break;

        default:
            amp_set->amp_num = STUDIO_PREAMP;
            break;
        }
        //                    STUDIO_PREAMP,
        //                    FENDER_57_CHAMP,
        //                    FENDER_57_DELUXE,
        //                    FENDER_57_TWIN,
        //                    FENDER_59_BASSMAN,
        //                    FENDER_65_PRINCETON,
        //                    FENDER_65_DELUXE_REVERB,
        //                    FENDER_65_TWIN_REVERB,
        //                    S60S_THRIFT,
        //                    BRITISH_WATTS,
        //                    BRITISH_60S,
        //                    BRITISH_70S,
        //                    BRITISH_80S,
        //                    BRITISH_COLOUR,
        //                    FENDER_SUPER_SONIC,
        //                    AMERICAN_90S,
        //                    METAL_2000

        amp_set->gain = data[1][GAIN];
        amp_set->volume = data[1][VOLUME];
        amp_set->treble = data[1][TREBLE];
        amp_set->middle = data[1][MIDDLE];
        amp_set->bass = data[1][BASS];
        amp_set->cabinet = data[1][CABINET];
        amp_set->noise_gate = data[1][NOISE_GATE];
        amp_set->master_vol = data[1][MASTER_VOL];
        amp_set->gain2 = data[1][GAIN2];
        amp_set->presence = data[1][PRESENCE];
        amp_set->threshold = data[1][THRESHOLD];
        amp_set->depth = data[1][DEPTH];
        amp_set->bias = data[1][BIAS];
        amp_set->sag = data[1][SAG];
        amp_set->brightness = data[1][BRIGHTNESS]?true:false;
        amp_set->usb_gain = data[6][16];
    }


    if(effects_set != NULL)
    {
        // EFFECTS
        for(int i = 2; i < 6; i++)
        {
            int j=0;

            prev_array[data[i][DSP]-6][0] = 0x1c;
            prev_array[data[i][DSP]-6][1] = 0x03;
            prev_array[data[i][DSP]-6][FXSLOT] = data[i][FXSLOT];
            prev_array[data[i][DSP]-6][DSP] = data[i][DSP];
            prev_array[data[i][DSP]-6][19] = data[i][19];
            prev_array[data[i][DSP]-6][20] = data[i][20];

            switch(data[i][FXSLOT])
            {
            case 0x00:
            case 0x04:
                j = 0;
                break;

            case 0x01:
            case 0x05:
                j = 1;
                break;

            case 0x02:
            case 0x06:
                j = 2;
                break;

            case 0x03:
            case 0x07:
                j = 3;
                break;

            default:
                j=0;
                break;
            }

            effects_set[j].fx_slot = j;
            effects_set[j].knob1 = data[i][KNOB1];
            effects_set[j].knob2 = data[i][KNOB2];
            effects_set[j].knob3 = data[i][KNOB3];
            effects_set[j].knob4 = data[i][KNOB4];
            effects_set[j].knob5 = data[i][KNOB5];
            effects_set[j].knob6 = data[i][KNOB6];
            if(data[i][FXSLOT] > 0x03)
                effects_set[j].put_post_amp = true;
            else
                effects_set[j].put_post_amp = false;

            switch(data[i][EFFECT])
            {
            case 0x00:
                effects_set[j].effect_num = EMPTY;
                break;

            case 0x3c:
                effects_set[j].effect_num =  OVERDRIVE;
                break;

            case 0x49:
                effects_set[j].effect_num = WAH;
                break;

            case 0x4a:
                effects_set[j].effect_num = TOUCH_WAH;
                break;

            case 0x1a:
                effects_set[j].effect_num = FUZZ;
                break;

            case 0x1c:
                effects_set[j].effect_num = FUZZ_TOUCH_WAH;
                break;

            case 0x88:
                effects_set[j].effect_num = SIMPLE_COMP;
                break;

            case 0x07:
                effects_set[j].effect_num = COMPRESSOR;
                break;

            case 0x12:
                effects_set[j].effect_num = SINE_CHORUS;
                break;

            case 0x13:
                effects_set[j].effect_num = TRIANGLE_CHORUS;
                break;

            case 0x18:
                effects_set[j].effect_num = SINE_FLANGER;
                break;

            case 0x19:
                effects_set[j].effect_num = TRIANGLE_FLANGER;
                break;

            case 0x2d:
                effects_set[j].effect_num = VIBRATONE;
                break;

            case 0x40:
                effects_set[j].effect_num = VINTAGE_TREMOLO;
                break;

            case 0x41:
                effects_set[j].effect_num = SINE_TREMOLO;
                break;

            case 0x22:
                effects_set[j].effect_num = RING_MODULATOR;
                break;

            case 0x29:
                effects_set[j].effect_num = STEP_FILTER;
                break;

            case 0x4f:
                effects_set[j].effect_num = PHASER;
                break;

            case 0x1f:
                effects_set[j].effect_num = PITCH_SHIFTER;
                break;

            case 0x16:
                effects_set[j].effect_num = MONO_DELAY;
                break;

            case 0x43:
                effects_set[j].effect_num = MONO_ECHO_FILTER;
                break;

            case 0x48:
                effects_set[j].effect_num = STEREO_ECHO_FILTER;
                break;

            case 0x44:
                effects_set[j].effect_num = MULTITAP_DELAY;
                break;

            case 0x45:
                effects_set[j].effect_num = PING_PONG_DELAY;
                break;

            case 0x15:
                effects_set[j].effect_num = DUCKING_DELAY;
                break;

            case 0x46:
                effects_set[j].effect_num = REVERSE_DELAY;
                break;

            case 0x2b:
                effects_set[j].effect_num = TAPE_DELAY;
                break;

            case 0x2a:
                effects_set[j].effect_num = STEREO_TAPE_DELAY;
                break;

            case 0x24:
                effects_set[j].effect_num = SMALL_HALL_REVERB;
                break;

            case 0x3a:
                effects_set[j].effect_num = LARGE_HALL_REVERB;
                break;

            case 0x26:
                effects_set[j].effect_num = SMALL_ROOM_REVERB;
                break;

            case 0x3b:
                effects_set[j].effect_num = LARGE_ROOM_REVERB;
                break;

            case 0x4e:
                effects_set[j].effect_num = SMALL_PLATE_REVERB;
                break;

            case 0x4b:
                effects_set[j].effect_num = LARGE_PLATE_REVERB;
                break;

            case 0x4c:
                effects_set[j].effect_num = AMBIENT_REVERB;
                break;

            case 0x4d:
                effects_set[j].effect_num = ARENA_REVERB;
                break;

            case 0x21:
                effects_set[j].effect_num = FENDER_63_SPRING_REVERB;
                break;

            case 0x0b:
                effects_set[j].effect_num = FENDER_65_SPRING_REVERB;
                break;

            default:
                effects_set[j].effect_num = EMPTY;
                break;
            }
        }
    }

    return 0;
}

int Mustang::save_effects(int slot, char name[24], int number_of_effects, struct fx_pedal_settings effects[2])
{
    int ret, received;
    unsigned char fxknob, repeat;
    unsigned char temp[LENGTH], array[LENGTH] = {
        0x1c, 0x01, 0x04, 0x00, 0x00, 0x00, 0x01, 0x01,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
    };
    execute[2]=0x00;  // why this must be here?

    if(number_of_effects > 2)
        repeat = 1;
    else
        repeat = number_of_effects;

    for(int i = 0; i < repeat; i++)
        if(effects[i].effect_num < SINE_CHORUS)
            return -1;

    if(effects[0].effect_num>=SINE_CHORUS && effects[0].effect_num<=PITCH_SHIFTER)
    {
        fxknob = 0x01;
        repeat = 1;  //just to be sure
    }
    else
        fxknob = 0x02;
    array[FXKNOB] = fxknob;

    array[SAVE_SLOT] = slot;

    // set and send the name
    if(name[24] != 0x00)
        name[24] = 0x00;
    for(int i = 0, j = 16; name[i] != 0x00; i++, j++)
        array[j] = name[i];
    ret = libusb_interrupt_transfer(amp_hand, 0x01, array, LENGTH, &received, TMOUT);
    libusb_interrupt_transfer(amp_hand, 0x81, temp, LENGTH, &received, TMOUT);

    array[1] = 0x03;
    array[6] = 0x00;
    memset(array+16, 0x00, LENGTH-16);
    for(int i = 0; i < repeat; i++)
    {
        array[19] = 0x00;
        array[20] = 0x08;
        array[21] = 0x01;
        array[KNOB6] = 0x00;

        if(effects[i].put_post_amp)
            array[FXSLOT] = effects[i].fx_slot+4;
        else
            array[FXSLOT] = effects[i].fx_slot;
        array[KNOB1] = effects[i].knob1;
        array[KNOB2] = effects[i].knob2;
        array[KNOB3] = effects[i].knob3;
        array[KNOB4] = effects[i].knob4;
        array[KNOB5] = effects[i].knob5;
        // some effects have more knobs
        if (effects[i].effect_num == MONO_ECHO_FILTER ||
                effects[i].effect_num == STEREO_ECHO_FILTER ||
                effects[i].effect_num == TAPE_DELAY ||
                effects[i].effect_num == STEREO_TAPE_DELAY)
        {
            array[KNOB6] = effects[i].knob6;
        }

        // fill the form with missing data
        switch (effects[i].effect_num) {
        case SINE_CHORUS:
            array[DSP] = 0x07;
            array[EFFECT] = 0x12;
            array[19] = 0x01;
            array[20] = 0x01;
            break;

        case TRIANGLE_CHORUS:
            array[DSP] = 0x07;
            array[EFFECT] = 0x13;
            array[19] = 0x01;
            array[20] = 0x01;
            break;

        case SINE_FLANGER:
            array[DSP] = 0x07;
            array[EFFECT] = 0x18;
            array[19] = 0x01;
            array[20] = 0x01;
            break;

        case TRIANGLE_FLANGER:
            array[DSP] = 0x07;
            array[EFFECT] = 0x19;
            array[19] = 0x01;
            array[20] = 0x01;
            break;

        case VIBRATONE:
            array[DSP] = 0x07;
            array[EFFECT] = 0x2d;
            array[19] = 0x01;
            array[20] = 0x01;
            break;

        case VINTAGE_TREMOLO:
            array[DSP] = 0x07;
            array[EFFECT] = 0x40;
            array[19] = 0x01;
            array[20] = 0x01;
            break;

        case SINE_TREMOLO:
            array[DSP] = 0x07;
            array[EFFECT] = 0x41;
            array[19] = 0x01;
            array[20] = 0x01;
            break;

        case RING_MODULATOR:
            array[DSP] = 0x07;
            array[EFFECT] = 0x22;
            array[19] = 0x01;
            if(array[KNOB4] > 0x01)
                array[KNOB4] = 0x01;
            break;

        case STEP_FILTER:
            array[DSP] = 0x07;
            array[EFFECT] = 0x29;
            array[19] = 0x01;
            array[20] = 0x01;
            break;

        case PHASER:
            array[DSP] = 0x07;
            array[EFFECT] = 0x4f;
            array[19] = 0x01;
            array[20] = 0x01;
            if(array[KNOB5] > 0x01)
                array[KNOB5] = 0x01;
            break;

        case PITCH_SHIFTER:
            array[DSP] = 0x07;
            array[EFFECT] = 0x1f;
            array[19] = 0x01;
            break;

        case MONO_DELAY:
            array[DSP] = 0x08;
            array[EFFECT] = 0x16;
            array[19] = 0x02;
            array[20] = 0x01;
            break;

        case MONO_ECHO_FILTER:
            array[DSP] = 0x08;
            array[EFFECT] = 0x43;
            array[19] = 0x02;
            array[20] = 0x01;
            break;

        case STEREO_ECHO_FILTER:
            array[DSP] = 0x08;
            array[EFFECT] = 0x48;
            array[19] = 0x02;
            array[20] = 0x01;
            break;

        case MULTITAP_DELAY:
            array[DSP] = 0x08;
            array[EFFECT] = 0x44;
            array[19] = 0x02;
            array[20] = 0x01;
            break;

        case PING_PONG_DELAY:
            array[DSP] = 0x08;
            array[EFFECT] = 0x45;
            array[19] = 0x02;
            array[20] = 0x01;
            break;

        case DUCKING_DELAY:
            array[DSP] = 0x08;
            array[EFFECT] = 0x15;
            array[19] = 0x02;
            array[20] = 0x01;
            break;

        case REVERSE_DELAY:
            array[DSP] = 0x08;
            array[EFFECT] = 0x46;
            array[19] = 0x02;
            array[20] = 0x01;
            break;

        case TAPE_DELAY:
            array[DSP] = 0x08;
            array[EFFECT] = 0x2b;
            array[19] = 0x02;
            array[20] = 0x01;
            break;

        case STEREO_TAPE_DELAY:
            array[DSP] = 0x08;
            array[EFFECT] = 0x2a;
            array[19] = 0x02;
            array[20] = 0x01;
            break;

        case SMALL_HALL_REVERB:
            array[DSP] = 0x09;
            array[EFFECT] = 0x24;
            break;

        case LARGE_HALL_REVERB:
            array[DSP] = 0x09;
            array[EFFECT] = 0x3a;
            break;

        case SMALL_ROOM_REVERB:
            array[DSP] = 0x09;
            array[EFFECT] = 0x26;
            break;

        case LARGE_ROOM_REVERB:
            array[DSP] = 0x09;
            array[EFFECT] = 0x3b;
            break;

        case SMALL_PLATE_REVERB:
            array[DSP] = 0x09;
            array[EFFECT] = 0x4e;
            break;

        case LARGE_PLATE_REVERB:
            array[DSP] = 0x09;
            array[EFFECT] = 0x4b;
            break;

        case AMBIENT_REVERB:
            array[DSP] = 0x09;
            array[EFFECT] = 0x4c;
            break;

        case ARENA_REVERB:
            array[DSP] = 0x09;
            array[EFFECT] = 0x4d;
            break;

        case FENDER_63_SPRING_REVERB:
            array[DSP] = 0x09;
            array[EFFECT] = 0x21;
            break;

        case FENDER_65_SPRING_REVERB:
            array[DSP] = 0x09;
            array[EFFECT] = 0x0b;
            break;
        }
        // send packet
        ret = libusb_interrupt_transfer(amp_hand, 0x01, array, LENGTH, &received, TMOUT);
        libusb_interrupt_transfer(amp_hand, 0x81, temp, LENGTH, &received, TMOUT);
    }

    execute[FXKNOB] = fxknob;
    ret = libusb_interrupt_transfer(amp_hand, 0x01, execute, LENGTH, &received, TMOUT);
    libusb_interrupt_transfer(amp_hand, 0x81, temp, LENGTH, &received, TMOUT);
    execute[FXKNOB] = 0x00;

    return 0;
}

int Mustang::update(char *filename)
{
    int ret, received;
    unsigned char array[LENGTH], number = 0;
    FILE *file;
//    struct timespec sleep;
//    sleep.tv_nsec = NANO_SEC_SLEEP;
//    sleep.tv_sec = 0;

    if(amp_hand == NULL)
    {
        // initialize libusb
        ret = libusb_init(NULL);
        if (ret)
            return ret;

        // get handle for the device
        amp_hand = libusb_open_device_with_vid_pid(NULL, USB_UPDATE_VID, OLD_USB_UPDATE_PID);
        if(amp_hand == NULL)
        {
            amp_hand = libusb_open_device_with_vid_pid(NULL, USB_UPDATE_VID, NEW_USB_UPDATE_PID);
            if(amp_hand == NULL)
            {
                amp_hand = libusb_open_device_with_vid_pid(NULL, USB_UPDATE_VID, MINI_USB_UPDATE_PID);
                if(amp_hand == NULL)
                {
                    amp_hand = libusb_open_device_with_vid_pid(NULL, USB_UPDATE_VID, FLOOR_USB_UPDATE_PID);
                    if(amp_hand == NULL)
                    {
                        libusb_exit(NULL);
                        return -100;
                    }
                }
            }
        }

        // detach kernel driver
        ret = libusb_kernel_driver_active(amp_hand, 0);
        if(ret)
        {
            ret = libusb_detach_kernel_driver(amp_hand, 0);
            if(ret)
            {
                stop_amp();
                return ret;
            }
        }

        // claim the device
        ret = libusb_claim_interface(amp_hand, 0);
        if(ret)
        {
            stop_amp();
            return ret;
        }
    }
    else
        return -200;

    file = fopen(filename, "rb");
    // send date when firmware was created
    fseek(file, 0x1a, SEEK_SET);
    memset(array, 0x00, LENGTH);
    array[0] = 0x02;
    array[1] = 0x03;
    array[2] = 0x01;
    array[3] = 0x06;
    int rc = fread(array+4, 1, 11, file);
    ret = libusb_interrupt_transfer(amp_hand, 0x01, array, LENGTH, &received, TMOUT);
    libusb_interrupt_transfer(amp_hand, 0x81, array, LENGTH, &received, TMOUT);
//    nanosleep(&sleep, NULL);
    usleep(10000);

    // send firmware
    fseek(file, 0x110, SEEK_SET);
    for(;;)
    {
        memset(array, 0x00, LENGTH);
        array[0] = array[1] = 0x03;
        array[2] = number;
        number++;
        array[3] = fread(array+4, 1, LENGTH-8, file);
        ret = libusb_interrupt_transfer(amp_hand, 0x01, array, LENGTH, &received, TMOUT);
        libusb_interrupt_transfer(amp_hand, 0x81, array, LENGTH, &received, TMOUT);
//        nanosleep(&sleep, NULL);
        usleep(10000);
        if(feof(file))  // if reached end of the file
            break;  // exit loop
    }
    fclose(file);

    // send "finished" packet
    memset(array, 0x00, LENGTH);
    array[0] = 0x04;
    array[1] = 0x03;
    ret = libusb_interrupt_transfer(amp_hand, 0x01, array, LENGTH, &received, TMOUT);
    libusb_interrupt_transfer(amp_hand, 0x81, array, LENGTH, &received, TMOUT);

    // release claimed interface
    ret = libusb_release_interface(amp_hand, 0);
    if(ret)
        return ret;

    // re-attach kernel driver
    ret = libusb_attach_kernel_driver(amp_hand, 0);
    if(ret)
        return ret;

    // close opened interface
    libusb_close(amp_hand);
    amp_hand = NULL;

    // stop using libusb
    libusb_exit(NULL);

    return 0;
}