eval.c

uclinux 下的vlc播放器源代码

	if (gen_expr == NULL)
		return NULL;
	gen_expr->type = type;
	gen_expr->item = item;	

	return gen_expr;
}

/* Frees a general expression */
int free_gen_expr(gen_expr_t * gen_expr) {

	if (gen_expr == NULL)
	 	return SUCCESS;
	
	switch (gen_expr->type) {
	case VAL_T:
		free_val_expr(gen_expr->item);
		break;
	case PREFUN_T:
		free_prefun_expr(gen_expr->item);
		break;
	case TREE_T:
		free_tree_expr(gen_expr->item);
		break;
	default:
		return FAILURE;
	}	

	free(gen_expr);
	return SUCCESS;

}


/* Frees a function in prefix notation */
int free_prefun_expr(prefun_expr_t * prefun_expr) {

	int i;
	if (prefun_expr == NULL)
		return SUCCESS;
	
	/* Free every element in expression list */
	for (i = 0 ; i < prefun_expr->num_args; i++) {
		free_gen_expr(prefun_expr->expr_list[i]);
	}

	free(prefun_expr);
	return SUCCESS;
}

/* Frees values of type VARIABLE and CONSTANT */
int free_val_expr(val_expr_t * val_expr) {

	if (val_expr == NULL)
		return SUCCESS;	
	
	free(val_expr);
	return SUCCESS;
}

/* Frees a tree expression */
int free_tree_expr(tree_expr_t * tree_expr) {

	if (tree_expr == NULL)
		return SUCCESS;
	
	/* free left tree */
	free_tree_expr(tree_expr->left);
	
	/* free general expression object */
	free_gen_expr(tree_expr->gen_expr);
	
	/* Note that infix operators are always
	   stored in memory unless the program 
	   exits, so we don't remove them here */
	
	/* free right tree */
	free_tree_expr(tree_expr->right);
	
	
	/* finally, free the struct itself */
	free(tree_expr);
	return SUCCESS;
}



/* Initializes all infix operators */
int init_infix_ops() {

	infix_add = new_infix_op(INFIX_ADD, 4);
	infix_minus = new_infix_op(INFIX_MINUS, 3);
	infix_div = new_infix_op(INFIX_DIV, 2);
	infix_or = new_infix_op(INFIX_OR, 5);
	infix_and = new_infix_op(INFIX_AND,4);
	infix_mod = new_infix_op(INFIX_MOD, 1);
	infix_mult = new_infix_op(INFIX_MULT, 2);
	
	/* Prefix operators */
	infix_positive = new_infix_op(INFIX_ADD, 0);
	infix_negative = new_infix_op(INFIX_MINUS, 0);

	return SUCCESS;
}

/* Destroys the infix operator list. This should
   be done on program exit */
int destroy_infix_ops()
{

  free(infix_add);
  free(infix_minus);
  free(infix_div);
  free(infix_or);
  free(infix_and);
  free(infix_mod);
  free(infix_mult);
  free(infix_positive);
  free(infix_negative);

  return SUCCESS;
}

/* Initializes an infix operator */
infix_op_t * new_infix_op(int type, int precedence) {

	infix_op_t * infix_op;
	
	infix_op = (infix_op_t*)malloc(sizeof(infix_op_t));
	
	if (infix_op == NULL)
		return NULL;
	
	infix_op->type = type;
	infix_op->precedence = precedence;
	
	return infix_op;
}




/* Clones a general expression */
gen_expr_t * clone_gen_expr(gen_expr_t * gen_expr) {

  gen_expr_t * new_gen_expr;
  val_expr_t * val_expr;
  tree_expr_t * tree_expr;
  prefun_expr_t * prefun_expr;

  /* Null argument check */
  if (gen_expr == NULL)
    return NULL;

  /* Out of memory */
  if ((new_gen_expr = (gen_expr_t*)malloc(sizeof(gen_expr_t))) == NULL)
    return NULL;

  /* Case on the type of general expression */
  switch (new_gen_expr->type = gen_expr->type) {

  case VAL_T: /* val expression */
    if ((val_expr = clone_val_expr((val_expr_t*)gen_expr->item)) == NULL) {
      free(new_gen_expr);
      return NULL;
    }
    new_gen_expr->item = (void*)val_expr;
    break;
    
  case PREFUN_T: /* prefix function expression */
    if ((prefun_expr = clone_prefun_expr((prefun_expr_t*)gen_expr->item)) == NULL) {
      free(new_gen_expr);
      return NULL;
    }
    new_gen_expr->item = (void*)prefun_expr;
    break;
    
  case TREE_T:  /* tree expression */
    if ((tree_expr = clone_tree_expr((tree_expr_t*)gen_expr->item)) == NULL) {
      free(new_gen_expr);
      return NULL;
    }
    new_gen_expr->item = (void*)tree_expr;
    break;
    
  default: /* unknown type, ut oh.. */
    free(new_gen_expr);
    return NULL;
  }
  
  return new_gen_expr; /* Return the new (cloned) general expression */
}


