mpeg4ip_config_set.h

完整的RTP RTSP代码库

	    *s = '\0';
	    s--;
	  }
	  s = name = line;

	  var = FindByName(strsep(&s, "="));
	  if (var == NULL || s == NULL) {
	    if (s != NULL) {
	      SConfigVariable *svar;
	      svar = MALLOC_STRUCTURE(SConfigVariable);
	      memset(svar, 0, sizeof(*svar));
	      svar->m_sName = strdup(name);
	      svar->m_type = CONFIG_TYPE_STRING;
	      if (!FromAscii(svar, s)) {
		fprintf(stderr, "bad config value in line %s\n", s);
	      }
	      SUnknownConfigVariable *ptr;
	      ptr = MALLOC_STRUCTURE(SUnknownConfigVariable);
	      ptr->next = m_unknown_head;
	      ptr->value = svar;
	      m_unknown_head = ptr;
	    }
	    if (m_debug) {
	      fprintf(stderr, "bad config line %s\n", s);  
	    }
	    return;
	  }
	  if (!FromAscii(var, s)) {
	    if (m_debug) {
	      fprintf(stderr, "bad config value in line %s\n", s);  
	    }
	  }
	}

	void SetVariableFromAscii(config_index_t ix, char *arg) {
	  FromAscii(&m_variables[ix], arg);
	};

	bool ReadFile(const char* fileName = NULL) {
	  if (fileName == NULL && m_fileName == NULL) 
	    return false;
       
	  if (fileName != NULL) {
		CHECK_AND_FREE(m_fileName);
		m_fileName = strdup(fileName);
	  }
		FILE* pFile = fopen(m_fileName, "r");
		if (pFile == NULL) {
			if (m_debug) {
				fprintf(stderr, "couldn't open file %s\n", fileName);
			}
			return false;
		}
		char line[256];
		while (fgets(line, sizeof(line), pFile)) {
		  ProcessLine(line);
		}
		fclose(pFile);
		return true;
	}

	bool WriteToFile(const char* fileName = NULL, bool allValues = false) {
		FILE* pFile;
		config_index_t i;
		SConfigVariable *var;
		SUnknownConfigVariable *ptr;
		if (fileName == NULL && m_fileName == NULL) {
		  return false;
		}
		if (fileName == NULL) {
		  fileName = m_fileName;
		}
		pFile = fopen(fileName, "w");
		if (pFile == NULL) {
			if (m_debug) {
				fprintf(stderr, "couldn't open file %s\n", fileName);
			}
			return false;
		}
		for (i = 0; i < m_numVariables; i++) {
			var = &m_variables[i];
			if (allValues || !IsValueDefault(var)) {
				fprintf(pFile, "%s=%s\n", var->m_sName, 
					ToAscii(var));
			}
		}
		ptr = m_unknown_head;
		while (ptr != NULL) {
		  fprintf(pFile, "%s=%s\n", ptr->value->m_sName, 
			  ToAscii(ptr->value));
		  ptr = ptr->next;
		}
		fclose(pFile);
		return true;
	}


	void SetDebug(bool debug = true) {
		m_debug = debug;
	}
#ifdef _WIN32
	int ReadVariablesFromRegistry(const char *reg_name, 
				      const char *config_section);
	void WriteVariablesToRegistry(const char *reg_name, 
				      const char *config_section);
#endif
 public:
	config_index_t FindIndexByName(const char *sName) {
		for (config_index_t i = 0; i < m_numVariables; i++) {
			if (!strcasecmp(sName, m_variables[i].m_sName)) {
			  return i;
			}
		}
		return UINT32_MAX;
	}
	ConfigType GetTypeFromIndex (config_index_t index) {
	  if (index < m_numVariables) {
	    return m_variables[index].m_type;
	  }
	  return CONFIG_TYPE_UNDEFINED;
	};
	const char *GetNameFromIndex (config_index_t index) {
	  if (index < m_numVariables) {
	    return m_variables[index].m_sName;
	  }
	  return NULL;
	};
	config_index_t GetNumVariables (void) {
	  return m_numVariables;
	};
	void DisplayHelp(bool onlyHelp = false) {
	  config_index_t ix;
	  for (ix = 0; ix < m_numVariables; ix++) {
	    if (m_variables[ix].m_helpString) {
	      fprintf(stdout, "%s - %s\n", m_variables[ix].m_sName,
		      m_variables[ix].m_helpString);
	    } else if (onlyHelp == false) {
	      fprintf(stdout, "%s\n", m_variables[ix].m_sName);
	    }
	  }
	};
	void Dump (void) {
	  fprintf(stdout, "File - %s\n", GetFileName());
	  config_index_t ix;
	  for (ix = 0; ix < m_numVariables; ix++) {
	    fprintf(stdout, "%s:\t%s\n", 
		    m_variables[ix].m_sName, 
		    ToAscii(&m_variables[ix]));
	  }
	};
	const char* GetUnknownStringValue (const char *var_name) {
	  SUnknownConfigVariable *svar = m_unknown_head;
	  while (svar != NULL) {
	    if (strcasecmp(var_name, svar->value->m_sName) == 0) {
	      return svar->value->m_value.m_svalue;
	    }
	    svar = svar->next;
	  }
	  config_index_t ix = FindIndexByName(var_name);
	  if (ix == UINT32_MAX) return NULL;
	  return m_variables[ix].m_value.m_svalue;
	};
	
