mpeg4ip_config_set.h

6410BSP1

    inline void CheckFloatType(config_index_t iName) {
        if (m_variables[iName].m_type != CONFIG_TYPE_FLOAT) {
          fprintf(stderr, 
              "config type mismatch on %s - shouldn't be float\n", 
              m_variables[iName].m_sName);
          fflush(stderr);
            throw new CConfigException(CONFIG_ERR_TYPE);
        }
    }

    inline bool IsDefault (const config_index_t iName) {
#if CONFIG_SAFETY
      CheckIName(iName);
#endif
      return m_variables[iName].IsValueDefault();
    };

    inline config_integer_t GetIntegerValue(const config_index_t iName) {
#if CONFIG_SAFETY
        CheckIName(iName);
        CheckIntegerType(iName);
#endif
        return m_variables[iName].m_value.m_ivalue;
    }

    inline void SetIntegerValue(const config_index_t iName, 
      config_integer_t ivalue) {
#if CONFIG_SAFETY
        CheckIName(iName);
        CheckIntegerType(iName);
#endif
        m_variables[iName].m_value.m_ivalue = ivalue;
    }

    inline bool GetBoolValue(const config_index_t iName) {
#if CONFIG_SAFETY
        CheckIName(iName);
        CheckBoolType(iName);
#endif
        return m_variables[iName].m_value.m_bvalue;;
    }

    inline void SetBoolValue(const config_index_t iName, bool bvalue) {
#if CONFIG_SAFETY
        CheckIName(iName);
        CheckBoolType(iName);
#endif
        m_variables[iName].m_value.m_bvalue = bvalue;
    }

    inline const char* GetStringValue(const config_index_t iName) {
#if CONFIG_SAFETY
        CheckIName(iName);
        CheckStringType(iName);
#endif
        return m_variables[iName].m_value.m_svalue;
    }

    inline const char* GetHelpValue(const config_index_t iName) {
#if CONFIG_SAFETY
      CheckIName(iName);
#endif
      return m_variables[iName].m_helpString;
    };

    inline void SetStringValue(const config_index_t iName, const char* svalue) {
#if CONFIG_SAFETY
        CheckIName(iName);
        CheckStringType(iName);
#endif
        if (svalue == m_variables[iName].m_value.m_svalue) {
            return;
        }
        CHECK_AND_FREE(m_variables[iName].m_value.m_svalue);
        if (svalue == NULL) {
          m_variables[iName].m_value.m_svalue = NULL;
        } else {
          m_variables[iName].m_value.m_svalue = strdup(svalue);
          if (m_variables[iName].m_value.m_svalue == NULL) {
            throw new CConfigException(CONFIG_ERR_MEMORY);
          }
        }
    }

    inline float GetFloatValue(const config_index_t iName) {
#if CONFIG_SAFETY
        CheckIName(iName);
        CheckFloatType(iName);
#endif
        return m_variables[iName].m_value.m_fvalue;
    }

    inline void SetFloatValue(const config_index_t iName, float fvalue) {
#if CONFIG_SAFETY
        CheckIName(iName);
        CheckFloatType(iName);
#endif
        m_variables[iName].m_value.m_fvalue = fvalue;
    }

    void SetToDefaults(int start = 0) {
        for (config_index_t i = start; i < m_numVariables; i++) {
            m_variables[i].SetToDefault();
        }
    }

    void SetToDefault(const config_index_t iName) {
      m_variables[iName].SetToDefault();
    }

    void ProcessLine (char *line) {
    // comment
      SConfigVariable* var;
      if (line[0] == '#') {
        return;
      }
      char* s = line, *name;
      while (*s != '\0') s++;
      s--;
      while (isspace(*s)) {
        *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 (!svar->FromAscii(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 (!var->FromAscii(s)) {
        if (m_debug) {
          fprintf(stderr, "bad config value in line %s\n", s);  
        }
      }
    }

    void SetVariableFromAscii(config_index_t ix, char *arg) {
      m_variables[ix].FromAscii(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 || !var->IsValueDefault()) {
                fprintf(pFile, "%s=%s\n", var->m_sName, var->ToAscii());
            }
        }
        ptr = m_unknown_head;
        while (ptr != NULL) {
          fprintf(pFile, "%s=%s\n", ptr->value->m_sName, 
              ptr->value->ToAscii());
          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, 
            m_variables[ix].ToAscii());
      }
    };
    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;
};

// 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

#ifdef _WIN32
#define CONFIG_BOOL(var, name, defval) \
 { SConfigVariable(&(var), (name), CONFIG_TYPE_BOOL, (defval)) }
#define CONFIG_FLOAT(var, name, defval) \
 { SConfigVariable(&(var), (name), CONFIG_TYPE_FLOAT,(float) (defval)) }
#define CONFIG_INT(var, name, defval) \
 { SConfigVariable(&var, name, CONFIG_TYPE_INTEGER, (config_integer_t)(defval))}
 //{ &(var), (name), CONFIG_TYPE_INTEGER,(config_integer_t) (defval), }
#define CONFIG_STRING(var, name, defval) \
 { SConfigVariable(&(var), (name), CONFIG_TYPE_STRING, (const char *)(defval)) }
#define CONFIG_BOOL_HELP(var, name, defval, help) \
 { SConfigVariable(&(var), (name), CONFIG_TYPE_BOOL, (defval), help) }
#define CONFIG_FLOAT_HELP(var, name, defval, help) \
 { SConfigVariable(&(var), (name), CONFIG_TYPE_FLOAT,(float) (defval), help) }
#define CONFIG_INT_HELP(var, name, defval, help) \
 { SConfigVariable(&var, name, CONFIG_TYPE_INTEGER, (config_integer_t)(defval), help)}
 //{ &(var), (name), CONFIG_TYPE_INTEGER,(config_integer_t) (defval), }
#define CONFIG_STRING_HELP(var, name, defval, help) \
 { SConfigVariable(&(var), (name), CONFIG_TYPE_STRING, (const char *)(defval), help) }
#else
#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

#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