preset.c

video linux conference

  if (pathname == NULL)
	  return FAILURE;
  if (preset == NULL)
	  return FAILURE;
  
  /* Open the file corresponding to pathname */
  if ((fs = fopen(pathname, "r")) == 0) {
    if (PRESET_DEBUG) printf("load_preset_file: loading of file %s failed!\n", pathname);
    return ERROR;	
  }

  if (PRESET_DEBUG) printf("load_preset_file: file stream \"%s\" opened successfully\n", pathname);

  /* Parse any comments */
  if (parse_top_comment(fs) < 0) {
    if (PRESET_DEBUG) printf("load_preset_file: no left bracket found...\n");
    fclose(fs);
    return FAILURE;
  }
  
  /* Parse the preset name and a left bracket */
  if (parse_preset_name(fs, preset->name) < 0) {
    if (PRESET_DEBUG) printf("load_preset_file: loading of preset name in file \"%s\" failed\n", pathname);
    fclose(fs);
    return ERROR;
  }
  
  if (PRESET_DEBUG) printf("load_preset_file: preset \"%s\" parsed\n", preset->name);

  /* Parse each line until end of file */
  if (PRESET_DEBUG) printf("load_preset_file: beginning line parsing...\n");
  while ((retval = parse_line(fs, preset)) != EOF) {
    if (retval == PARSE_ERROR) {
      if (PRESET_DEBUG > 1) printf("load_preset_file: parse error in file \"%s\"\n", pathname);
    }
  }
  
  if (PRESET_DEBUG) printf("load_preset_file: finished line parsing successfully\n"); 

  /* Now the preset has been loaded.
     Evaluation calls can be made at appropiate
     times in the frame loop */
  
  fclose(fs);
   
  if (PRESET_DEBUG) printf("load_preset_file: file \"%s\" closed, preset ready\n", pathname);
  return SUCCESS;
  
}

void evalInitConditions() {
  splay_traverse(eval_init_cond, active_preset->init_cond_tree);
  splay_traverse(eval_init_cond, active_preset->per_frame_init_eqn_tree);
}

void evalPerFrameEquations() {
  splay_traverse(eval_per_frame_eqn, active_preset->per_frame_eqn_tree);
}

void evalPerFrameInitEquations() {
  //printf("evalPerFrameInitEquations: per frame init unimplemented!\n");
  //  splay_traverse(eval_per_frame_eqn, active_preset->per_frame_init_eqn_tree);
}	

/* Returns nonzero if string 'name' contains .milk or
   (the better) .prjm extension. Not a very strong function currently */
int is_valid_extension(char * name) {

	if (PRESET_DEBUG > 1) {
		printf("is_valid_extension: scanning string \"%s\"...", name);
		fflush(stdout);
	}

	if (strstr(name, MILKDROP_FILE_EXTENSION)) {
			if (PRESET_DEBUG > 1) printf("\".milk\" extension found in string [true]\n");
			return TRUE;
	}	
	
	if (strstr(name, PROJECTM_FILE_EXTENSION)) {
		    if (PRESET_DEBUG > 1) printf("\".prjm\" extension found in string [true]\n");
			return TRUE;
	}
	 
	if (PRESET_DEBUG > 1) printf("no valid extension found [false]\n");
	return FALSE;
}

/* Private function to close a preset file */
int close_preset(preset_t * preset) {

  if (preset == NULL)
    return FAILURE;


  splay_traverse(free_init_cond, preset->init_cond_tree);
  destroy_splaytree(preset->init_cond_tree);
  
  splay_traverse(free_init_cond, preset->per_frame_init_eqn_tree);
  destroy_splaytree(preset->per_frame_init_eqn_tree);
  
  splay_traverse(free_per_pixel_eqn, preset->per_pixel_eqn_tree);
  destroy_splaytree(preset->per_pixel_eqn_tree);
  
  splay_traverse(free_per_frame_eqn, preset->per_frame_eqn_tree);
  destroy_splaytree(preset->per_frame_eqn_tree);
  
  splay_traverse(free_param, preset->user_param_tree);
  destroy_splaytree(preset->user_param_tree);
  
  splay_traverse(free_custom_wave, preset->custom_wave_tree);
  destroy_splaytree(preset->custom_wave_tree);

  splay_traverse(free_custom_shape, preset->custom_shape_tree);
  destroy_splaytree(preset->custom_shape_tree);

  free(preset); 
  
  return SUCCESS;

}