protected:
	SConfigVariable* FindByName(const char* sName) {
	  config_index_t ix = FindIndexByName(sName);
	  if (ix == UINT32_MAX) return NULL;
	  return &m_variables[ix];
	};

protected:
	SConfigVariable*	m_variables;
	config_index_t		m_numVariables;
	bool 			m_debug;
	const char*		m_fileName;
	SUnknownConfigVariable *m_unknown_head;
	const char* ToAscii(SConfigVariable *v) {
	  static char sBuf[CONFIG_MAX_STRLEN+3];
	  switch (v->m_type) {
	  case CONFIG_TYPE_INTEGER:
	    sprintf(sBuf, "%d", v->m_value.m_ivalue);
	    return sBuf;
	  case CONFIG_TYPE_BOOL:
	    sprintf(sBuf, "%d", v->m_value.m_bvalue);
	    return sBuf;
	  case CONFIG_TYPE_STRING:
	    if (v->m_value.m_svalue == NULL) {
	      sprintf(sBuf, "\"\"");
	      return sBuf;
	    } 
	    if (strchr(v->m_value.m_svalue, ' ')) {
	      sBuf[0] = '"';
	      strncpy(&sBuf[1], v->m_value.m_svalue, CONFIG_MAX_STRLEN);
	      strcpy(&sBuf[MIN(strlen(v->m_value.m_svalue), 
			       CONFIG_MAX_STRLEN)+1], "\"");
	    }
	    return v->m_value.m_svalue;
	  case CONFIG_TYPE_FLOAT:
	    sprintf(sBuf, "%f", v->m_value.m_fvalue);
	    return sBuf;
	  case CONFIG_TYPE_UNDEFINED:
	  default:
	    return "";
	  }
	};

	bool FromAscii(SConfigVarible *v, const char* s) {
	  switch (v->m_type) {
	  case CONFIG_TYPE_INTEGER:
	    return (sscanf(s, " %i ", &v->m_value.m_ivalue) == 1);
	  case CONFIG_TYPE_BOOL:
	    // OPTION could add "yes/no", "true/false"
	    if (sscanf(s, " %u ", &v->m_value.m_ivalue) != 1) {
	      return false;
	    }
	    v->m_value.m_bvalue = v->m_value.m_ivalue ? true : false;
	    return true;
	  case CONFIG_TYPE_STRING:
	    // N.B. assuming m_svalue has been alloc'ed
	    {
	      size_t len = strlen(s);
	      CHECK_AND_FREE(v->m_value.m_svalue);
	      if (*s == '"' && s[len] == '"') {
		char *newvalue = strdup(s + 1);
		newvalue[len - 1] = '\0';

		v->m_value.m_svalue = newvalue;
	      } else {
		v->m_value.m_svalue = strdup(s);
	      }
	      if (v->m_value.m_svalue == NULL) {
		throw new CConfigException(CONFIG_ERR_MEMORY);
	      }
	      return true;
	    }
	  case CONFIG_TYPE_FLOAT:
	    return (sscanf(s, " %f ", &v->m_value.m_fvalue) == 1);
	  case CONFIG_TYPE_UNDEFINED:
	  default:
	    return false;
	  }
	};

	void SetToDefault(SConfigVariable *v) {
	  switch (v->m_type) {
	  case CONFIG_TYPE_INTEGER:
	    v->m_value.m_ivalue = v->m_defaultValue.m_ivalue;
	    break;
	  case CONFIG_TYPE_BOOL:
	    v->m_value.m_bvalue = v->m_defaultValue.m_bvalue;
	    break;
	  case CONFIG_TYPE_STRING:
	    CHECK_AND_FREE(v->m_value.m_svalue);
	    if (v->m_defaultValue.m_svalue == NULL) {
	      v->m_value.m_svalue = NULL;
	    } else {
	      v->m_value.m_svalue = strdup(v->m_defaultValue.m_svalue);
	      if (v->m_value.m_svalue == NULL) {
		throw new CConfigException(CONFIG_ERR_MEMORY);
	      }
	    }
	    break;
	  case CONFIG_TYPE_FLOAT:
	    v->m_value.m_fvalue = v->m_defaultValue.m_fvalue;
	    break;
	  case CONFIG_TYPE_UNDEFINED:
	  default:
	    break;
	  } 
	};

	bool IsValueDefault(SConfigVarible *v) {
	  switch (v->m_type) {
	  case CONFIG_TYPE_INTEGER:
	    return v->m_value.m_ivalue == v->m_defaultValue.m_ivalue;
	  case CONFIG_TYPE_BOOL:
	    return v->m_value.m_bvalue == v->m_defaultValue.m_bvalue;
	  case CONFIG_TYPE_STRING:
	    if (v->m_defaultValue.m_svalue == NULL && 
		v->m_value.m_svalue == NULL) 
	      return true;
	    if (v->m_defaultValue.m_svalue == NULL) return false;
	    if (v->m_value.m_svalue == NULL) return false;
	    return (strcmp(v->m_value.m_svalue, 
			   v->m_defaultValue.m_svalue) == 0);
	  case CONFIG_TYPE_FLOAT:
	    return v->m_value.m_fvalue == v->m_defaultValue.m_fvalue;
	  case CONFIG_TYPE_UNDEFINED:
	  default:
	    return false;
	  } 
	};
        void CleanUpConfig(SConfigVariable *v) {
	  if (v->m_type == CONFIG_TYPE_STRING) {
	    CHECK_AND_FREE(v->m_value.m_svalue);
	  }
	};
};

