/*
* The main procedure is similar to the main found in ARITH1E.C. It has
* to initialize the coder and the model. It then sits in a loop reading
* input symbols and encoding them. One difference is that every 256
* symbols a compression check is performed. If the compression ratio
* falls below 10%, a flush character is encoded. This flushes the encod
* ing model, and will cause the decoder to flush its model when the
* file is being expanded. The second difference is that each symbol is
* repeatedly encoded until a successful encoding occurs. When trying to
* encode a character in a particular order, the model may have to
* transmit an ESCAPE character. If this is the case, the character has
* to be retransmitted using a lower order. This process repeats until a
* successful match is found of the symbol in a particular context.
* Usually this means going down no further than the order -1 model.
* However, the FLUSH and DONE symbols drop back to the order -2 model.
*
*/
void CompressFile(FILE *input,BIT_FILE *output,int argc,char *argv[])
{
SYMBOL s;
int c;
int escaped;
int flush = 0;
long int text_count = 0;
initialize_options( argc, argv );
initialize_model();
initialize_arithmetic_encoder();
for ( ; ; ) {
if ( ( ++text_count & 0x0ff ) == 0 )
flush = check_compression( input, output );
if ( !flush )
c = getc( input );
else
c = FLUSH;
if ( c == EOF )
c = DONE;
do {
escaped = convert_int_to_symbol( c, &s);
encode_symbol( output, &s );
} while ( escaped );
if ( c == DONE )
break;
if ( c == FLUSH ) {
flush_model();
flush = 0;
}
update_model( c );
add_character_to_model( c );
}
flush_arithmetic_encoder( output );
}
/**
* @brief Fills the fields from the existing entity.
*/
void EditEntityDialog::initialize() {
initialize_simple_booleans();
initialize_simple_integers();
initialize_simple_strings();
initialize_behavior();
initialize_breed();
initialize_damage_on_enemies();
initialize_destination();
initialize_destination_map();
initialize_direction();
initialize_font();
initialize_ground();
initialize_layer();
initialize_maximum_moves();
initialize_model();
initialize_name();
initialize_opening_method();
initialize_rank();
initialize_savegame_variable();
initialize_size();
initialize_sound();
initialize_sprite();
initialize_subtype();
initialize_transition();
initialize_treasure();
initialize_type();
initialize_weight();
initialize_xy();
adjustSize();
}
inline bool process_terrain(Memory *memory, TerrainChunk *chunk, int detail_level) {
Model *model = chunk->models + detail_level;
if (model->state == AssetState::INITIALIZED) {
return false;
}
if (model->state == AssetState::HAS_DATA) {
initialize_model(model);
return true;
}
if (platform.queue_has_free_spot(memory->main_queue)) {
if (model->state == AssetState::EMPTY) {
auto *work = (GenerateGrountWorkData*)(malloc(sizeof(GenerateGrountWorkData)));
work->chunk = chunk;
work->detail_level = detail_level;
platform.add_work(memory->main_queue, generate_ground_work, work);
return true;
}
}
return true;
}
/*
* The main loop for expansion is very similar to the expansion
* routine used in the simpler compression program, ARITH1E.C. The
* routine first has to initialize the the arithmetic coder and the
* model. The decompression loop differs in a couple of respect.
* First of all, it handles the special ESCAPE character, by
* removing them from the input bit stream but just throwing them
* away otherwise. Secondly, it handles the special FLUSH character.
* Once the main decoding loop is done, the cleanup code is called,
* and the program exits.
*
*/
void ExpandFile(BIT_FILE *input,FILE *output,int argc,char *argv[])
{
SYMBOL s;
int c;
int count;
initialize_options( argc, argv );
initialize_model();
initialize_arithmetic_decoder( input );
for ( ; ; ) {
do {
get_symbol_scale( &s );
count = get_current_count( &s );
c = convert_symbol_to_int( count, &s );
remove_symbol_from_stream( input, &s );
} while ( c == ESCAPE );
if ( c == DONE )
break;
if ( c != FLUSH )
putc( (char) c, output );
else
flush_model();
update_model( c );
add_character_to_model( c );
}
}
lsh::lsh(uint64_t base_num)
: base_num_(base_num) {
if (base_num == 0) {
throw JUBATUS_EXCEPTION(common::exception::runtime_error("base_num == 0"));
}
initialize_model();
}
lsh::lsh(uint64_t hash_num)
: hash_num_(hash_num) {
if (!(1 <= hash_num)) {
throw JUBATUS_EXCEPTION(
common::invalid_parameter("1 <= hash_num"));
}
initialize_model();
}
lsh::lsh(const config& config)
: hash_num_(config.hash_num) {
if (!(1 <= config.hash_num)) {
throw JUBATUS_EXCEPTION(
common::invalid_parameter("1 <= hash_num"));
}
initialize_model();
}
int
main (int argc, char *argv[])
{
GtkWidget *window;
GtkWidget *vbox;
GtkWidget *scrolled_window;
GtkWidget *tree_view;
GtkWidget *hbox;
GtkWidget *button;
GtkTreePath *path;
gtk_init (&argc, &argv);
path = gtk_tree_path_new_from_string ("80");
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_title (GTK_WINDOW (window), "Reflow test");
g_signal_connect (window, "destroy", gtk_main_quit, NULL);
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 8);
gtk_container_set_border_width (GTK_CONTAINER (vbox), 8);
gtk_box_pack_start (GTK_BOX (vbox), gtk_label_new ("Incremental Reflow Test"), FALSE, FALSE, 0);
gtk_container_add (GTK_CONTAINER (window), vbox);
scrolled_window = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_AUTOMATIC);
gtk_box_pack_start (GTK_BOX (vbox), scrolled_window, TRUE, TRUE, 0);
initialize_model ();
tree_view = gtk_tree_view_new_with_model (model);
gtk_tree_view_scroll_to_cell (GTK_TREE_VIEW (tree_view), path, NULL, TRUE, 0.5, 0.0);
selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (tree_view));
gtk_tree_selection_select_path (selection, path);
gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (tree_view), FALSE);
gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (tree_view),
-1,
NULL,
gtk_cell_renderer_text_new (),
"text", TEXT_COLUMN,
NULL);
gtk_container_add (GTK_CONTAINER (scrolled_window), tree_view);
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
button = gtk_button_new_with_mnemonic ("<b>_Futz!!</b>");
gtk_box_pack_start (GTK_BOX (hbox), button, FALSE, FALSE, 0);
gtk_label_set_use_markup (GTK_LABEL (gtk_bin_get_child (GTK_BIN (button))), TRUE);
g_signal_connect (button, "clicked", G_CALLBACK (futz), NULL);
g_signal_connect (button, "realize", G_CALLBACK (gtk_widget_grab_focus), NULL);
gtk_window_set_default_size (GTK_WINDOW (window), 300, 400);
gtk_widget_show_all (window);
gdk_threads_add_timeout (1000, (GSourceFunc) futz, NULL);
gtk_main ();
return 0;
}
void init_common(AVCodecContext *avctx, MscCodecContext *mscContext) {
ff_dsputil_init(&mscContext->dsp, avctx);
mscContext->mb_width = (avctx->width + 15) / 16;
mscContext->mb_height = (avctx->height + 15) / 16;
initialize_model(&mscContext->arithModelIndexCodingModel, 4);
initialize_model(&mscContext->lastZeroCodingModel, 6);
/*
* Initialize arithmetic coder models. First model: arithModels[0],
* can store 0, 1 values (2^1). Second one arithModels[1], 0, 1, 2, 3
* (2^2) and so on.
*/
for (int i = 0; i < 10; ++i) {
initialize_model(&mscContext->arithModels[i], i + 1);
mscContext->arithModelAddValue[i] = pow(2, i) - 1;
}
mscContext->referenceFrame = avcodec_alloc_frame();
if (!mscContext->referenceFrame) {
av_log(avctx, AV_LOG_ERROR, "Could not allocate frame.\n");
}
}
lsh::lsh()
: hash_num_(DEFAULT_HASH_NUM) {
initialize_model();
}
/* ==== */
static void
initialize_wl(void)
{
int bins,fnlen=512;
char *res_string=NULL;
double low,high,lo,hi,hmin,hmax,erange,*range = NULL;
srand(time(NULL));
if(wanglandau_opt.verbose){
printf("[[initialize_wl()]]\n");
}
/* assign function pointers */
initialize_model = initialize_RNA; /* for RNA */
pre_process_model = pre_process_RNA;
post_process_model = post_process_RNA;
/* set energy paramters for current model; compute mfe */
initialize_model(wanglandau_opt.sequence);
range = (double*)calloc((wanglandau_opt.bins+1), sizeof(double));
assert(range!=NULL);
/* initialize histograms */
hmin=mfe;
if(wanglandau_opt.res_given){ /* determine histogram ranges manually */
int i;
range[0]=mfe;
for(i=1;i<=wanglandau_opt.bins;i++){
range[i]=range[i-1]+wanglandau_opt.res;
}
if(wanglandau_opt.verbose){
/* info output */
fprintf(stderr,"#allocating %lu bins of width %g\n",
wanglandau_opt.bins,wanglandau_opt.res);
/* fprintf(stderr,"#histogram ranges:\n #");
for(i=0;i<=wanglandau_opt.bins;i++){
fprintf(stderr, "%6.2f ",range[i]);
}
fprintf(stderr,"\n");
*/
}
if(wanglandau_opt.max_given){
hmax=wanglandau_opt.max;
}
else{
wanglandau_opt.max=range[wanglandau_opt.bins]; /* the last element */
hmax=wanglandau_opt.max;
}
h = gsl_histogram_alloc(wanglandau_opt.bins);
g = gsl_histogram_alloc(wanglandau_opt.bins);
s = gsl_histogram_alloc(wanglandau_opt.bins);
gsl_histogram_set_ranges(h,range,(wanglandau_opt.bins+1));
gsl_histogram_set_ranges(g,range,(wanglandau_opt.bins+1));
gsl_histogram_set_ranges(s,range,(wanglandau_opt.bins+1));
}
else{ /* determine histogram ranges automatically */
if(wanglandau_opt.max_given){
hmax = wanglandau_opt.max;
}
else{
hmax=20*fabs(mfe);
}
h = ini_histogram_uniform(wanglandau_opt.bins,hmin,hmax);
g = ini_histogram_uniform(wanglandau_opt.bins,hmin,hmax);
s = ini_histogram_uniform(wanglandau_opt.bins,hmin,hmax);
}
fprintf (stderr, "# sampling energy range is %6.2f - %6.2f\n",
hmin,hmax);
free(range);
/* get the energy range up to which we will compute true DOS via
RNAsubopt */
gsl_histogram_get_range(s,0,&lo,&hi);
low = lo;
gsl_histogram_get_range(s,(wanglandau_opt.truedosbins-1),&lo,&hi);
high = hi;
wanglandau_opt.erange=(float)fabs(mfe-high+0.01);
if(wanglandau_opt.verbose){
printf("Using true DOS for bins 0-%d: (%6.3g -- %6.3g) wl_opt.erange=%6.3f\n",
(wanglandau_opt.truedosbins-1),low,high,wanglandau_opt.erange);
}
/* prepare gsl random-number generation */
(void) clock_gettime(CLOCK_REALTIME, &ts);
if(wanglandau_opt.seed_given){
seed = wanglandau_opt.seed;
}
else {
seed = ts.tv_sec ^ ts.tv_nsec;
}
fprintf(stderr, "initializing random seed: %d\n",seed);
gsl_rng_env_setup();
r = gsl_rng_alloc (gsl_rng_mt19937);
gsl_rng_set( r, seed );
/* end gsl */
/* make prefix for output */
out_prefix = (char*)calloc(fnlen, sizeof(char));
res_string = (char*)calloc(16, sizeof(char));
sprintf(res_string,"%3.1f", wanglandau_opt.res);
strcpy(out_prefix, wanglandau_opt.basename); strcat(out_prefix, ".res");
strcat(out_prefix, res_string); strcat(out_prefix, ".");
free(res_string);
return;
}
/* We first try to grab the global lock in read mode to check whether the model
* was loaded or not (this is very likely to have been already loaded). If the
* model was not loaded yet, we take the lock in write mode, and if the model
* is still not loaded once we have the lock, we do load it. */
static void load_history_based_model(struct starpu_perfmodel_t *model, unsigned scan_history)
{
STARPU_ASSERT(model);
STARPU_ASSERT(model->symbol);
int already_loaded;
PTHREAD_RWLOCK_RDLOCK(®istered_models_rwlock);
already_loaded = model->is_loaded;
PTHREAD_RWLOCK_UNLOCK(®istered_models_rwlock);
if (already_loaded)
return;
/* The model is still not loaded so we grab the lock in write mode, and
* if it's not loaded once we have the lock, we do load it. */
PTHREAD_RWLOCK_WRLOCK(®istered_models_rwlock);
/* Was the model initialized since the previous test ? */
if (model->is_loaded)
{
PTHREAD_RWLOCK_UNLOCK(®istered_models_rwlock);
return;
}
PTHREAD_RWLOCK_INIT(&model->model_rwlock, NULL);
PTHREAD_RWLOCK_WRLOCK(&model->model_rwlock);
/* make sure the performance model directory exists (or create it) */
_starpu_create_sampling_directory_if_needed();
/*
* We need to keep track of all the model that were opened so that we can
* possibly update them at runtime termination ...
*/
_starpu_register_model(model);
char path[256];
get_model_path(model, path, 256);
_STARPU_DEBUG("Opening performance model file %s for model %s ... ", path, model->symbol);
unsigned calibrate_flag = _starpu_get_calibrate_flag();
model->benchmarking = calibrate_flag;
/* try to open an existing file and load it */
int res;
res = access(path, F_OK);
if (res == 0) {
if (calibrate_flag == 2)
{
/* The user specified that the performance model should
* be overwritten, so we don't load the existing file !
* */
_STARPU_DEBUG("Overwrite existing file\n");
initialize_model(model);
}
else {
/* We load the available file */
_STARPU_DEBUG("File exists\n");
FILE *f;
f = fopen(path, "r");
STARPU_ASSERT(f);
parse_model_file(f, model, scan_history);
fclose(f);
}
}
else {
_STARPU_DEBUG("File does not exists\n");
if (!calibrate_flag) {
_STARPU_DISP("Warning: model %s is not calibrated, forcing calibration for this run. Use the STARPU_CALIBRATE environment variable to control this.\n", model->symbol);
_starpu_set_calibrate_flag(1);
model->benchmarking = 1;
}
initialize_model(model);
}
model->is_loaded = 1;
PTHREAD_RWLOCK_UNLOCK(&model->model_rwlock);
PTHREAD_RWLOCK_UNLOCK(®istered_models_rwlock);
}
/*
Purpose: animate and run the game with the clock
Input : a char length pointer to the frame buffer and a long length pointer to the frame buffer
Returns: nothing, but constantly runs the game and its functions
Assume : nothing
*/
void animate_main(char *base,long *iBase)
{
long *back,*temp;
int musicCounter = 0;
int enMisCount = 0;
int plMisCount = 0;
int x,y = 0;
long clock;
long newClock;
int mouseClicked = 0;
unsigned short mouseX,mouseY;
int i= 0,j = 0,k = 0,l = 0;
int randX,randY,randX2;
int fire = 0;
int s = 0;
int done = 0;
int render = 0;
struct missile friendlyMis[NUM_MISSILES];
struct missile enemyMis[NUM_MISSILES];
struct explosion explosions[NUM_EXPLOSIONS];
struct missile_Silo silo;
struct city city1;
struct city city2;
struct city city3;
struct city city4;
struct city city5;
struct city city6;
int *music = get_music();
Vector original_Vector;
/*start the music*/
stop_sound();
start_music();
/*init ther model*/
initialize_model(&city1,&city2,&city3,&city4,&city5,&city6,&silo,friendlyMis,enemyMis,explosions);
/*create the backbuffer*/
back = (long *)(buffer + (256 -((long)&buffer)%256));
init_VBL_ISR(original_Vector);
while(done == 0)
{
/*random values for enemy missiles*/
randX = rand() % BORDER_RIGHT + 16;
randX2 = rand() % BORDER_RIGHT + 16;
randY = rand() % GROUND_LEVEL - 200;
/* needs to fire a player missile at the mouse click coordinates */
if (mouseClicked == TRUE)
{ /* process on input */
if (k > NUM_MISSILES-1)
{
k = 0;
}
if (friendlyMis[k].destroyed == TRUE)
{
friendlyMis[k].destroyed = FALSE;
friendlyMis[k].currentY = GROUND_LEVEL-20;
friendly_Missile_Fired(mouseX,mouseY, &friendlyMis[k],MISSILE_SILO_FIRING_POINT);
missile_fired_sound();
k++;
}
}
clock = clockGet();
if (clock != newClock)
{ /* process on clock change */
fire++;
if(fire == MISSILE_FIRED_TIME)
{
enemyMis[j].destroyed = FALSE;
enemy_Missile_Fired(randX, GROUND_LEVEL, &enemyMis[j],randX2);
j++;
if(fire == MISSILE_FIRED_TIME)
{
fire = 0;
}
if (j == NUM_MISSILES-1)
{
j = 0;
}
}
mouseClicked = get_mouse_pos(&mouseX,&mouseY);
if(render == 1)
{
render_main(back, city1, city2, city3, city4, city5, city6, silo, enemyMis,friendlyMis, explosions,mouseX,mouseY,render);
}
/* T */
temp = iBase;
iBase = back;
back = temp;
/* wait for sync and then set the screen to the current buffer */
set_video_base_wrap((char *)iBase);
/* process missiles
might need to change to be able to handle more */
for (i = 0; i < NUM_MISSILES; i++)
{
if (enemyMis[i].destroyed == FALSE && explosions[i].exists == FALSE)
{
processEnemyMissiles(&enemyMis[i],&explosions[i],clock,ENEMY_SPEED);
}
if (friendlyMis[i].destroyed == FALSE && explosions[i+NUM_MISSILES].exists == FALSE)
{
processEnemyMissiles(&friendlyMis[i],&explosions[i+NUM_MISSILES],clock,FRIENDLY_SPEED);
}
}
/* process explosions
might need to change to be able to handle more */
for (i = 0; i < NUM_EXPLOSIONS; i++)
{
if (explosions[i].exists == TRUE)
{
processExplosions(&explosions[i]);
}
}
/* process missile -> explosion collisions */
for (i = NUM_MISSILES; i < NUM_EXPLOSIONS; i++)
{
if (explosions[i].exists == TRUE)
{
processCollisions(friendlyMis,enemyMis,explosions[i]);
}
}
/* process explosion -> city explosions */
for (i = 0; i < NUM_MISSILES; i++)
{
if (explosions[i].hit_city != FALSE)
{
city_collision(explosions[i].hit_city,&city1,&city2,&city3,&city4,&city5,&city6);
}
}
if (musicCounter < SONG_LENGTH){
if (fire % 4 == 0)
{
play_music(music[musicCounter]);
musicCounter++;
}
}
else
{
musicCounter = 0;
}
}
newClock = clockGet();
done = game_over(city1,city2,city3,city4,city5,city6);
}
stop_sound();
}
lsh::lsh()
: base_num_(DEFAULT_BASE_NUM) {
initialize_model();
}
lsh::lsh(const config& config)
: base_num_(config.hash_num) {
initialize_model();
}