void reloadPerPixel(char *s, preset_t * preset) {
  
  FILE * fs;
  int slen;
  char c;
  int i;

  if (s == NULL)
    return;

  if (preset == NULL)
    return;

  /* Clear previous per pixel equations */
  splay_traverse(free_per_pixel_eqn, preset->per_pixel_eqn_tree);
  destroy_splaytree(preset->per_pixel_eqn_tree);
  preset->per_pixel_eqn_tree = create_splaytree(compare_int, copy_int, free_int);

  /* Convert string to a stream */
  fs = fmemopen (s, strlen(s), "r");

  while ((c = fgetc(fs)) != EOF) {
    ungetc(c, fs);
    parse_per_pixel_eqn(fs, preset);
  }

  fclose(fs);

  /* Clear string space */
  memset(preset->per_pixel_eqn_string_buffer, 0, STRING_BUFFER_SIZE);

  /* Compute length of string */
  slen = strlen(s);

  /* Copy new string into buffer */
  strncpy(preset->per_pixel_eqn_string_buffer, s, slen);

  /* Yet again no bounds checking */
  preset->per_pixel_eqn_string_index = slen;

  /* Finished */
 
  return;
}

/* Obviously unwritten */
void reloadPerFrameInit(char *s, preset_t * preset) {

}

void reloadPerFrame(char * s, preset_t * preset) {

  FILE * fs;
  int slen;
  char c;
  int eqn_count = 1;
  per_frame_eqn_t * per_frame;

  if (s == NULL)
    return;

  if (preset == NULL)
    return;

  /* Clear previous per frame equations */
  splay_traverse(free_per_frame_eqn, preset->per_frame_eqn_tree);
  destroy_splaytree(preset->per_frame_eqn_tree);
  preset->per_frame_eqn_tree = create_splaytree(compare_int, copy_int, free_int);

  /* Convert string to a stream */
  fs = fmemopen (s, strlen(s), "r");

  while ((c = fgetc(fs)) != EOF) {
    ungetc(c, fs);
    if ((per_frame = parse_per_frame_eqn(fs, eqn_count, preset)) != NULL) {
      splay_insert(per_frame, &eqn_count, preset->per_frame_eqn_tree);
      eqn_count++;
    }
  }

  fclose(fs);

  /* Clear string space */
  memset(preset->per_frame_eqn_string_buffer, 0, STRING_BUFFER_SIZE);

  /* Compute length of string */
  slen = strlen(s);

  /* Copy new string into buffer */
  strncpy(preset->per_frame_eqn_string_buffer, s, slen);

  /* Yet again no bounds checking */
  preset->per_frame_eqn_string_index = slen;

  /* Finished */
  printf("reloadPerFrame: %d eqns parsed succesfully\n", eqn_count-1);
  return;

}

preset_t * load_preset(char * pathname) {

  preset_t * preset;
  int i;

  /* Initialize preset struct */
  if ((preset = (preset_t*)malloc(sizeof(preset_t))) == NULL)
    return NULL;
   
  /* Initialize equation trees */
  preset->init_cond_tree = create_splaytree(compare_string, copy_string, free_string);
  preset->user_param_tree = create_splaytree(compare_string, copy_string, free_string);
  preset->per_frame_eqn_tree = create_splaytree(compare_int, copy_int, free_int);
  preset->per_pixel_eqn_tree = create_splaytree(compare_int, copy_int, free_int);
  preset->per_frame_init_eqn_tree = create_splaytree(compare_string, copy_string, free_string);
  preset->custom_wave_tree = create_splaytree(compare_int, copy_int, free_int);
  preset->custom_shape_tree = create_splaytree(compare_int, copy_int, free_int);

  memset(preset->per_pixel_flag, 0, sizeof(int)*NUM_OPS);

  /* Copy file path */  
  strncpy(preset->file_path, pathname, MAX_PATH_SIZE-1);
  
  /* Set initial index values */
  preset->per_pixel_eqn_string_index = 0;
  preset->per_frame_eqn_string_index = 0;
  preset->per_frame_init_eqn_string_index = 0;
  
  
  /* Clear string buffers */
  memset(preset->per_pixel_eqn_string_buffer, 0, STRING_BUFFER_SIZE);
  memset(preset->per_frame_eqn_string_buffer, 0, STRING_BUFFER_SIZE);
  memset(preset->per_frame_init_eqn_string_buffer, 0, STRING_BUFFER_SIZE);
  
  
  if (load_preset_file(pathname, preset) < 0) {
	if (PRESET_DEBUG) printf("load_preset: failed to load file \"%s\"\n", pathname);
	close_preset(preset);
	return NULL;
  }

  /* It's kind of ugly to reset these values here. Should definitely be placed in the parser somewhere */
  per_frame_eqn_count = 0;
  per_frame_init_eqn_count = 0;

  /* Finished, return new preset */
  return preset;
}

void savePreset(char * filename) {

  FILE * fs;

  if (filename == NULL)
    return;
  
  /* Open the file corresponding to pathname */
  if ((fs = fopen(filename, "w+")) == 0) {
    if (PRESET_DEBUG) printf("savePreset: failed to create filename \"%s\"!\n", filename);
    return;	
  }

  write_stream = fs;

  if (write_preset_name(fs) < 0) {
    write_stream = NULL;
    fclose(fs);
    return;
  }

  if (write_init_conditions(fs) < 0) {
    write_stream = NULL;
    fclose(fs);
    return;
  }

  if (write_per_frame_init_equations(fs) < 0) {
    write_stream = NULL;
    fclose(fs);
    return;
  }

  if (write_per_frame_equations(fs) < 0) {
    write_stream = NULL;
    fclose(fs);
    return;
  }

  if (write_per_pixel_equations(fs) < 0) {
    write_stream = NULL;
    fclose(fs);
    return;
  }
 
  write_stream = NULL;
  fclose(fs);

}

