/**
* Compute command
*/
void command_compute(char* line) {
char cmd[MAX_BUFFER];
char key[MAX_BUFFER];
char func[MAX_BUFFER];
char arg1[MAX_BUFFER];
int argc = sscanf(line, "%s %s %s %s", cmd, func, key, arg1);
if (argc < 3) {
goto invalid;
}
MATRIX_GUARD(key);
uint32_t result = 0;
if (strcasecmp(func, "sum") == 0) {
result = get_sum(m);
} else if (strcasecmp(func, "trace") == 0) {
result = get_trace(m);
} else if (strcasecmp(func, "minimum") == 0) {
result = get_minimum(m);
} else if (strcasecmp(func, "maximum") == 0) {
result = get_maximum(m);
} else if (strcasecmp(func, "frequency") == 0) {
result = get_frequency(m, atoll(arg1));
} else {
goto invalid;
}
printf("%" PRIu32 "\n", result);
return;
invalid:
puts("invalid arguments");
}
static int
handle_event(struct measurements *m, const struct input_event *ev)
{
if (ev->type == EV_SYN) {
const int idle_reset = 3000000; /* us */
uint64_t last_us = m->us;
m->us = tv2us(&ev->time);
/* reset after pause */
if (last_us + idle_reset < m->us) {
m->max_frequency = 0.0;
m->distance = 0;
} else {
double freq = get_frequency(last_us, m->us);
push_frequency(m, freq);
m->max_frequency = max(freq, m->max_frequency);
return print_current_values(m);
}
return 0;
} else if (ev->type != EV_REL)
return 0;
switch(ev->code) {
case REL_X:
m->distance += ev->value;
break;
}
return 0;
}
void create_note(synth_note * sn, int note, int octave, float start_time, float len)
{
sn->note = note;
sn->octave = octave;
sn->start_time = start_time;
sn->end_time = start_time + len;
printf("Start Time: %f\n", sn->start_time);
printf("End Time: %f\n", sn->end_time);
//create sin waves
sin_wave base;
init(&base, 0.15, 0.0, get_frequency(note, octave));
create_envelope(&(sn->env), 0.1, len);
sn->num_waves = 8;
sn->waves = (sin_wave *) malloc(sizeof(sin_wave) * sn->num_waves);
sn->waves[0] = base;
harmonic(&(sn->waves[1]), &(sn->waves[0]), 2);
harmonic(&(sn->waves[2]), &(sn->waves[0]), 3);
harmonic(&(sn->waves[3]), &(sn->waves[0]), 4);
harmonic(&(sn->waves[4]), &(sn->waves[0]), 5);
harmonic(&(sn->waves[5]), &(sn->waves[0]), 6);
harmonic(&(sn->waves[6]), &(sn->waves[0]), 7);
harmonic(&(sn->waves[7]), &(sn->waves[0]), 8);
}
uint64_t query(factor Factor) const
{
const auto Diff = call_function(QueryPerformanceCounter) - m_StartTime;
const auto Frequency = get_frequency();
const auto Whole = Diff / Frequency;
const auto Fraction = Diff % Frequency;
return Whole * Factor + (Fraction * Factor) / Frequency;
}
static void wireless_frequency(RESULT * result, RESULT * arg1)
{
char *dev = R2S(arg1);
if (check_socket() != 0)
return;
save_result(result, dev, KEY_FREQUENCY, get_frequency(dev, KEY_FREQUENCY));
}
namespace stopwatch
{
#if defined(_MSC_VER)
inline double get_frequency()
{
LARGE_INTEGER proc_freq;
::QueryPerformanceFrequency(&proc_freq);
return 1000.*1000.*1000./(double)proc_freq.QuadPart;
}
static const double frequency = get_frequency();
#endif
unsigned int depth = 0;
unsigned int counter = 0;
// function to get current time
inline double current_time()
{
#if defined(__GNUC__)
timespec ts;
clock_gettime(CLOCK_MONOTONIC, &ts);
double t = ts.tv_sec * 1000 * 1000 * 1000;
t += ts.tv_nsec;
return t;
#elif defined(_MSC_VER)
LARGE_INTEGER ts;
::QueryPerformanceCounter(&ts);
return (double)ts.QuadPart/(double)frequency;
#endif
}
struct stopwatch_object
{
stopwatch_object() : name_(0), depth_(0), timestamp_(0.0) {}
stopwatch_object(const char *& name) :
name_(name), depth_(depth), timestamp_(current_time())
{}
const char * name_;
unsigned int depth_;
double timestamp_;
};
struct map_entry
{
stopwatch::stopwatch_object swo;
bool even;
unsigned int invocations;
double timestamp_buff;
unsigned int num;
};
// this initialization may cause the stopwatch to segfault if more than
// data.size()/2 different measurements are taken
std::vector<stopwatch_object> data(500000);
}
/*****************************************************************
* \brief public wrapper for get_frequency
* \parameter frequency pointer to float, which will contain frequency in MHz
* \return 1 if success,0 - otherwise
*/
int radio_get_freq(struct stream *stream, float *frequency) {
radio_priv_t* priv=(radio_priv_t*)stream->priv;
if (!frequency)
return 0;
if (get_frequency(priv,frequency)!=STREAM_OK) {
return 0;
}
return 1;
}
void Group::generate(float *buf, size_t samples)
{
Waveform type = (Waveform) list.get_cur_value();
float frequency = get_frequency();
float phase = get_phase();
generate_wave(type, buf, samples, t, frequency, phase);
t += dt * samples;
}
void synth_run_16bit(synth_state* synth, short* audiobuffer, long nframes)
{
for(int c=0;c < synth->num_channels;++c) {
float freq = get_frequency(c);
float phase_inc = 2.0 * M_PI * freq / synth->sample_rate;
for(long n=0;n < nframes;++n) {
audiobuffer[n*synth->num_channels+c] = sin(synth->phase[c]) * VOLUME * 32767.0f;
synth->phase[c] += phase_inc;
}
}
}
/*****************************************************************
* \brief public wrapper for set_frequency
* \parameter frequency frequency in MHz
* \return 1 if success,0 - otherwise
*/
int radio_set_freq(struct stream_st *stream, float frequency){
radio_priv_t* priv=(radio_priv_t*)stream->priv;
if (set_frequency(priv,frequency)!=STREAM_OK){
return 0;
}
if (get_frequency(priv,&frequency)!=STREAM_OK){
return 0;
}
mp_msg(MSGT_RADIO, MSGL_INFO, MSGTR_RADIO_CurrentFreq,frequency);
return 1;
}
void Group::update_labels()
{
char buf[32];
float frequency = get_frequency();
float phase = get_phase();
sprintf(buf, "%4.0f Hz", frequency);
freq_val_label.set_text(buf);
sprintf(buf, "%.2f π", phase/PI);
phase_val_label.set_text(buf);
}
/*****************************************************************
* \brief public wrapper for set_frequency
* \parameter frequency frequency in MHz
* \return 1 if success,0 - otherwise
*/
int radio_set_freq(struct stream *stream, float frequency) {
radio_priv_t* priv=(radio_priv_t*)stream->priv;
if (set_frequency(priv,frequency)!=STREAM_OK) {
return 0;
}
if (get_frequency(priv,&frequency)!=STREAM_OK) {
return 0;
}
mp_tmsg(MSGT_RADIO, MSGL_INFO, "[radio] Current frequency: %.2f\n",frequency);
return 1;
}
static PyObject *
python_get_frequency(PyObject *self, PyObject *args ) {
char *usage = "Usage: _seisparams._get_frequency( magnitude, depth, distance )";
PyObject *obj;
double retval, magnitude, depth, distance;
if( ! PyArg_ParseTuple( args, "ddd", &magnitude, &depth, &distance ) ) {
USAGE;
return NULL;
}
retval=get_frequency( magnitude, depth, distance);
obj = Py_BuildValue( "d", retval );
return obj;
}
/*****************************************************************
* \brief tune current frequency by step_interval value
* \parameter step_interval increment value
* \return 1 if success,0 - otherwise
*
*/
int radio_step_freq(struct stream *stream, float step_interval) {
float frequency;
radio_priv_t* priv=(radio_priv_t*)stream->priv;
if (get_frequency(priv,&frequency)!=STREAM_OK)
return 0;
frequency+=step_interval;
if (frequency>priv->rangehigh)
frequency=priv->rangehigh;
if (frequency<priv->rangelow)
frequency=priv->rangelow;
return radio_set_freq(stream,frequency);
}
uint64_t get_time_usecs() {
static LARGE_INTEGER frequency = get_frequency();
static bool old_windows = is_xp_or_older();
CRITICAL_SECTION mutex;
LARGE_INTEGER time;
if (old_windows) {
InitializeCriticalSection(&mutex);
EnterCriticalSection(&mutex);
QueryPerformanceCounter(&time);
LeaveCriticalSection(&mutex);
} else {
QueryPerformanceCounter(&time);
}
return (1000000 * time.QuadPart / frequency.QuadPart)
}
verdict test_randomized()
{
#if !defined(NO_RANDOMIZATION)
srand (unsigned(get_time_stamp()/get_frequency())); // Randomize pseudo random number generator
#endif
std::cout << "=================== Randomized Test ===================" << std::endl;
size_t a1 = 0, a2 = 0;
std::vector<long long> mediansV(K); // Final verdict of medians for each of the K experiments with visitors
std::vector<long long> mediansM(K); // Final verdict of medians for each of the K experiments with matching
std::vector<long long> timingsV(M);
std::vector<long long> timingsM(M);
std::vector<Shape*> shapes(N);
for (size_t k = 0; k < K; ++k)
{
for (size_t i = 0; i < N; ++i)
shapes[i] = make_shape(rand());
run_timings(shapes, timingsV, timingsM, a1, a2);
mediansV[k] = display("AreaVisRnd", timingsV);
mediansM[k] = display("AreaMatRnd", timingsM);
std::cout << "\t\t" << verdict(mediansV[k], mediansM[k]) << std::endl;
for (size_t i = 0; i < N; ++i)
{
delete shapes[i];
shapes[i] = 0;
}
}
if (a1 != a2)
{
std::cout << "ERROR: Invariant " << a1 << "==" << a2 << " doesn't hold." << std::endl;
exit(42);
}
std::sort(mediansV.begin(), mediansV.end());
std::sort(mediansM.begin(), mediansM.end());
return verdict(mediansV[K/2],mediansM[K/2]);
}
/**
* Compute command.
*/
void command_compute(char* line) {
char cmd[MAX_BUFFER];
char key[MAX_BUFFER];
char func[MAX_BUFFER];
char arg1[MAX_BUFFER];
int argc = sscanf(line, "%s %s %s %s", cmd, func, key, arg1);
if (argc < 3) {
goto invalid;
}
MATRIX_GUARD(key);
float result = 0;
if (strcasecmp(func, "sum") == 0) {
result = get_sum(m);
} else if (strcasecmp(func, "trace") == 0) {
result = get_trace(m);
} else if (strcasecmp(func, "minimum") == 0) {
result = get_minimum(m);
} else if (strcasecmp(func, "maximum") == 0) {
result = get_maximum(m);
} else if (strcasecmp(func, "determinant") == 0) {
result = get_determinant(m);
} else if (strcasecmp(func, "frequency") == 0) {
ssize_t count = get_frequency(m, atof(arg1));
printf("%zu\n", count);
return;
} else {
goto invalid;
}
printf("%.2f\n", result);
return;
invalid:
puts("invalid arguments");
}
BoxClass::current_tone_list BoxClass::GetCurrentTones()
{
ScopedLock lock(mutex);
current_tone_list retval;
if (!box) return retval;
struct mutabor_logic_parsed * file = box->file;
if (!file) return retval;
// no file means no logic (implying no current logic)
int count = box->key_count;
if (!count) return retval;
retval.resize(count);
size_t i = 0;
for (mutabor_note_type * key = mutabor_find_key_in_box(box,0);
key != NULL;
key = mutabor_find_key_in_box(box,key->next)) {
int index = key->number;
mutabor_tone tone;
switch (tone=get_frequency(index)) {
case MUTABOR_NO_KEY:
break;
case MUTABOR_INVALID_KEY:
retval[i].flag=tone_entry::invalid;
break;
default:
retval[i] = current_tone_entry(index,
mutabor_convert_tone_to_pitch(tone),
key->id,
GetChannel(index, key->channel, key->id));
}
++i;
}
return retval;
}
int main(int argc, char *argv[]){
// 1. Initialization
int c;
symbol *root;
root=init_symbol(ROOT_NODE);
root->frequency=NON_EXISTENT;
root->parent=root;
// 1.a. init: file pointers
FILE *inputfile;
FILE *outputfile;
inputfile=NULL;
outputfile=NULL;
if (argc >=2)
inputfile = fopen(argv[1],"r");
if (argc >=3)
outputfile = fopen(argv[2],"w");
if (inputfile == NULL) {
fprintf(stderr, "Can't open input file. \n");
exit(1);
}
if (outputfile == NULL) {
outputfile=stdout;
}
// 2. count the frequency of each character in inputfile
while((c=fgetc(inputfile))!=EOF){
update_frequency(root,c);
}
update_frequency(root,-1);
// 3. Make the huffman tree
while(count_parentless_nodes(root) > 1){
symbol *node1,*node2, *newnode;
node1 = get_rarest_parentless_node(root);
node1->parent=node1; //temporarily
node2 = get_rarest_parentless_node(root);
node2->parent=node2; //temporarily
newnode = new_node(node1, node2);
insert_symbol(root,newnode);
}
// 4. Output symbol mappings
for(c=-1;c<256;c++){
char *encodingstring;
encodingstring=get_encoding(root,c);
int freq=get_frequency(root,c);
if (freq > 0){
/*if (c <=127 && c>=32 )
fprintf(outputfile,"%c\t%d\t%s\n", c, freq, encodingstring);
else */
fprintf(outputfile,"%d\t%d\t%s\n", c, freq, encodingstring);
}
free(encodingstring);
}
fprintf(outputfile,"\n");
// 5. Output encoding of inputfile
rewind(inputfile);
while((c=fgetc(inputfile))!=EOF){
char *encodingstring;
encodingstring=get_encoding(root,c);
fprintf(outputfile, "%s", encodingstring);
free(encodingstring);
}
char *encodingstring;
encodingstring=get_encoding(root,EOF);
fprintf(outputfile, "%s", encodingstring);
free(encodingstring);
fprintf(outputfile,"\n");
free_symbol(root);
// 6. Close file pointers
fclose(inputfile);
fclose(outputfile);
}
GameClock::GameClock()
: m_start_time {}, m_current_time {}, m_last_time {}, m_frequency {} {
m_frequency = get_frequency();
reset();
}
bool cpu_frequency::set_frequency(cpu_frequency_type type,unsigned long khz,unsigned long khzUpper,unsigned long khzLower)
{
if(!valid) return false;
bool governorAvailable = false;
bool freqMatched = false;
bool upperMatched = false;
bool lowerMatched = false;
for(std::vector<cpu_frequency_type>::iterator i = available_governors.begin();i != available_governors.end();i++)
{
if(*i == type)
{
governorAvailable = true;
break;
}
}
for(std::vector<unsigned long>::iterator i = available_frequencies.begin();i != available_frequencies.end();i++)
{
if(*i == khz) freqMatched = true;
if(*i == khzUpper) upperMatched = true;
if(*i == khzLower) lowerMatched = true;
}
if(!governorAvailable || !upperMatched || !lowerMatched || !freqMatched)
{
last_error = PBSE_FREQUENCY_NOT_AVAILABLE;
return false;
}
std::string govString;
get_governor_string(type,govString);
if(!set_string_in_file(path + "scaling_governor",govString))
{
return false;
}
unsigned long currKHz;
unsigned long currKHzUpper;
unsigned long currKHzLower;
cpu_frequency_type currType;
if(!get_frequency(currType,currKHz,currKHzUpper,currKHzLower))
{
return false;
}
if(khzUpper < currKHzLower)
{
if(!set_number_in_file(path + "scaling_min_freq",khzLower))
{
return false;
}
if(!set_number_in_file(path + "scaling_max_freq",khzUpper))
{
return false;
}
}
else
{
if(!set_number_in_file(path + "scaling_max_freq",khzUpper))
{
return false;
}
if(!set_number_in_file(path + "scaling_min_freq",khzLower))
{
return false;
}
}
if(type == UserSpace)
{
if(!set_number_in_file(path + "scaling_setspeed",khz))
{
return false;
}
}
return true;
}
unsigned long operator()(
SampleSource &sample_source, InputProperties const &input_properties,
void *output, unsigned long const num_output_samples, OutputProperties const &output_properties,
unsigned int const volume, unsigned int const max_volume
)
{
// prerequisites
unsigned int num_input_channels = get_num_channels(input_properties);
unsigned int num_output_channels = get_num_channels(output_properties);
unsigned int input_frequency = get_frequency(input_properties);
unsigned int output_frequency = get_frequency(output_properties);
if (input_frequency == 0) // if the input frequency is 0, then the sample source can adapt to the output frequency
input_frequency = output_frequency;
bool frequencies_match = (input_frequency == output_frequency);
bool num_channels_match = (num_input_channels == num_output_channels);
bool sample_types_match = get_sample_type(input_properties) == get_sample_type(output_properties);
// if the properties fully match, no processing is necessary - just transmit the samples directly to the output and exit
// do a volume processing if necessary, but otherwise its just one transmission
if (frequencies_match && sample_types_match && num_channels_match)
{
unsigned long num_retrieved_samples = retrieve_samples(sample_source, output, num_output_samples);
if (volume != max_volume)
{
sample_type output_sample_type = get_sample_type(output_properties);
for (unsigned long i = 0; i < num_retrieved_samples * num_output_channels; ++i)
{
set_sample_value(
output, i,
adjust_sample_volume(get_sample_value(output, i, output_sample_type), volume, max_volume),
output_sample_type
);
}
}
return num_retrieved_samples;
}
unsigned long num_retrieved_samples = 0;
uint8_t *resampler_input = 0;
sample_type dest_type = sample_unknown;
// note that this returns true if the resampler is in an uninitialized state
bool resampler_needed_more_input = is_more_input_needed_for(resampler, num_output_samples);
// first processing stage: convert samples & mix channels if necessary
// also, the resampler input is prepared here
// if resampling is necessary, and the resampler has enough input data for now, this stage is bypassed
if (frequencies_match || resampler_needed_more_input)
{
// with the adjusted value from above, retrieve samples from the sample source, and resize the buffer to the number of actually retrieved samples
// (since the sample source may have given us less samples than we requested)
unsigned long num_samples_to_retrieve = num_output_samples;
source_data_buffer.resize(num_samples_to_retrieve * num_input_channels * get_sample_size(get_sample_type(input_properties)));
num_retrieved_samples = retrieve_samples(sample_source, &source_data_buffer[0], num_samples_to_retrieve);
source_data_buffer.resize(num_retrieved_samples * num_input_channels * get_sample_size(get_sample_type(input_properties)));
// here, the dest and dest_type values are set, as well as the resampler input (if necessary)
// several optimizations are done here: if the resampler is not necessary, then dest points to the output - any conversion steps will write data directly to the output then
// if the resampler is necessary, and the sample types match, then the resampler's input is the source data buffer, otherwise it is the "dest" pointer
// the reason for this is: if the sample types match, no conversion step is necessary, and the resampler can pull data directly from the source data buffer;
// otherwise, the conversion step needs to convert to an intermediate buffer (the buffer the dest pointer points at), and then the resampler pulls data from this buffer
uint8_t *dest;
if (frequencies_match)
{
// frequencies match - dest is set to point at the output, meaning that the next step will directly write to the output
dest_type = get_sample_type(output_properties);
dest = reinterpret_cast < uint8_t* > (output);
}
else
{
// frequencies do not match, resampling is necessary - dest is set to point at an intermediate buffer, which the resampler will use
// ask the resampler what resampling input type it needs - this may differ from the output properties' sample type, but this is ok,
// since with resampling, an intermediate step between sample type conversion & mixing and actual output is present anyway
dest_type = find_compatible_type(resampler, get_sample_type(input_properties));
if (sample_types_match && num_channels_match)
{
// if the sample types and channel count match, then no conversion step is necessary, and the resampler can pull data from the source data buffer directly
resampler_input = &source_data_buffer[0];
dest = 0;
}
else
{
// if the sample types and channel count do not match, then the resampler needs to pull data from the intermediate buffer dest points to
// the conversion step will write to dest
resampling_input_buffer.resize(num_output_samples * num_output_channels * get_sample_size(dest_type));
dest = &resampling_input_buffer[0];
resampler_input = dest;
}
}
// actual mixing and conversion is done here
if (num_channels_match)
{
// channel counts match, no mixing necessary
if (!sample_types_match)
{
assert(dest != 0);
// sample types do not match
// go through all the input samples, convert them, and write them to dest
for (unsigned long i = 0; i < num_retrieved_samples * num_input_channels; ++i)
{
set_sample_value(
dest, i,
convert_sample_value(
get_sample_value(&source_data_buffer[0], i, get_sample_type(input_properties)),
get_sample_type(input_properties), dest_type
),
dest_type
);
}
}
// if the sample types match, nothing needs to be done here
}
else
{
// channels count do not match - call the mixer
mix_channels(&source_data_buffer[0], dest, num_retrieved_samples, get_sample_type(input_properties), dest_type, get_num_channels(input_properties), get_num_channels(output_properties));
}
}
else
{
// either resampling is not necessary, or the resampler does not need any new input for now
// set number of retrieved samples to number of output samples, and if resampling is necessary, set the dest_type value
num_retrieved_samples = num_output_samples;
// the dest_type value is set, since the resampler might reset itself if it sees a change in the input type
if (!frequencies_match)
dest_type = find_compatible_type(resampler, get_sample_type(input_properties));
}
// the final stage adjusts the output volume; if the volume equals the max volume, it is unnecessary
// this boolean conditionally enables this stage
bool do_volume_stage = (volume != max_volume);
// second processing stage: resample if necessary (otherwise this stage is bypassed)
if (!frequencies_match)
{
sample_type resampler_input_type = dest_type;
// the resampler may have only support for a fixed number of sample types - let it choose a suitable output one
sample_type resampler_output_type = find_compatible_type(resampler, resampler_input_type, get_sample_type(output_properties));
sample_type output_type = get_sample_type(output_properties);
bool conversion_needed = (resampler_output_type != output_type);
uint8_t *resampler_output = reinterpret_cast < uint8_t* > (output);
if (conversion_needed)
{
resampling_output_buffer.resize(num_output_samples * num_output_channels * get_sample_size(resampler_output_type));
resampler_output = &resampling_output_buffer[0];
}
// resampler input -can- be zero - sometimes the resampler does not need any more input
assert(!resampler_needed_more_input || (resampler_input != 0));
// call the actual resampler, which returns the number of samples that were actually sent to output
// if this is the first call since the resampler was reset(), this call internally initializes the resampler
// and sets its internal values to the given ones
// note that the is_more_input_needed_for() call returns true if the resampler is in such an uninitialized state
// if the resampler was initialized already, it may reinitialize itself internally if certain parameters change
// (this is entirely implementation-dependent; from the outside, no such reinitialization is noticeable)
num_retrieved_samples = resample(
resampler,
resampler_input, num_retrieved_samples,
resampler_output, num_output_samples,
input_frequency, output_frequency,
resampler_input_type, resampler_output_type,
num_output_channels
);
// the output type chosen by the resampler may not match the output type given by the output properties, so a final conversion step may be necessary
if (conversion_needed)
{
if (do_volume_stage)
{
// if the volume stage is required, use the opportunity to do it together with the final conversion step
for (unsigned long i = 0; i < num_retrieved_samples * num_output_channels; ++i)
{
set_sample_value(
output, i,
adjust_sample_volume(
get_sample_value(resampler_output, i, resampler_output_type),
volume, max_volume
),
output_type
);
}
// volume adjustment was done in-line in the conversion step above -> no further volume adjustment required
do_volume_stage = false;
}
else
{
// conversion without volume adjustment
for (unsigned long i = 0; i < num_retrieved_samples * num_output_channels; ++i)
set_sample_value(output, i, get_sample_value(resampler_output, i, output_type), output_type);
}
}
}
// do the volume stage if required
if (do_volume_stage)
{
sample_type output_sample_type = get_sample_type(output_properties);
for (unsigned long i = 0; i < num_retrieved_samples * num_output_channels; ++i)
{
set_sample_value(
output, i,
adjust_sample_volume(get_sample_value(output, i, output_sample_type), volume, max_volume),
output_sample_type
);
}
}
// finally, return the number of retrieved samples, either from the resampler, or from the source directly,
// depending on whether or not resampling was necessary
return num_retrieved_samples;
}