/* Clones a tree expression */
tree_expr_t * clone_tree_expr(tree_expr_t * tree_expr) {

  tree_expr_t * new_tree_expr;

  /* Null argument */
  if (tree_expr == NULL)
    return NULL;
  
  /* Out of memory */
  if ((new_tree_expr = (tree_expr_t*)malloc(sizeof(tree_expr_t))) == NULL) 
    return NULL;
  
  /* Set each argument in tree_expr_t struct */
  new_tree_expr->infix_op = tree_expr->infix_op;  /* infix operators are in shared memory */
  new_tree_expr->gen_expr = clone_gen_expr(tree_expr->gen_expr); /* clone the general expression */
  new_tree_expr->left = clone_tree_expr(tree_expr->left); /* clone the left tree expression */
  new_tree_expr->right = clone_tree_expr(tree_expr->right); /* clone the right tree expression */

  return new_tree_expr; /* Return the new (cloned) tree expression */
}

/* Clones a value expression, currently only passes the pointer to 
   the value that this object represents, not a pointer to a copy of the value */
val_expr_t * clone_val_expr(val_expr_t * val_expr) {

  val_expr_t * new_val_expr;

  /* Null argument */
  if (val_expr == NULL)
    return NULL;
  
  /* Allocate space, check for out of memory */
  if ((new_val_expr = (val_expr_t*)malloc(sizeof(val_expr_t))) == NULL) 
    return NULL;

  /* Set the values in the val_expr_t struct */
  new_val_expr->type = val_expr->type;
  new_val_expr->term = val_expr->term;
  
  /* Return the new (cloned) value expression */
  return new_val_expr;
}

/* Clones a prefix function with its arguments */
prefun_expr_t * clone_prefun_expr(prefun_expr_t * prefun_expr) {

  int i;
  prefun_expr_t * new_prefun_expr;
  
  /* Null argument */
  if (prefun_expr == NULL)
    return NULL;
  
  /* Out of memory */
  if ((new_prefun_expr = (prefun_expr_t*)malloc(sizeof(prefun_expr_t))) == NULL) 
    return NULL;
  
  /* Set the function argument paired with its number of arguments */
  new_prefun_expr->num_args = prefun_expr->num_args;
  new_prefun_expr->func_ptr = prefun_expr->func_ptr;

  /* Allocate space for the expression list pointers */
  if ((new_prefun_expr->expr_list = (gen_expr_t**)malloc(sizeof(gen_expr_t*)*new_prefun_expr->num_args)) == NULL) {
    free(new_prefun_expr);
    return NULL;
  }

  /* Now copy each general expression from the argument expression list */
  for (i = 0; i < new_prefun_expr->num_args;i++) 
    new_prefun_expr->expr_list[i] = clone_gen_expr(prefun_expr->expr_list[i]);
  
  /* Finally, return the new (cloned) prefix function expression */
  return new_prefun_expr;
}

/* Reinitializes the engine variables to a default (conservative and sane) value */
void reset_engine_vars() {

  zoom=1.0;
  zoomexp= 1.0;
  rot= 0.0;
  warp= 0.0;
  
  sx= 1.0;
  sy= 1.0;
  dx= 0.0;
  dy= 0.0;
  cx= 0.5;
  cy= 0.5;

  
  decay=.98;
  
  wave_r= 1.0;
  wave_g= 0.2;
  wave_b= 0.0;
  wave_x= 0.5;
  wave_y= 0.5;
  wave_mystery= 0.0;

  ob_size= 0.0;
  ob_r= 0.0;
  ob_g= 0.0;
  ob_b= 0.0;
  ob_a= 0.0;

  ib_size = 0.0;
  ib_r = 0.0;
  ib_g = 0.0;
  ib_b = 0.0;
  ib_a = 0.0;

  mv_a = 0.0;
  mv_r = 0.0;
  mv_g = 0.0;
  mv_b = 0.0;
  mv_l = 1.0;
  mv_x = 16.0;
  mv_y = 12.0;
  mv_dy = 0.02;
  mv_dx = 0.02;
  
  meshx = 0;
  meshy = 0;
 
  Time = 0;
  treb = 0;
  mid = 0;
  bass = 0;
  treb_att = 0;
  mid_att = 0;
  bass_att = 0;
  progress = 0;
  frame = 0;

// bass_thresh = 0;

/* PER_FRAME CONSTANTS END */
  fRating = 0;
  fGammaAdj = 1.0;
  fVideoEchoZoom = 1.0;
  fVideoEchoAlpha = 0;
  nVideoEchoOrientation = 0;
 
  nWaveMode = 7;
  bAdditiveWaves = 0;
  bWaveDots = 0;
  bWaveThick = 0;
  bModWaveAlphaByVolume = 0;
  bMaximizeWaveColor = 0;
  bTexWrap = 0;
  bDarkenCenter = 0;
  bRedBlueStereo = 0;
  bBrighten = 0;
  bDarken = 0;
  bSolarize = 0;
 bInvert = 0;
 bMotionVectorsOn = 1;
 
  fWaveAlpha =1.0;
  fWaveScale = 1.0;
  fWaveSmoothing = 0;
  fWaveParam = 0;
  fModWaveAlphaStart = 0;
  fModWaveAlphaEnd = 0;
  fWarpAnimSpeed = 0;
  fWarpScale = 0;
  fShader = 0;


/* PER_PIXEL CONSTANTS BEGIN */
 x_per_pixel = 0;
 y_per_pixel = 0;
 rad_per_pixel = 0;
 ang_per_pixel = 0;

/* PER_PIXEL CONSTANT END */


/* Q VARIABLES START */

 q1 = 0;
 q2 = 0;
 q3 = 0;
 q4 = 0;
 q5 = 0;
 q6 = 0;
 q7 = 0;
 q8 = 0;


 /* Q VARIABLES END */


}