MainWindow::MainWindow(QWidget *parent) :
QMainWindow(parent),
ui(new Ui::MainWindow)
{
ui->setupUi(this);
m_bfalse=true;
playform = new QWidget(this);
playform->setSizePolicy(QSizePolicy(QSizePolicy::Preferred, QSizePolicy::Preferred));
playform->setAttribute(Qt::WA_OpaquePaintEvent);
playform->move(110,100);
playform->setMinimumSize(320,240);
//playform->hide();
connect(ui->pushButton,SIGNAL(clicked()),this,SLOT(play()));
connect(ui->pushButton_2,SIGNAL(clicked()),this,SLOT(stop()));
connect(ui->quiet,SIGNAL(clicked()),this,SLOT(quiet()));
connect(ui->next,SIGNAL(clicked()),this,SLOT(next()));
connect(ui->pre,SIGNAL(clicked()),this,SLOT(pre()));
connect(ui->v_,SIGNAL(clicked()),this,SLOT(v_()));
connect(ui->v2,SIGNAL(clicked()),this,SLOT(v2()));
connect(ui->fast,SIGNAL(clicked()),this,SLOT(move()));
// connect(process,SIGNAL(readyReadStandardOutput()),this,SLOT(back_messgae()));
// timer=new QTimer(this);
// connect(timer,SIGNAL(timeout()),this,SLOT(getTime()));
// timer->start(1000);
//退出 quit\n
i=1;
}
int mca_spml_ucx_deregister(sshmem_mkey_t *mkeys)
{
spml_ucx_mkey_t *ucx_mkey;
map_segment_t *mem_seg;
int segno;
int my_pe = oshmem_my_proc_id();
MCA_SPML_CALL(quiet(oshmem_ctx_default));
if (!mkeys)
return OSHMEM_SUCCESS;
if (!mkeys[0].spml_context)
return OSHMEM_SUCCESS;
mem_seg = memheap_find_va(mkeys[0].va_base);
ucx_mkey = (spml_ucx_mkey_t*)mkeys[0].spml_context;
if (OPAL_UNLIKELY(NULL == mem_seg)) {
return OSHMEM_ERROR;
}
if (MAP_SEGMENT_ALLOC_UCX != mem_seg->type) {
ucp_mem_unmap(mca_spml_ucx.ucp_context, ucx_mkey->mem_h);
}
ucp_rkey_destroy(ucx_mkey->rkey);
ucx_mkey->rkey = NULL;
if (0 < mkeys[0].len) {
ucp_rkey_buffer_release(mkeys[0].u.data);
}
free(mkeys);
return OSHMEM_SUCCESS;
}
static void
watchQuietCallback(SCDynamicStoreRef store, CFArrayRef changedKeys, void *info)
{
Boolean _quiet;
Boolean _timeout = FALSE;
_quiet = quiet(&_timeout);
if (_quiet
#if !TARGET_OS_IPHONE
|| _timeout
#endif /* !TARGET_OS_IPHONE */
) {
watchQuietDisable();
}
if (_quiet || _timeout) {
static int logged = 0;
(void) establishNewPreferences();
if (_timeout && (logged++ == 0)) {
SCLog(TRUE, LOG_NOTICE,
CFSTR("Network configuration creation timed out waiting for IORegistry"));
}
}
return;
}
void CLogicalChannel::start() {
m_flags = 0;
m_fPitchBend = 0;
m_fModWheel = 0;
m_fLFO = 0.0;
m_fPortamentoNote = 0.0;
m_fDetuneStep = 0.0;
m_arpCounter = 0;
m_arpIndex = 0;
m_fLFOPhase = 0;
m_portaTargetNote = 0;
m_fPortaStep = 0;
// ensure no sound
quiet();
// initialise the high divider flags for each voice
for(int i=m_voiceBegin; i<m_voiceEnd; ++i) {
Voice[i].div8_high(m_conf->flags & TONE_CONFIG::POKEY_HIHZ);
}
// initial calculation of detune spread
recalc_detune();
}
int main(int argc, char* argv[])
{
log_init();
try
{
cxxtools::Arg<bool> quiet(argc, argv, 'q');
if (argc <= 1)
{
std::cerr << "usage: " << argv[0]
<< " inifile [-q] [section [key [default]]]" << std::endl;
return -1;
}
const char* fname = argv[1];
std::ifstream in(fname);
if (!in)
throw std::runtime_error(std::string("error reading input file \"") + fname + '"');
cxxtools::IniFile ini(in);
if (argc <= 2)
{
// list sections
if (!quiet)
std::cout << "sections in " << fname << ": ";
ini.getSections(std::ostream_iterator<std::string>(std::cout, "\t"));
std::cout << std::endl;
return 0;
}
const char* section = argv[2];
if (argc <= 3)
{
// list keys
if (!quiet)
std::cout << "keys in " << fname << " [" << section << "]: ";
ini.getKeys(section, std::ostream_iterator<std::string>(std::cout, "\t"));
std::cout << std::endl;
return 0;
}
const char* key = argv[3];
const char* defvalue = argv[4] ? argv[4] : "";
if (!quiet)
std::cout << "value of " << fname << " [" << section << "]." << key << ": ";
std::cout << ini.getValue(section, key, defvalue) << std::endl;
}
catch (const std::exception& e)
{
std::cerr << e.what() << std::endl;
}
}
void ConnectionWindow::rfbLog(const char *format, ...)
{
if ( !quiet() ) {
va_list args;
QString message;
va_start(args, format);
message.vsprintf(format, args);
message.prepend(tr("RFB") + ": ");
va_end(args);
VncMainWindow::log(message);
}
}
void mca_spml_ucx_ctx_destroy(shmem_ctx_t ctx)
{
MCA_SPML_CALL(quiet(ctx));
SHMEM_MUTEX_LOCK(mca_spml_ucx.internal_mutex);
_ctx_remove(&mca_spml_ucx.active_array, (mca_spml_ucx_ctx_t *)ctx);
_ctx_add(&mca_spml_ucx.idle_array, (mca_spml_ucx_ctx_t *)ctx);
SHMEM_MUTEX_UNLOCK(mca_spml_ucx.internal_mutex);
if (!mca_spml_ucx.active_array.ctxs_count) {
opal_progress_unregister(spml_ucx_ctx_progress);
}
}
/* Set the currently used note waveform
*/
void set_waveform(uint8_t wavetype) {
//0==square, 1==triangle, 2=sin
/* Stop the current note */
quiet();
/* Toggle the waveform */
if (waveform != wavetype) {
waveform = wavetype;
} else {
waveform = 0;
}
/* Continue the current note */
start_note();
}
/* Play a note.
**
** Setup timer 1 to generate an interrupt at twice the frequency
** of the desired note for square waves, and twice*no. of steps
** for triangular waves. We then change the value being sent to
** the D2A. Timer 1 is configured to count the system clock
** and to reset on output compare match.
*/
void start_note(void)
{
uint16_t clockVal = 0;
const uint16_t noteClocks[] = {15287,13620,12133,11452,10203,9089,8098,7643};
/* Select precalculated clock times matching a note
** length for the compare register.
** period=1/(frequency)
** clocksteps=8MHz *period
**/
//c4 261.30hz //d4 293.66hz //e4 329.63hz //f4 349.23hz
//g4 392.00hz //a4 440.00hz //b4 493.88hz //c5 523.25hz
if (note<=7) {
clockVal = noteClocks[note];
} else {
quiet();
return;
}
/* Allow for waveforms: divide by no. steps needed
** then subtract 1, as clk starts at 0 */
if (waveform==1) clockVal = clockVal/(triWaveSteps);
if (waveform==2) clockVal = clockVal/(16);
if (octave==1) clockVal = clockVal/2;
//if (waveform==0) clockVal = clockVal;
clockVal--;
/* Write to the timer compare register */
OCR1A = clockVal;
/* Set up timer so that it resets on output compare match
** and is clocked by the system clock. This turns the timer
** on - so the interrupt handler will fire when it reaches
** the output compare value - and sound will be generated.
*/
TCCR1B = (1<<WGM12)|(1<<CS10);
}
//-----------------------------------------------------------------------------
int KMFolder::compact(void)
{
KMFolder* tempFolder;
KMMessage* msg;
QString tempName, msgStr;
int openCount = mOpenCount;
int num, numStatus;
if (!needsCompact)
{
//debug ("Not compacting %s; it's clean", name().data());
return 0;
}
debug ("Compacting %s ", name().data());
tempName = "." + name();
tempName.detach();
tempName += ".compacted";
unlink(tempName);
//tempFolder = parent()->createFolder(tempName); //sven: shouldn't be in list
tempFolder = new KMFolder(parent(), tempName); //sven: we create it
if(tempFolder->create()) {
debug("KMFolder::compact() Creating tempFolder failed!\n");
delete tempFolder; //sven: and we delete it
return 0;
}
quiet(TRUE);
tempFolder->open();
open();
for(num=1,numStatus=9; count() > 0; num++, numStatus--)
{
if (numStatus <= 0)
{
msgStr.sprintf(i18n("Compacting folder: %d messages done"), num);
emit statusMsg(msgStr);
numStatus = 10;
}
msg = getMsg(0);
if(msg)
tempFolder->moveMsg(msg);
}
tempName = tempFolder->location();
tempFolder->close(TRUE);
close(TRUE);
mMsgList.clear(TRUE);
_rename(tempName, location());
_rename(tempFolder->indexLocation(), indexLocation());
// Now really free all memory
delete tempFolder; //sven: we delete it, not the manager
if (openCount > 0)
{
open();
mOpenCount = openCount;
}
quiet(FALSE);
if (!mQuiet) emit changed();
needsCompact = false; // We are clean now
return 0;
}
int
main (int argc, char **argv) {
int c, s, fd;
unsigned int address, length;
unsigned int count, param;
char filename[PATH_MAX], ifname[IFNAMSIZ];
unsigned int cmd;
struct ifreq ifr;
char *buffer;
struct stat filestat;
int flag;
int target_version = -1;
int target_type = -1;
unsigned int bitwise_mask;
progname = argv[0];
if (argc == 1) usage();
flag = 0;
memset(filename, '\0', sizeof(filename));
memset(ifname, '\0', IFNAMSIZ);
strcpy(ifname, "eth1");
s = socket(AF_INET, SOCK_DGRAM, 0);
if (s < 0) err(1, "socket");
while (1) {
int option_index = 0;
static struct option long_options[] = {
{"get", 0, NULL, 'g'},
{"set", 0, NULL, 's'},
{"read", 0, NULL, 'r'},
{"test", 0, NULL, 't'},
{"file", 1, NULL, 'f'},
{"done", 0, NULL, 'd'},
{"write", 0, NULL, 'w'},
{"begin", 0, NULL, 'b'},
{"count", 1, NULL, 'c'},
{"param", 1, NULL, 'p'},
{"length", 1, NULL, 'l'},
{"execute", 0, NULL, 'e'},
{"address", 1, NULL, 'a'},
{"interface", 1, NULL, 'i'},
{"info", 0, NULL, 'I'},
{"and", 1, NULL, 'n'},
{"or", 1, NULL, 'o'},
{"quiet", 0, NULL, 'q'},
{"uncompress", 0, NULL, 'u'},
{0, 0, 0, 0}
};
c = getopt_long (argc, argv, "rwtebdgsIqf:l:a:p:i:c:n:o:",
long_options, &option_index);
if (c == -1)
break;
switch (c) {
case 'r':
cmd = BMI_READ_MEMORY;
break;
case 'w':
cmd = BMI_WRITE_MEMORY;
break;
case 'e':
cmd = BMI_EXECUTE;
break;
case 'b':
cmd = BMI_SET_APP_START;
break;
case 'd':
cmd = BMI_DONE;
break;
case 'g':
cmd = BMI_READ_SOC_REGISTER;
break;
case 's':
cmd = BMI_WRITE_SOC_REGISTER;
break;
case 't':
cmd = BMI_TEST;
break;
case 'f':
memset(filename, '\0', sizeof(filename));
strncpy(filename, optarg, sizeof(filename));
flag |= FILE_FLAG;
break;
case 'l':
length = atoi(optarg);
flag |= LENGTH_FLAG;
break;
case 'a':
address = strtoul(optarg, NULL, 0);
flag |= ADDRESS_FLAG;
break;
case 'p':
param = strtoul(optarg, NULL, 0);
flag |= PARAM_FLAG;
break;
case 'c':
count = atoi(optarg);
flag |= COUNT_FLAG;
break;
case 'i':
memset(ifname, '\0', 8);
strcpy(ifname, optarg);
break;
case 'I':
cmd = BMI_GET_TARGET_INFO;
break;
case 'n':
flag |= PARAM_FLAG | AND_OP_FLAG | BITWISE_OP_FLAG;
bitwise_mask = strtoul(optarg, NULL, 0);
break;
case 'o':
flag |= PARAM_FLAG | BITWISE_OP_FLAG;
bitwise_mask = strtoul(optarg, NULL, 0);
break;
case 'q':
flag |= QUIET_FLAG;
break;
case 'u':
flag |= UNCOMPRESS_FLAG;
break;
default:
usage();
}
}
strncpy(ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
/* Verify that the Target is alive. If not, wait for it. */
{
int rv;
static int waiting_msg_printed = 0;
buffer = (char *)MALLOC(sizeof(struct bmi_target_info));
((int *)buffer)[0] = AR6000_XIOCTL_TARGET_INFO;
ifr.ifr_data = buffer;
while ((rv=ioctl(s, AR6000_IOCTL_EXTENDED, &ifr)) < 0)
{
if (errno == ENODEV) {
/*
* Give the Target device a chance to start.
* Then loop back and see if it's alive.
*/
if (!waiting_msg_printed) {
nqprintf("bmiloader is waiting for Target....\n");
waiting_msg_printed = 1;
}
usleep(100000); /* Wait for 100ms */
} else {
printf("Unexpected error on AR6000_XIOCTL_TARGET_INFO: %d\n", rv);
exit(1);
}
}
target_version = ((int *)buffer)[0];
target_type = ((int *)buffer)[1];
free(buffer);
}
switch(cmd)
{
case BMI_DONE:
nqprintf("BMI Done\n");
buffer = (char *)MALLOC(4);
((int *)buffer)[0] = AR6000_XIOCTL_BMI_DONE;
ifr.ifr_data = buffer;
if (ioctl(s, AR6000_IOCTL_EXTENDED, &ifr) < 0)
{
err(1, ifr.ifr_name);
}
free(buffer);
break;
case BMI_TEST:
if ((flag & (COUNT_FLAG | LENGTH_FLAG | ADDRESS_FLAG)) ==
(COUNT_FLAG | LENGTH_FLAG | ADDRESS_FLAG))
{
nqprintf("BMI Test (address: 0x%x, length: %d, count: %d)\n",
address, length, count);
buffer = (char *)MALLOC(16);
((int *)buffer)[0] = AR6000_XIOCTL_BMI_TEST;
((int *)buffer)[1] = address;
((int *)buffer)[2] = length;
((int *)buffer)[3] = count;
ifr.ifr_data = buffer;
if (ioctl(s, AR6000_IOCTL_EXTENDED, &ifr) < 0)
{
err(1, ifr.ifr_name);
}
free(buffer);
}
else usage();
break;
case BMI_READ_MEMORY:
if ((flag & (ADDRESS_FLAG | LENGTH_FLAG | FILE_FLAG)) ==
(ADDRESS_FLAG | LENGTH_FLAG | FILE_FLAG))
{
nqprintf(
"BMI Read Memory (address: 0x%x, length: %d, filename: %s)\n",
address, length, filename);
if ((fd = open(filename, O_CREAT|O_WRONLY|O_TRUNC, 00644)) < 0)
{
perror("Could not create a file");
exit(1);
}
buffer = (char *)MALLOC(MAX_BUF + 12);
{
unsigned int remaining = length;
while (remaining)
{
length = (remaining > MAX_BUF) ? MAX_BUF : remaining;
((int *)buffer)[0] = AR6000_XIOCTL_BMI_READ_MEMORY;
((int *)buffer)[1] = address;
/*
* We round up the requested length because some
* SDIO Host controllers can't handle other lengths;
* but we still only write the requested number of
* bytes to the file.
*/
((int *)buffer)[2] = A_ROUND_UP(length, 4);
ifr.ifr_data = buffer;
if (ioctl(s, AR6000_IOCTL_EXTENDED, &ifr) < 0)
{
err(1, ifr.ifr_name);
}
else
{
write(fd, buffer, length);
}
remaining -= length;
address += length;
}
}
close(fd);
free(buffer);
}
else usage();
break;
case BMI_WRITE_MEMORY:
if (!(flag & ADDRESS_FLAG))
{
usage(); /* no address specified */
}
if (!(flag & (FILE_FLAG | PARAM_FLAG)))
{
usage(); /* no data specified */
}
if ((flag & FILE_FLAG) && (flag & PARAM_FLAG))
{
usage(); /* too much data specified */
}
if ((flag & UNCOMPRESS_FLAG) && !(flag & FILE_FLAG))
{
usage(); /* uncompress only works with a file */
}
if (flag & FILE_FLAG)
{
nqprintf(
"BMI Write %sMemory (address: 0x%x, filename: %s)\n",
((flag & UNCOMPRESS_FLAG) ? "compressed " : ""),
address, filename);
if ((fd = open(filename, O_RDONLY)) < 0)
{
perror("Could not open file");
exit(1);
}
memset(&filestat, '\0', sizeof(struct stat));
buffer = (char *)MALLOC(MAX_BUF + 12);
fstat(fd, &filestat);
length = filestat.st_size;
if (flag & UNCOMPRESS_FLAG) {
/* Initiate compressed stream */
((int *)buffer)[0] = AR6000_XIOCTL_BMI_LZ_STREAM_START;
((int *)buffer)[1] = address;
if (ioctl(s, AR6000_IOCTL_EXTENDED, &ifr) < 0)
{
err(1, ifr.ifr_name);
}
}
}
else
{ /* PARAM_FLAG */
nqprintf(
"BMI Write Memory (address: 0x%x, value: 0x%x)\n",
address, param);
length = sizeof(param);
buffer = (char *)MALLOC(length + 12);
*(unsigned int *)(&buffer[12]) = param;
fd = -1;
}
/*
* Write length bytes of data to memory.
* Data is either present in buffer OR
* needs to be read from fd in MAX_BUF chunks.
*
* Within the kernel, the implementation of
* AR6000_XIOCTL_BMI_WRITE_MEMORY further
* limits the size of each transfer over the
* interconnect according to BMI protocol
* limitations.
*/
{
unsigned int remaining = length;
int *pLength;
while (remaining)
{
length = (remaining > MAX_BUF) ? MAX_BUF : remaining;
if (flag & UNCOMPRESS_FLAG) {
/* 0 pad last word of data to avoid messy uncompression */
((A_UINT32 *)buffer)[2+((length-1)/4)] = 0;
if (read(fd, &buffer[8], length) != length)
{
perror("read from compressed file failed");
exit(1);
}
((int *)buffer)[0] = AR6000_XIOCTL_BMI_LZ_DATA;
pLength = &((int *)buffer)[1];
} else {
if (fd > 0)
{
if (read(fd, &buffer[12], length) != length)
{
perror("read from file failed");
exit(1);
}
}
((int *)buffer)[0] = AR6000_XIOCTL_BMI_WRITE_MEMORY;
((int *)buffer)[1] = address;
pLength = &((int *)buffer)[2];
}
/*
* We round up the requested length because some
* SDIO Host controllers can't handle other lengths.
* This generally isn't a problem for users, but it's
* something to be aware of.
*/
*pLength = A_ROUND_UP(length, 4);
ifr.ifr_data = buffer;
while (ioctl(s, AR6000_IOCTL_EXTENDED, &ifr) < 0)
{
err(1, ifr.ifr_name);
}
remaining -= length;
address += length;
}
}
free(buffer);
if (fd > 0)
{
close(fd);
if (flag & UNCOMPRESS_FLAG) {
/*
* Close compressed stream and open a new (fake)
* one. This serves mainly to flush Target caches.
*/
((int *)buffer)[0] = AR6000_XIOCTL_BMI_LZ_STREAM_START;
((int *)buffer)[1] = 0;
if (ioctl(s, AR6000_IOCTL_EXTENDED, &ifr) < 0)
{
err(1, ifr.ifr_name);
}
}
}
break;
case BMI_READ_SOC_REGISTER:
if ((flag & (ADDRESS_FLAG)) == (ADDRESS_FLAG))
{
nqprintf("BMI Read Register (address: 0x%x)\n", address);
buffer = (char *)MALLOC(8);
((int *)buffer)[0] = AR6000_XIOCTL_BMI_READ_SOC_REGISTER;
((int *)buffer)[1] = address;
ifr.ifr_data = buffer;
if (ioctl(s, AR6000_IOCTL_EXTENDED, &ifr) < 0)
{
err(1, ifr.ifr_name);
}
param = ((int *)buffer)[0];
if (quiet()) {
printf("0x%x\n", param);
} else {
printf("Return Value from target: 0x%x\n", param);
}
free(buffer);
}
else usage();
break;
case BMI_WRITE_SOC_REGISTER:
if ((flag & (ADDRESS_FLAG | PARAM_FLAG)) == (ADDRESS_FLAG | PARAM_FLAG))
{
int origvalue = 0;
if (flag & BITWISE_OP_FLAG) {
/* first read */
buffer = (char *)MALLOC(8);
((int *)buffer)[0] = AR6000_XIOCTL_BMI_READ_SOC_REGISTER;
((int *)buffer)[1] = address;
ifr.ifr_data = buffer;
if (ioctl(s, AR6000_IOCTL_EXTENDED, &ifr) < 0)
{
err(1, ifr.ifr_name);
}
param = ((int *)buffer)[0];
origvalue = param;
free(buffer);
/* now modify */
if (flag & AND_OP_FLAG) {
param &= bitwise_mask;
} else {
param |= bitwise_mask;
}
/* fall through to write out the parameter */
}
if (flag & BITWISE_OP_FLAG) {
if (quiet()) {
printf("0x%x\n", origvalue);
} else {
printf("BMI Bit-Wise (%s) modify Register (address: 0x%x, orig:0x%x, new: 0x%x, mask:0x%X)\n",
(flag & AND_OP_FLAG) ? "AND" : "OR", address, origvalue, param, bitwise_mask );
}
} else{
nqprintf("BMI Write Register (address: 0x%x, param: 0x%x)\n", address, param);
}
buffer = (char *)MALLOC(12);
((int *)buffer)[0] = AR6000_XIOCTL_BMI_WRITE_SOC_REGISTER;
((int *)buffer)[1] = address;
((int *)buffer)[2] = param;
ifr.ifr_data = buffer;
if (ioctl(s, AR6000_IOCTL_EXTENDED, &ifr) < 0)
{
err(1, ifr.ifr_name);
}
free(buffer);
}
else usage();
break;
case BMI_EXECUTE:
if ((flag & (ADDRESS_FLAG | PARAM_FLAG)) == (ADDRESS_FLAG | PARAM_FLAG))
{
nqprintf("BMI Execute (address: 0x%x, param: 0x%x)\n", address, param);
buffer = (char *)MALLOC(12);
((int *)buffer)[0] = AR6000_XIOCTL_BMI_EXECUTE;
((int *)buffer)[1] = address;
((int *)buffer)[2] = param;
ifr.ifr_data = buffer;
if (ioctl(s, AR6000_IOCTL_EXTENDED, &ifr) < 0)
{
err(1, ifr.ifr_name);
}
param = ((int *)buffer)[0];
if (quiet()) {
printf("0x%x\n", param);
} else {
printf("Return Value from target: 0x%x\n", param);
}
free(buffer);
}
else usage();
break;
case BMI_SET_APP_START:
if ((flag & ADDRESS_FLAG) == ADDRESS_FLAG)
{
nqprintf("BMI Set App Start (address: 0x%x)\n", address);
buffer = (char *)MALLOC(8);
((int *)buffer)[0] = AR6000_XIOCTL_BMI_SET_APP_START;
((int *)buffer)[1] = address;
ifr.ifr_data = buffer;
if (ioctl(s, AR6000_IOCTL_EXTENDED, &ifr) < 0)
{
err(1, ifr.ifr_name);
}
free(buffer);
}
else usage();
break;
case BMI_GET_TARGET_INFO:
nqprintf("BMI Target Info:\n");
printf("TARGET_TYPE=%s\n",
(target_type == TARGET_TYPE_AR6001) ? "AR6001" :
((target_type == TARGET_TYPE_AR6002) ? "AR6002" :
(((target_type == TARGET_TYPE_AR6003) ? "AR6003" : "unknown"))));
printf("TARGET_VERSION=0x%x\n", target_version);
break;
default:
usage();
}
exit (0);
}
void shmem_quiet_f(void)
{
MCA_SPML_CALL(quiet(oshmem_ctx_default));
}
void CLogicalChannel::handleCC(char cc, char value)
{
switch(cc) {
case CC_POKEYCFG:
{
byte mode;
switch(ccMapValue(value, TONE_CONFIG::POKEY_MAX)) {
case TONE_CONFIG::POKEY_8_HPF:
mode = CPokey::MODE_8BITHPF;
break;
case TONE_CONFIG::POKEY_16:
mode = CPokey::MODE_16BIT;
break;
case TONE_CONFIG::POKEY_8:
default:
mode = CPokey::MODE_8BIT;
break;
}
if(mode != m_conf->ePokeyMode) {
m_conf->ePokeyMode = mode;
// m_flags |= SF_RECONFIG;
}
}
break;
case CC_POKEYDUAL:
{
byte flags = m_conf->flags;
ccFlag(&flags, TONE_CONFIG::POKEY_DUAL, value);
if(flags != m_conf->flags) {
// m_flags |= SF_RECONFIG;
m_conf->flags = flags;
}
}
break;
case CC_POKEYRANGE:
ccFlag(&m_conf->flags, TONE_CONFIG::POKEY_HIHZ, value);
div8_high(!!(m_conf->flags & TONE_CONFIG::POKEY_HIHZ));
break;
case CC_MIDIVEL:
ccFlag(&m_conf->flags, TONE_CONFIG::USE_VELOCITY, value);
break;
case CC_MONO:
ccFlag(&m_conf->flags, TONE_CONFIG::MONO, 127);
break;
case CC_POLY:
ccFlag(&m_conf->flags, TONE_CONFIG::MONO, 0);
break;
case CC_ARPENABLE:
ccFlag(&m_conf->flags, TONE_CONFIG::ARPEGGIATE, value);
break;
case CC_ARP2ENV:
ccFlag(&m_conf->flags, TONE_CONFIG::ARP2ENV, value);
break;
case CC_MOD:
m_fModWheel = (float)value/127;
break;
case CC_PORTATIME:
m_conf->portaTime = value;
break;
case CC_TRANSPOSE:
m_conf->transpose = value - 64;
break;
case CC_FINETUNE:
m_conf->fFineTune = ((float)value - 64)/10.0;
break;
case CC_ARPRATE:
m_conf->arpRate = value;
break;
case CC_ARPCOUNT:
m_conf->arpCount = 1 + value/16;
break;
case CC_LFORATE:
m_conf->lfoRate = value;
break;
case CC_LFODEPTH:
m_conf->lfoDepth = value;
break;
case CC_AENVATTACK:
m_conf->ampEnv.attackSlope = envSlope(value,0);
break;
case CC_AENVRELEASE:
m_conf->ampEnv.releaseSlope = envSlope(value,1);
break;
case CC_AENVMODE:
m_conf->ampEnv.mode = ccMapValue(value, ENVELOPE::MAX_MODE);
break;
case CC_MENVATTACK:
m_conf->modEnv.attackSlope = envSlope(value,0);
break;
case CC_MENVRELEASE:
m_conf->modEnv.releaseSlope = envSlope(value,1);
break;
case CC_MENVMODE:
m_conf->modEnv.mode = ccMapValue(value, ENVELOPE::MAX_MODE);
break;
case CC_PBRANGE:
m_conf->pitchBendRange = 12.0 * (value/127.0);
break;
case CC_HPF:
m_conf->hpf = value;
break;
case CC_DIST:
m_conf->dist = value;
break;
case CC_DETUNELEVEL:
m_conf->detuneLevel = value;
break;
case CC_UNISONTYPE:
m_conf->eUnisonMode = ccMapValue(value, TONE_CONFIG::UNISON_MAX);
recalc_detune();
break;
case CC_LFOMODE:
m_conf->eLFOMode = ccMapValue(value, TONE_CONFIG::LFO_MAX);
break;
case CC_LFOWAVE:
m_conf->eLFOWave = ccMapValue(value, TONE_CONFIG::WAVE_MAX);
break;
case CC_LFODEPTH_MODSRC:
m_conf->lfoDepthModSrc = ccMapValue(value, TONE_CONFIG::MODSRC_MAX);
break;
case CC_DETUNE_MODSRC:
m_conf->detuneModSrc = ccMapValue(value, TONE_CONFIG::MODSRC_MAX);
break;
case CC_HPF_MODSRC:
m_conf->hpfModSrc = ccMapValue(value, TONE_CONFIG::MODSRC_MAX);
break;
case CC_DIST_MODSRC:
m_conf->distModSrc = ccMapValue(value, TONE_CONFIG::MODSRC_MAX);
break;
case CC_LFORATE_MODSRC:
m_conf->lfoRateModSrc = ccMapValue(value, TONE_CONFIG::MODSRC_MAX);
break;
case CC_ARPATE_MODSRC:
m_conf->arpRateModSrc = ccMapValue(value, TONE_CONFIG::MODSRC_MAX);
break;
// MOD MATRIX SETTINGS FOR LFO
case CC_LFO_2_PITCH:
m_conf->lfoToPitch = ccModDepth(value);
break;
case CC_LFO_2_VOL:
m_conf->lfoToAmp = ccModDepth(value);
break;
case CC_ENV_2_PITCH:
m_conf->modEnvToPitch = ccModDepth(value);
break;
case CC_ALL_SOUND_OFF:
case CC_ALL_NOTES_OFF:
quiet();
break;
case CC_RESET_CTRL:
//TODO
break;
case CC_FROM_NOTE:
m_fromNote = value;
if(m_toNote < m_fromNote) {
m_fromNote = m_toNote;
m_toNote = value;
}
break;
case CC_TO_NOTE:
m_toNote = value;
if(m_toNote < m_fromNote) {
m_toNote = m_fromNote;
m_fromNote = value;
}
break;
}
}