int write_preset_name(FILE * fs) {

  char s[256];
  int len;

  memset(s, 0, 256);

  if (fs == NULL)
    return FAILURE;

  /* Format the preset name in a string */
  sprintf(s, "[%s]\n", active_preset->name);

  len = strlen(s);

  /* Write preset name to file stream */
  if (fwrite(s, 1, len, fs) != len)
    return FAILURE;

  return SUCCESS;

}

int write_init_conditions(FILE * fs) {

  if (fs == NULL)
    return FAILURE;
  if (active_preset == NULL)
    return FAILURE;


  splay_traverse(write_init, active_preset->init_cond_tree);
  
  return SUCCESS;
}

void write_init(init_cond_t * init_cond) {

  char s[512];
  int len;

  if (write_stream == NULL)
    return;

  memset(s, 0, 512);

  if (init_cond->param->type == P_TYPE_BOOL)
    sprintf(s, "%s=%d\n", init_cond->param->name, init_cond->init_val.bool_val);

  else if (init_cond->param->type == P_TYPE_INT)    
    sprintf(s, "%s=%d\n", init_cond->param->name, init_cond->init_val.int_val);

  else if (init_cond->param->type == P_TYPE_DOUBLE)
    sprintf(s, "%s=%f\n", init_cond->param->name, init_cond->init_val.double_val);

  else { printf("write_init: unknown parameter type!\n"); return; }
  
  len = strlen(s);

  if ((fwrite(s, 1, len, write_stream)) != len)
    printf("write_init: failed writing to file stream! Out of disk space?\n");
  
}


int write_per_frame_init_equations(FILE * fs) {

  int len;

  if (fs == NULL)
    return FAILURE;
  if (active_preset == NULL)
    return FAILURE;
  
  len = strlen(active_preset->per_frame_init_eqn_string_buffer);

  if (fwrite(active_preset->per_frame_init_eqn_string_buffer, 1, len, fs) != len)
    return FAILURE;

  return SUCCESS;
}


int write_per_frame_equations(FILE * fs) {

  int len;

  if (fs == NULL)
    return FAILURE;
  if (active_preset == NULL)
    return FAILURE;

  len = strlen(active_preset->per_frame_eqn_string_buffer);

  if (fwrite(active_preset->per_frame_eqn_string_buffer, 1, len, fs) != len)
    return FAILURE;

  return SUCCESS;
}


int write_per_pixel_equations(FILE * fs) {

  int len;

  if (fs == NULL)
    return FAILURE;
  if (active_preset == NULL)
    return FAILURE;

  len = strlen(active_preset->per_pixel_eqn_string_buffer);

  if (fwrite(active_preset->per_pixel_eqn_string_buffer, 1, len, fs) != len)
    return FAILURE;

  return SUCCESS;
}


void load_init_conditions() {

  splay_traverse(load_init_cond, builtin_param_tree);

 
}

void load_init_cond(param_t * param) {

  init_cond_t * init_cond;
  value_t init_val;

  /* Don't count read only parameters as initial conditions */
  if (param->flags & P_FLAG_READONLY)
    return;

  /* If initial condition was not defined by the preset file, force a default one
     with the following code */
  if ((init_cond = splay_find(param->name, active_preset->init_cond_tree)) == NULL) {
    
    /* Make sure initial condition does not exist in the set of per frame initial equations */
    if ((init_cond = splay_find(param->name, active_preset->per_frame_init_eqn_tree)) != NULL)
      return;
    
    if (param->type == P_TYPE_BOOL)
      init_val.bool_val = 0;
    
    else if (param->type == P_TYPE_INT)
      init_val.int_val = *(int*)param->engine_val;

    else if (param->type == P_TYPE_DOUBLE)
      init_val.double_val = *(double*)param->engine_val;

    //printf("%s\n", param->name);
    /* Create new initial condition */
    if ((init_cond = new_init_cond(param, init_val)) == NULL)
      return;
    
    /* Insert the initial condition into this presets tree */
    if (splay_insert(init_cond, init_cond->param->name, active_preset->init_cond_tree) < 0) {
      free_init_cond(init_cond);
      return;
    }
    
  }
 
}

void load_custom_wave_init_conditions() {

  splay_traverse(load_custom_wave_init, active_preset->custom_wave_tree);

}

void load_custom_wave_init(custom_wave_t * custom_wave) {

  load_unspecified_init_conds(custom_wave);

}


void load_custom_shape_init_conditions() {

  splay_traverse(load_custom_shape_init, active_preset->custom_shape_tree);

}

void load_custom_shape_init(custom_shape_t * custom_shape) {
 
  load_unspecified_init_conds_shape(custom_shape);
 
}