// To define configuration variables - first DECLARE_CONFIG in a
// .h file.  Then in either a C++ or h file, define a static array
// of configuration variables using CONFIG_BOOL, CONFIG_FLOAT, CONFIG_INT
// or CONFIG_STRING.  You can include the .h anywhere you use the variable - 
// in a .cpp, you must include the .h file with DECLARE_CONFIG_VARIABLES
// defined before the .h file.  Note - if you're already including mp4live.h, 
// you need to #define the DECLARE_CONFIG_VARIABLES after the include.
//
// Note - you want to add the config variables BEFORE the ReadFile
// call

#define CONFIG_BOOL(var, name, defval) \
 { &(var), (name), CONFIG_TYPE_BOOL, (defval), }
#define CONFIG_FLOAT(var, name, defval) \
 { &(var), (name), CONFIG_TYPE_FLOAT,(float) (defval), }
#define CONFIG_INT(var, name, defval) \
 { &(var), (name), CONFIG_TYPE_INTEGER,(config_integer_t) (defval), }
#define CONFIG_STRING(var, name, defval) \
 { &(var), (name), CONFIG_TYPE_STRING, (const char *)(defval), (const char *)NULL }
#define CONFIG_BOOL_HELP(var, name, defval, help) \
 { &(var), (name), CONFIG_TYPE_BOOL, (defval), (help), }
#define CONFIG_FLOAT_HELP(var, name, defval, help) \
 { &(var), (name), CONFIG_TYPE_FLOAT,(float) (defval), (help), }
#define CONFIG_INT_HELP(var, name, defval, help) \
 { &(var), (name), CONFIG_TYPE_INTEGER,(config_integer_t) (defval), (help), }
#define CONFIG_STRING_HELP(var, name, defval, help) \
 { &(var), (name), CONFIG_TYPE_STRING, (const char *)(defval), (help), (const char *)NULL,  }


#endif /* __CONFIG_SET_H__ */

#undef DECLARE_CONFIG
#ifdef DECLARE_CONFIG_VARIABLES
#define DECLARE_CONFIG(a) config_index_t (a);
#else
#define DECLARE_CONFIG(a) extern config_index_t (a);
#endif