GK SDK 源码库: XMIPCLinuxV100R005C00SPC030 (kernel/tools/open_source excluded)

sample/uvc_app/common/config_svc.c

@@ -0,0 +1,133 @@
+/*
+ * Copyright (c) XMEDIA. All rights reserved.
+ */
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <unistd.h>
+#include <assert.h>
+#include <string.h>
+
+#include "config_svc.h"
+#include "iniparser.h"
+#include "log_base.h"
+
+#define CONFIG_MAX_PATH 256
+
+typedef struct {
+    char* config_file;
+} config_svc_t;
+
+static config_svc_t* __config_svc = NULL;
+
+int create_config_svc(char *config_path)
+{
+    assert(config_path != NULL);
+
+    if (__config_svc != NULL) {
+        free(__config_svc);
+    }
+
+    __config_svc = (config_svc_t*)malloc(sizeof(config_svc_t));
+    if (__config_svc == NULL) {
+        LOGE("create config svc failure\n");
+        goto ERR;
+    }
+
+    __config_svc->config_file = malloc(sizeof(char) * CONFIG_MAX_PATH);
+    if (__config_svc->config_file == NULL) {
+        LOGE("malloc config file memory failure\n");
+        goto ERR;
+    }
+
+    if (strlen(config_path) > CONFIG_MAX_PATH) {
+        LOGE("config path is too length\n");
+        goto ERR;
+    }
+
+    strcpy(__config_svc->config_file, config_path);
+
+    return 0;
+
+ERR:
+    if (__config_svc) {
+        if (__config_svc->config_file) {
+            free(__config_svc->config_file);
+        }
+
+        free(__config_svc);
+    }
+
+    __config_svc = NULL;
+
+    return -1;
+}
+
+void release_cofnig_svc()
+{
+    if (__config_svc) {
+        if (__config_svc->config_file) {
+            free(__config_svc->config_file);
+        }
+
+        free(__config_svc);
+    }
+
+    __config_svc = NULL;
+}
+
+int get_config_value(const char *key, int default_value)
+{
+    dictionary *config_dic;
+    int value = default_value;
+
+    assert(key != NULL);
+    assert(__config_svc != NULL);
+
+    config_dic = iniparser_load(__config_svc->config_file);
+
+    if (config_dic == NULL) {
+        LOGE("open config file failuer[%s], returen default value:%d\n", __config_svc->config_file, default_value);
+        return value;
+    }
+
+    value = iniparser_getint(config_dic, key, default_value);
+    iniparser_freedict(config_dic);
+
+    return value;
+}
+
+int get_config_string(const char *key, char *buf, int size)
+{
+    dictionary *config_dic;
+    int copy_size;
+    int ret = -1;
+    char* value = NULL;
+
+    assert(key != NULL);
+    assert(buf != NULL);
+    assert(__config_svc != NULL);
+
+    config_dic = iniparser_load(__config_svc->config_file);
+    if (config_dic == NULL) {
+        LOGE("open config file failuer[%s], returen NULL\n", __config_svc->config_file);
+        return ret;
+    }
+
+    value = iniparser_getstring(config_dic, key, NULL);
+    if (value != NULL) {
+        copy_size = strlen(value);
+        if (copy_size <= size) {
+            memcpy(buf, value, copy_size);
+            ret = 0;
+        } else {
+            LOGE("buffer is small too get %s.\n", key);
+        }
+    } else {
+        LOGD("getstring (%s) fail.\n", key);
+    }
+
+    iniparser_freedict(config_dic);
+
+    return ret;
+}

sample/uvc_app/common/config_svc.h

@@ -0,0 +1,13 @@
+/*
+ * Copyright (c) XMEDIA. All rights reserved.
+ */
+
+#ifndef __CONFIG_SERVICE_H__
+#define __CONFIG_SERVICE_H__
+
+int  create_config_svc(char* config_path);
+void release_cofnig_svc();
+int get_config_value(const char *key, int default_value);
+int get_config_string(const char *key, char *buf, int size);
+
+#endif //__CONFIG_SERVICE_H__

sample/uvc_app/common/dictionary.c

@@ -0,0 +1,513 @@
+/*
+ * Copyright (c) XMEDIA. All rights reserved.
+ */
+/*-------------------------------------------------------------------------*/
+
+/**
+   @file    dictionary.c
+   @author  N. Devillard
+   @brief   Implements a dictionary for string variables.
+
+   This module implements a simple dictionary object, i.e. a list
+   of string/string associations. This object is useful to store e.g.
+   informations retrieved from a configuration file (ini files).
+ */
+
+/*--------------------------------------------------------------------------*/
+
+//extern "C" {
+
+/*---------------------------------------------------------------------------
+                                Includes
+ ---------------------------------------------------------------------------*/
+#include "dictionary.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+
+/** Maximum value size for integers and doubles. */
+#define MAXVALSZ 1024
+
+/** Minimal allocated number of entries in a dictionary */
+#define DICTMINSZ 128
+
+/** Invalid key token */
+#define DICT_INVALID_KEY ((char*)-1)
+
+/*---------------------------------------------------------------------------
+                            Private functions
+ ---------------------------------------------------------------------------*/
+
+/* Doubles the allocated size associated to a pointer */
+/* 'size' is the current allocated size. */
+static void * mem_double(void * ptr, int size)
+{
+    void * newptr;
+
+    newptr = calloc(2 * size, 1);
+    if (newptr == NULL)
+    {
+        return NULL;
+    }
+
+    memcpy(newptr, ptr, size);
+    free(ptr);
+    return newptr;
+}
+
+/*-------------------------------------------------------------------------*/
+
+/**
+  @brief    Duplicate a string
+  @param    s String to duplicate
+  @return   Pointer to a newly allocated string, to be freed with free()
+
+  This is a replacement for strdup(). This implementation is provided
+  for systems that do not have it.
+ */
+
+/*--------------------------------------------------------------------------*/
+static char * xstrdup(const char * s)
+{
+    char * t;
+
+    if (!s)
+    {
+        return NULL;
+    }
+
+    t = (char*)malloc(strlen(s) + 1);
+    if (t)
+    {
+        strcpy(t, s);
+    }
+
+    return t;
+}
+
+/*---------------------------------------------------------------------------
+                            Function codes
+ ---------------------------------------------------------------------------*/
+
+/*-------------------------------------------------------------------------*/
+
+/**
+  @brief    Compute the hash key for a string.
+  @param    key     Character string to use for key.
+  @return   1 unsigned int on at least 32 bits.
+
+  This hash function has been taken from an Article in Dr Dobbs Journal.
+  This is normally a collision-free function, distributing keys evenly.
+  The key is stored anyway in the struct so that collision can be avoided
+  by comparing the key itself in last resort.
+ */
+
+/*--------------------------------------------------------------------------*/
+unsigned dictionary_hash(const char * key)
+{
+    int len;
+    unsigned hash;
+    int i;
+
+    len = strlen(key);
+    for (hash = 0, i = 0; i < len; i++)
+    {
+        hash += (unsigned)key[i];
+        hash += (hash << 10);
+        hash ^= (hash >> 6);
+    }
+
+    hash += (hash << 3);
+    hash ^= (hash >> 11);
+    hash += (hash << 15);
+    return hash;
+}
+
+/*-------------------------------------------------------------------------*/
+
+/**
+  @brief    Create a new dictionary object.
+  @param    size    Optional initial size of the dictionary.
+  @return   1 newly allocated dictionary objet.
+
+  This function allocates a new dictionary object of given size and returns
+  it. If you do not know in advance (roughly) the number of entries in the
+  dictionary, give size=0.
+ */
+
+/*--------------------------------------------------------------------------*/
+dictionary * dictionary_new(int size)
+{
+    dictionary  *   d;
+
+    /* If no size was specified, allocate space for DICTMINSZ */
+    if (size < DICTMINSZ)
+    {
+        size = DICTMINSZ;
+    }
+
+    if (!(d = (dictionary *)calloc(1, sizeof(dictionary))))
+    {
+        return NULL;
+    }
+
+    d->size = size;
+    d->val  = (char **)calloc(size, sizeof(char*));
+    d->key  = (char **)calloc(size, sizeof(char*));
+    d->hash = (unsigned int *)calloc(size, sizeof(unsigned));
+    return d;
+}
+
+/*-------------------------------------------------------------------------*/
+
+/**
+  @brief    Delete a dictionary object
+  @param    d   dictionary object to deallocate.
+  @return   void
+
+  Deallocate a dictionary object and all memory associated to it.
+ */
+
+/*--------------------------------------------------------------------------*/
+void dictionary_del(dictionary * d)
+{
+    int i;
+
+    if (d == NULL)
+    {
+        return;
+    }
+
+    for (i = 0; i < d->size; i++)
+    {
+        if (d->key[i] != NULL)
+        {
+            free(d->key[i]);
+        }
+
+        if (d->val[i] != NULL)
+        {
+            free(d->val[i]);
+        }
+    }
+
+    free(d->val);
+    free(d->key);
+    free(d->hash);
+    free(d);
+    return;
+}
+
+/*-------------------------------------------------------------------------*/
+
+/**
+  @brief    Get a value from a dictionary.
+  @param    d       dictionary object to search.
+  @param    key     Key to look for in the dictionary.
+  @param    def     Default value to return if key not found.
+  @return   1 pointer to internally allocated character string.
+
+  This function locates a key in a dictionary and returns a pointer to its
+  value, or the passed 'def' pointer if no such key can be found in
+  dictionary. The returned character pointer points to data internal to the
+  dictionary object, you should not try to free it or modify it.
+ */
+
+/*--------------------------------------------------------------------------*/
+char * dictionary_get(dictionary * d, const char * key, char * def)
+{
+    unsigned hash;
+    int i;
+
+    hash = dictionary_hash(key);
+    for (i = 0; i < d->size; i++)
+    {
+        if (d->key[i] == NULL)
+        {
+            continue;
+        }
+
+        /* Compare hash */
+        if (hash == d->hash[i])
+        {
+            /* Compare string, to avoid hash collisions */
+            if (!strcmp(key, d->key[i]))
+            {
+                return d->val[i];
+            }
+        }
+    }
+
+    return def;
+}
+
+/*-------------------------------------------------------------------------*/
+
+/**
+  @brief    Set a value in a dictionary.
+  @param    d       dictionary object to modify.
+  @param    key     Key to modify or add.
+  @param    val     Value to add.
+  @return   int     0 if Ok, anything else otherwise
+
+  If the given key is found in the dictionary, the associated value is
+  replaced by the provided one. If the key cannot be found in the
+  dictionary, it is added to it.
+
+  It is Ok to provide a NULL value for val, but NULL values for the dictionary
+  or the key are considered as errors: the function will return immediately
+  in such a case.
+
+  Notice that if you dictionary_set a variable to NULL, a call to
+  dictionary_get will return a NULL value: the variable will be found, and
+  its value (NULL) is returned. In other words, setting the variable
+  content to NULL is equivalent to deleting the variable from the
+  dictionary. It is not possible (in this implementation) to have a key in
+  the dictionary without value.
+
+  This function returns non-zero in case of failure.
+ */
+
+/*--------------------------------------------------------------------------*/
+int dictionary_set(dictionary * d, const char * key, const char * val)
+{
+    int i;
+    unsigned hash;
+
+    if ((d == NULL) || (key == NULL))
+    {
+        return -1;
+    }
+
+    /* Compute hash for this key */
+    hash = dictionary_hash(key);
+
+    /* Find if value is already in dictionary */
+    if (d->n > 0)
+    {
+        for (i = 0; i < d->size; i++)
+        {
+            if (d->key[i] == NULL)
+            {
+                continue;
+            }
+
+            if (hash == d->hash[i])
+            {
+                /* Same hash value */
+                if (!strcmp(key, d->key[i]))
+                {
+                    /* Same key */
+                    /* Found a value: modify and return */
+                    if (d->val[i] != NULL)
+                    {
+                        free(d->val[i]);
+                    }
+
+                    d->val[i] = val ? xstrdup(val) : NULL;
+
+                    /* Value has been modified: return */
+                    return 0;
+                }
+            }
+        }
+    }
+
+    /* Add a new value */
+    /* See if dictionary needs to grow */
+    if (d->n == d->size)
+    {
+        /* Reached maximum size: reallocate dictionary */
+        d->val  = (char **)mem_double(d->val, d->size * sizeof(char*));
+        d->key  = (char **)mem_double(d->key, d->size * sizeof(char*));
+        d->hash = (unsigned int *)mem_double(d->hash, d->size * sizeof(unsigned));
+        if ((d->val == NULL) || (d->key == NULL) || (d->hash == NULL))
+        {
+            /* Cannot grow dictionary */
+            return -1;
+        }
+
+        /* Double size */
+        d->size *= 2;
+    }
+
+    /* Insert key in the first empty slot. Start at d->n and wrap at
+       d->size. Because d->n < d->size this will necessarily
+       terminate. */
+    for (i = d->n; d->key[i];)
+    {
+        if (++i == d->size)
+        {
+            i = 0;
+        }
+    }
+
+    /* Copy key */
+    d->key[i]  = xstrdup(key);
+    d->val[i]  = val ? xstrdup(val) : NULL;
+    d->hash[i] = hash;
+    d->n++;
+    return 0;
+}
+
+/*-------------------------------------------------------------------------*/
+
+/**
+  @brief    Delete a key in a dictionary
+  @param    d       dictionary object to modify.
+  @param    key     Key to remove.
+  @return   void
+
+  This function deletes a key in a dictionary. Nothing is done if the
+  key cannot be found.
+ */
+
+/*--------------------------------------------------------------------------*/
+void dictionary_unset(dictionary * d, const char * key)
+{
+    unsigned hash;
+    int i;
+
+    if (key == NULL)
+    {
+        return;
+    }
+
+    hash = dictionary_hash(key);
+    for (i = 0; i < d->size; i++)
+    {
+        if (d->key[i] == NULL)
+        {
+            continue;
+        }
+
+        /* Compare hash */
+        if (hash == d->hash[i])
+        {
+            /* Compare string, to avoid hash collisions */
+            if (!strcmp(key, d->key[i]))
+            {
+                /* Found key */
+                break;
+            }
+        }
+    }
+
+    if (i >= d->size)
+    {
+        /* Key not found */
+        return;
+    }
+
+    free(d->key[i]);
+    d->key[i] = NULL;
+    if (d->val[i] != NULL)
+    {
+        free(d->val[i]);
+        d->val[i] = NULL;
+    }
+
+    d->hash[i] = 0;
+    d->n--;
+    return;
+}
+
+/*-------------------------------------------------------------------------*/
+
+/**
+  @brief    Dump a dictionary to an opened file pointer.
+  @param    d   Dictionary to dump
+  @param    f   Opened file pointer.
+  @return   void
+
+  Dumps a dictionary onto an opened file pointer. Key pairs are printed out
+  as @c [Key]=[Value], one per line. It is Ok to provide stdout or stderr as
+  output file pointers.
+ */
+
+/*--------------------------------------------------------------------------*/
+void dictionary_dump(dictionary * d, FILE * out)
+{
+    int i;
+
+    if ((d == NULL) || (out == NULL))
+    {
+        return;
+    }
+
+    if (d->n < 1)
+    {
+        fprintf(out, "empty dictionary\n");
+        return;
+    }
+
+    for (i = 0; i < d->size; i++)
+    {
+        if (d->key[i])
+        {
+            fprintf(out, "%20s\t[%s]\n",
+                    d->key[i],
+                    d->val[i] ? d->val[i] : "UNDEF");
+        }
+    }
+
+    return;
+}
+
+/* Test code */
+#ifdef TESTDIC
+ #define NVALS 20000
+int main(int argc, char *argv[])
+{
+    dictionary  *   d;
+    char    *   val;
+    int i;
+    char cval[90];
+
+    /* Allocate dictionary */
+    printf("allocating...\n");
+    d = dictionary_new(0);
+
+    /* Set values in dictionary */
+    printf("setting %d values...\n", NVALS);
+    for (i = 0; i < NVALS; i++)
+    {
+        sprintf(cval, "%04d", i);
+        dictionary_set(d, cval, "salut");
+    }
+
+    printf("getting %d values...\n", NVALS);
+    for (i = 0; i < NVALS; i++)
+    {
+        sprintf(cval, "%04d", i);
+        val = dictionary_get(d, cval, DICT_INVALID_KEY);
+        if (val == DICT_INVALID_KEY)
+        {
+            printf("cannot get value for key [%s]\n", cval);
+        }
+    }
+
+    printf("unsetting %d values...\n", NVALS);
+    for (i = 0; i < NVALS; i++)
+    {
+        sprintf(cval, "%04d", i);
+        dictionary_unset(d, cval);
+    }
+
+    if (d->n != 0)
+    {
+        printf("error deleting values\n");
+    }
+
+    printf("deallocating...\n");
+    dictionary_del(d);
+    return 0;
+}
+
+#endif
+
+/* vim: set ts=4 et sw=4 tw=75 */
+
+//}//end if extern "C"

sample/uvc_app/common/dictionary.h

@@ -0,0 +1,182 @@
+/*
+ * Copyright (c) XMEDIA. All rights reserved.
+ */
+/*-------------------------------------------------------------------------*/
+
+/**
+   @file    dictionary.h
+   @author  N. Devillard
+   @brief   Implements a dictionary for string variables.
+
+   This module implements a simple dictionary object, i.e. a list
+   of string/string associations. This object is useful to store e.g.
+   informations retrieved from a configuration file (ini files).
+ */
+
+/*--------------------------------------------------------------------------*/
+
+#ifndef _DICTIONARY_H_
+#define _DICTIONARY_H_
+
+/*---------------------------------------------------------------------------
+                                Includes
+ ---------------------------------------------------------------------------*/
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+
+/*---------------------------------------------------------------------------
+                                New types
+ ---------------------------------------------------------------------------*/
+
+/*-------------------------------------------------------------------------*/
+
+/**
+  @brief    Dictionary object
+
+  This object contains a list of string/string associations. Each
+  association is identified by a unique string key. Looking up values
+  in the dictionary is speeded up by the use of a (hopefully collision-free)
+  hash function.
+ */
+
+/*-------------------------------------------------------------------------*/
+typedef struct _dictionary_
+{
+    int             n;      /** Number of entries in dictionary */
+    int             size;   /** Storage size */
+    char        **  val;   /** List of string values */
+    char        **  key;   /** List of string keys */
+    unsigned     *  hash;  /** List of hash values for keys */
+} dictionary;
+
+/*---------------------------------------------------------------------------
+                            Function prototypes
+ ---------------------------------------------------------------------------*/
+
+/*-------------------------------------------------------------------------*/
+
+/**
+  @brief    Compute the hash key for a string.
+  @param    key     Character string to use for key.
+  @return   1 unsigned int on at least 32 bits.
+
+  This hash function has been taken from an Article in Dr Dobbs Journal.
+  This is normally a collision-free function, distributing keys evenly.
+  The key is stored anyway in the struct so that collision can be avoided
+  by comparing the key itself in last resort.
+ */
+
+/*--------------------------------------------------------------------------*/
+unsigned     dictionary_hash(const char * key);
+
+/*-------------------------------------------------------------------------*/
+
+/**
+  @brief    Create a new dictionary object.
+  @param    size    Optional initial size of the dictionary.
+  @return   1 newly allocated dictionary objet.
+
+  This function allocates a new dictionary object of given size and returns
+  it. If you do not know in advance (roughly) the number of entries in the
+  dictionary, give size=0.
+ */
+
+/*--------------------------------------------------------------------------*/
+dictionary * dictionary_new(int size);
+
+/*-------------------------------------------------------------------------*/
+
+/**
+  @brief    Delete a dictionary object
+  @param    d   dictionary object to deallocate.
+  @return   void
+
+  Deallocate a dictionary object and all memory associated to it.
+ */
+
+/*--------------------------------------------------------------------------*/
+void         dictionary_del(dictionary * vd);
+
+/*-------------------------------------------------------------------------*/
+
+/**
+  @brief    Get a value from a dictionary.
+  @param    d       dictionary object to search.
+  @param    key     Key to look for in the dictionary.
+  @param    def     Default value to return if key not found.
+  @return   1 pointer to internally allocated character string.
+
+  This function locates a key in a dictionary and returns a pointer to its
+  value, or the passed 'def' pointer if no such key can be found in
+  dictionary. The returned character pointer points to data internal to the
+  dictionary object, you should not try to free it or modify it.
+ */
+
+/*--------------------------------------------------------------------------*/
+char *       dictionary_get(dictionary * d, const char * key, char * def);
+
+/*-------------------------------------------------------------------------*/
+
+/**
+  @brief    Set a value in a dictionary.
+  @param    d       dictionary object to modify.
+  @param    key     Key to modify or add.
+  @param    val     Value to add.
+  @return   int     0 if Ok, anything else otherwise
+
+  If the given key is found in the dictionary, the associated value is
+  replaced by the provided one. If the key cannot be found in the
+  dictionary, it is added to it.
+
+  It is Ok to provide a NULL value for val, but NULL values for the dictionary
+  or the key are considered as errors: the function will return immediately
+  in such a case.
+
+  Notice that if you dictionary_set a variable to NULL, a call to
+  dictionary_get will return a NULL value: the variable will be found, and
+  its value (NULL) is returned. In other words, setting the variable
+  content to NULL is equivalent to deleting the variable from the
+  dictionary. It is not possible (in this implementation) to have a key in
+  the dictionary without value.
+
+  This function returns non-zero in case of failure.
+ */
+
+/*--------------------------------------------------------------------------*/
+int          dictionary_set(dictionary * vd, const char * key, const char * val);
+
+/*-------------------------------------------------------------------------*/
+
+/**
+  @brief    Delete a key in a dictionary
+  @param    d       dictionary object to modify.
+  @param    key     Key to remove.
+  @return   void
+
+  This function deletes a key in a dictionary. Nothing is done if the
+  key cannot be found.
+ */
+
+/*--------------------------------------------------------------------------*/
+void         dictionary_unset(dictionary * d, const char * key);
+
+/*-------------------------------------------------------------------------*/
+
+/**
+  @brief    Dump a dictionary to an opened file pointer.
+  @param    d   Dictionary to dump
+  @param    f   Opened file pointer.
+  @return   void
+
+  Dumps a dictionary onto an opened file pointer. Key pairs are printed out
+  as @c [Key]=[Value], one per line. It is Ok to provide stdout or stderr as
+  output file pointers.
+ */
+
+/*--------------------------------------------------------------------------*/
+void         dictionary_dump(dictionary * d, FILE * out);
+
+#endif

sample/uvc_app/common/events.c

@@ -0,0 +1,71 @@
+/*
+ * Copyright (c) XMEDIA. All rights reserved.
+ */
+
+#include <stdio.h>
+#include <time.h>
+#include <errno.h>
+#include <semaphore.h>
+
+static sem_t g_sem;
+
+int events_init(void)
+{
+    return sem_init(&g_sem, 0, 0);
+}
+
+int events_wait(void)
+{
+    return sem_wait(&g_sem);
+}
+
+int events_wait_timeout_ms(unsigned long long timeout_ms)
+{
+    int rc;
+    unsigned long long sec, nsec;
+    struct timespec tv = {0};
+
+    clock_gettime(CLOCK_REALTIME, &tv);
+
+    sec  = timeout_ms / 1000;
+    nsec = (timeout_ms % 1000) * 1000000;
+
+    tv.tv_nsec += nsec;
+    tv.tv_sec += sec;
+
+    rc = sem_timedwait(&g_sem, (const struct timespec*)&tv);
+    if (rc < 0) {
+        if (rc == ETIMEDOUT) {
+            printf("sem_timedwait timeout.\n");
+        } else {
+            printf("sem_timedwait fail.\n");
+        }
+    }
+
+    return 0;
+}
+
+int events_notity_one(void)
+{
+    return sem_post(&g_sem);
+}
+
+int events_deinit(void)
+{
+    return sem_destroy(&g_sem);
+}
+
+int node_wait(void)
+{
+    return events_wait();
+}
+
+int node_wait_timeout_ms(unsigned long long timeout_ms)
+{
+    return events_wait_timeout_ms(timeout_ms);
+}
+
+int node_notity_one(void)
+{
+    return events_notity_one();
+}

sample/uvc_app/common/events.h

@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) XMEDIA. All rights reserved.
+ */
+
+#ifndef __EVENTS_H_
+#define __EVENTS_H_
+
+int events_init(void);
+int events_deinit(void);
+int events_wait(void);
+int events_wait_timeout_ms(unsigned long long timeout_ms);
+int events_notity_one(void);
+
+int node_wait(void);
+int node_wait_timeout_ms(unsigned long long timeout_ms);
+int node_notity_one(void);
+
+#endif

sample/uvc_app/common/frame_cache.c

@@ -0,0 +1,504 @@
+/*
+ * Copyright (c) XMEDIA. All rights reserved.
+ */
+/*
+ * The main logic about frame cache module
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <malloc.h>
+
+#include "log_base.h"
+#include "events.h"
+#include "config_svc.h"
+#include "frame_cache.h"
+
+static void cache_init(frame_cache_t *cache)
+{
+    cache->tail  = NULL;
+    cache->head  = NULL;
+    cache->count = 0;
+}
+
+static void cache_destroy(frame_cache_t *cache)
+{
+    frame_node_t *tmp = NULL;
+
+    while (cache->tail != NULL) {
+        tmp = cache->tail;
+        cache->tail = tmp->next;
+        free(tmp->mem);
+        free(tmp);
+    }
+
+    cache->tail  = NULL;
+    cache->head  = NULL;
+    cache->count = 0;
+}
+
+static int put_frame_into_cache(frame_cache_t *cache, frame_node_t *node)
+{
+    node->next = NULL;
+    cache->count++;
+
+    // first time
+    if (cache->head == NULL && cache->tail == NULL) {
+        cache->head = node;
+        cache->tail = node;
+    } else {
+        cache->head->next = node;
+        cache->head = node;
+    }
+
+    return 0;
+}
+
+static int get_frame_from_cache(frame_cache_t *cache, frame_node_t **node)
+{
+    *node = cache->tail;
+
+    if ((cache->tail != NULL) && (cache->tail->next != NULL)) {
+        cache->tail = cache->tail->next;
+        cache->count--;
+    } else if (cache->tail == cache->head) {
+        cache->tail  = NULL;
+        cache->head  = NULL;
+        cache->count = 0;
+    }
+
+    return (*node != NULL) ? 0 : -1;
+}
+
+static int free_queue(frame_queue_t *queue)
+{
+    frame_cache_t *cache = queue->cache;
+
+    if (cache != NULL) {
+        cache_destroy(cache);
+        free(cache);
+        queue->cache = NULL;
+    }
+
+    pthread_mutex_destroy(&(queue->locker));
+
+    return 0;
+}
+
+static int free_uvc_cache(uvc_cache_t *uvc_cache)
+{
+    /* free queue*/
+    free_queue(uvc_cache->ok_queue);
+    free_queue(uvc_cache->free_queue);
+
+    free(uvc_cache->ok_queue);
+    free(uvc_cache->free_queue);
+
+    return 0;
+}
+
+static int free_uac_cache(uac_cache_t *uac_cache)
+{
+    /* free queue*/
+    free_queue(uac_cache->ok_queue);
+    free_queue(uac_cache->free_queue);
+
+    free(uac_cache->ok_queue);
+    free(uac_cache->free_queue);
+
+    return 0;
+}
+
+
+static int init_queue(frame_queue_t **queue)
+{
+    frame_queue_t *q = *queue;
+
+    if (q == NULL) {
+        goto ERR;
+    }
+
+    q->cache = (frame_cache_t *)malloc(sizeof(frame_cache_t));
+    if (q->cache == NULL) {
+        LOGE("malloc frame cache failure\n");
+        goto ERR;
+    }
+
+    cache_init(q->cache);
+
+    /*FIXME: recursive locker....*/
+    pthread_mutex_init(&(q->locker), NULL);
+
+    return 0;
+
+ERR:
+    return -1;
+}
+
+static int init_uvc_frame_cache(uvc_cache_t **cache)
+{
+    uvc_cache_t *uvc_cache = *cache;
+
+    if (uvc_cache == NULL) {
+        LOGE("the uvc cache is null\n");
+        goto ERR;
+    }
+
+    uvc_cache->ok_queue = NULL;
+    uvc_cache->free_queue = NULL;
+
+    uvc_cache->ok_queue = (frame_queue_t *)malloc(sizeof(frame_queue_t));
+    if (uvc_cache->ok_queue == NULL) {
+        LOGE("malloc ok_queue failure \n");
+        goto ERR;
+    }
+
+    uvc_cache->free_queue = (frame_queue_t *)malloc(sizeof(frame_queue_t));
+    if (uvc_cache->free_queue == NULL) {
+        LOGE("malloc free_queue failure\n");
+        goto ERR;
+    }
+
+    if (init_queue(&(uvc_cache->ok_queue)) < 0) {
+        goto ERR;
+    }
+
+    if (init_queue(&(uvc_cache->free_queue)) < 0) {
+        goto ERR;
+    }
+
+    return 0;
+
+ERR:
+    if (uvc_cache->ok_queue != NULL) {
+        free(uvc_cache->ok_queue);
+        uvc_cache->ok_queue = NULL;
+    }
+
+    if (uvc_cache->free_queue != NULL) {
+        free(uvc_cache->free_queue);
+        uvc_cache->free_queue = NULL;
+    }
+
+    return -1;
+}
+
+static int init_uac_frame_cache(uac_cache_t **cache)
+{
+    uac_cache_t *uac_cache = *cache;
+
+    if (uac_cache == NULL) {
+        LOGE("the uac cache is null\n");
+        goto ERR;
+    }
+
+    uac_cache->ok_queue   = NULL;
+    uac_cache->free_queue = NULL;
+
+    uac_cache->ok_queue = (frame_queue_t *)malloc(sizeof(frame_queue_t));
+    if (uac_cache->ok_queue == NULL) {
+        LOGE("malloc ok_queue failure \n");
+        goto ERR;
+    }
+
+    uac_cache->free_queue = (frame_queue_t *)malloc(sizeof(frame_queue_t));
+    if (uac_cache->free_queue == NULL) {
+        LOGE("malloc free_queue failure\n");
+        goto ERR;
+    }
+
+    if (init_queue(&(uac_cache->ok_queue)) < 0) {
+        goto ERR;
+    }
+
+    if (init_queue(&(uac_cache->free_queue)) < 0) {
+        goto ERR;
+    }
+
+    return 0;
+
+ERR:
+    if (uac_cache->ok_queue != NULL) {
+        free(uac_cache->ok_queue);
+        uac_cache->ok_queue = NULL;
+    }
+
+    if (uac_cache->free_queue != NULL) {
+        free(uac_cache->free_queue);
+        uac_cache->free_queue = NULL;
+    }
+
+    return -1;
+}
+
+static void clear_frame_cache(frame_cache_t *c)
+{
+    cache_destroy(c);
+}
+
+static void clear_queue(frame_queue_t *q)
+{
+    if (0 != pthread_mutex_lock(&(q->locker))) {
+        LOGE("failed to lock frame cache\n");
+        goto ERR;
+    }
+
+    clear_frame_cache(q->cache);
+
+    pthread_mutex_unlock(&(q->locker));
+
+ERR:
+    return;
+}
+
+static int create_cache_node_list(frame_queue_t *q, unsigned int buffer_size, int cache_count)
+{
+    int i = 0;
+    unsigned int page_size;
+    frame_node_t *n = NULL;
+
+    page_size = getpagesize();
+
+    buffer_size = (buffer_size + page_size - 1) & ~(page_size - 1);
+
+    for (; i < cache_count; ++i) {
+        n = (frame_node_t *)malloc(sizeof(frame_node_t));
+        if (!n) {
+            LOGE("failed to malloc frame_node_t\n");
+            goto ERR;
+        }
+
+        n->mem = (unsigned char *)memalign(page_size, buffer_size);
+        if (!n->mem) {
+            LOGE("failed to malloc frame_node_t->mem field\n");
+            goto ERR;
+        }
+
+        n->length = buffer_size;
+        n->used = 0;
+        n->next = NULL;
+        n->index = i;
+
+        put_node_to_queue(q, n);
+    }
+
+    return 0;
+
+ERR:
+
+    if (n) {
+        free(n);
+    }
+
+    return -1;
+}
+
+//only one instance for each process.
+static uvc_cache_t *g_uvc_cache = NULL;
+static uac_cache_t *g_uac_cache = NULL;
+
+uvc_cache_t *uvc_cache_get(void)
+{
+    return g_uvc_cache;
+}
+
+int create_uvc_cache(void)
+{
+    unsigned int buffer_size;
+    int cache_count;
+
+    g_uvc_cache = (uvc_cache_t *)malloc(sizeof(uvc_cache_t));
+    if (g_uvc_cache == NULL) {
+        LOGE("malloc uvc_cache failure\n");
+        goto ERR;
+    }
+
+    if (init_uvc_frame_cache(&g_uvc_cache) < 0) {
+        LOGE("init uvc cache failure\n");
+        goto ERR;
+    }
+
+    buffer_size = get_config_value("uvc:imagesize", 1843200);
+    cache_count = get_config_value("uvc:cache_count", 6);
+
+    create_cache_node_list(g_uvc_cache->free_queue, buffer_size, cache_count);
+
+    events_init();
+
+    return 0;
+
+ERR:
+    if (g_uvc_cache != NULL) {
+        free(g_uvc_cache);
+        g_uvc_cache = NULL;
+    }
+
+    return -1;
+}
+
+void destroy_uvc_cache(void)
+{
+    if (uvc_cache_get() != NULL) {
+        free_uvc_cache(uvc_cache_get());
+        free(uvc_cache_get());
+        events_deinit();
+
+        g_uvc_cache = NULL;
+    }
+}
+
+void clear_uvc_cache(void)
+{
+    if (uvc_cache_get() != NULL) {
+        uvc_cache_t* uvc_cache = uvc_cache_get();
+
+        clear_queue(uvc_cache->free_queue);
+        clear_queue(uvc_cache->ok_queue);
+    }
+}
+
+uac_cache_t* uac_cache_get(void)
+{
+    return g_uac_cache;
+}
+
+int create_uac_cache(void)
+{
+    int cache_count;
+    unsigned int buffer_size;
+
+    g_uac_cache = (uac_cache_t *)malloc(sizeof(uac_cache_t));
+
+    if (g_uac_cache == NULL) {
+        LOGE("malloc uac_cache failure\n");
+        goto ERR;
+    }
+
+    if (init_uac_frame_cache(&g_uac_cache) < 0) {
+        LOGE("init uac cache failure\n");
+        goto ERR;
+    }
+
+    buffer_size = get_config_value("uac:imagesize", 1024);
+    cache_count = get_config_value("uac:cache_count", 6);
+
+    create_cache_node_list(g_uac_cache->free_queue, buffer_size, cache_count);
+
+    return 0;
+
+ERR:
+    if (g_uac_cache != NULL) {
+        free(g_uac_cache);
+    }
+
+    g_uac_cache = NULL;
+
+    return -1;
+}
+
+void destroy_uac_cache(void)
+{
+    if (uac_cache_get() != NULL) {
+        free_uac_cache(uac_cache_get());
+        free(uac_cache_get());
+
+        g_uac_cache = NULL;
+    }
+}
+
+void clear_uac_cache(void)
+{
+    if (uac_cache_get() != NULL) {
+        uac_cache_t * uac_cache = uac_cache_get();
+
+        clear_queue(uac_cache->free_queue);
+        clear_queue(uac_cache->ok_queue);
+    }
+}
+
+int put_node_to_queue(frame_queue_t *q, frame_node_t* node)
+{
+    if ((q == NULL) || (node == NULL)) {
+        goto ERR;
+    }
+
+    if (0 != pthread_mutex_lock(&(q->locker))) {
+        LOGE("failed to lock frame cache\n");
+        goto ERR;
+    }
+
+    if (0 != put_frame_into_cache(q->cache, node)) {
+        pthread_mutex_unlock(&(q->locker));
+
+        goto ERR;
+    }
+
+    pthread_mutex_unlock(&(q->locker));
+
+    if (g_uvc_cache && g_uvc_cache->ok_queue == q) {
+        node_notity_one();
+    }
+
+    return 0;
+
+ERR:
+    return -1;
+}
+
+int get_node_from_queue(frame_queue_t *q, frame_node_t** node)
+{
+    if ((q == NULL) || (node == NULL)) {
+        goto ERR;
+    }
+
+    if (0 != pthread_mutex_lock(&(q->locker))) {
+        LOGE("failed to lock frame cache\n");
+        goto ERR;
+    }
+
+    if (0 != get_frame_from_cache(q->cache, node)) {
+        pthread_mutex_unlock(&(q->locker));
+
+        goto ERR;
+    }
+
+    pthread_mutex_unlock(&(q->locker));
+
+    return 0;
+ERR:
+    return -1;
+}
+
+int wait_queue(frame_queue_t *q)
+{
+    if (q == NULL) {
+        goto ERR;
+    }
+
+ERR:
+    return -1;
+}
+
+void debug_dump_node(frame_node_t *node)
+{
+    printf("0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x\n",
+            node->mem[0],
+            node->mem[1],
+            node->mem[2],
+            node->mem[3],
+            node->mem[4],
+            node->mem[5]);
+}
+
+void clear_ok_queue(void)
+{
+    frame_node_t* node = NULL;
+    uvc_cache_t* uvc_cache = uvc_cache_get();
+
+    events_init();
+    while (0 == get_node_from_queue(uvc_cache->ok_queue, &node)) {
+        node->used = 0;
+        put_node_to_queue(uvc_cache->free_queue, node);
+    }
+}

sample/uvc_app/common/frame_cache.h

@@ -0,0 +1,58 @@
+/*
+ * Copyright (c) XMEDIA. All rights reserved.
+ */
+/*
+ * The header file about frame cache
+ */
+
+#ifndef __FRAME_CACHE_H__
+#define __FRAME_CACHE_H__
+
+#include <pthread.h>
+
+typedef struct frame_node_t {
+    unsigned char *mem;
+    unsigned int length;
+    unsigned int used;
+    unsigned int index;
+    unsigned int offset;
+    struct frame_node_t *next;
+} frame_node_t;
+
+typedef struct frame_cache_t {
+    struct frame_node_t *head;
+    struct frame_node_t *tail;
+    unsigned int count;
+} frame_cache_t;
+
+typedef struct frame_queue_t {
+    struct frame_cache_t *cache;
+    pthread_mutex_t locker;
+} frame_queue_t;
+
+typedef struct uvc_cache_t {
+    frame_queue_t *ok_queue;
+    frame_queue_t *free_queue;
+} uvc_cache_t;
+
+typedef struct uac_cache_t {
+    frame_queue_t *ok_queue;
+    frame_queue_t *free_queue;
+} uac_cache_t;
+
+int create_uvc_cache(void);
+void destroy_uvc_cache(void);
+uvc_cache_t *uvc_cache_get(void);
+
+int create_uac_cache(void);
+void destroy_uac_cache(void);
+uac_cache_t *uac_cache_get(void);
+
+int put_node_to_queue(frame_queue_t *q, frame_node_t *node);
+int get_node_from_queue(frame_queue_t *q, frame_node_t **node);
+void clear_uvc_cache(void);
+void debug_dump_node(frame_node_t *node);
+
+void clear_ok_queue(void);
+
+#endif //__FRAME_CACHE_H__

sample/uvc_app/common/iniparser.c

@@ -0,0 +1,952 @@
+/*
+ * Copyright (c) XMEDIA. All rights reserved.
+ */
+//extern "C" {
+
+/*-------------------------------------------------------------------------*/
+
+/**
+   @file    iniparser.c
+   @author  N. Devillard
+   @brief   Parser for ini files.
+ */
+
+/*--------------------------------------------------------------------------*/
+/*---------------------------- Includes ------------------------------------*/
+#include <ctype.h>
+#include "iniparser.h"
+
+/*---------------------------- Defines -------------------------------------*/
+#define ASCIILINESZ (1024)
+#define INI_INVALID_KEY ((char*)-1)
+
+/*---------------------------------------------------------------------------
+                        Private to this module
+ ---------------------------------------------------------------------------*/
+
+/**
+ * This enum stores the status for each parsed line (internal use only).
+ */
+typedef enum _line_status_
+{
+    LINE_UNPROCESSED,
+    LINE_ERROR,
+    LINE_EMPTY,
+    LINE_COMMENT,
+    LINE_SECTION,
+    LINE_VALUE
+} line_status;
+
+/*-------------------------------------------------------------------------*/
+
+/**
+  @brief    Convert a string to lowercase.
+  @param    s   String to convert.
+  @return   ptr to statically allocated string.
+
+  This function returns a pointer to a statically allocated string
+  containing a lowercased version of the input string. Do not free
+  or modify the returned string! Since the returned string is statically
+  allocated, it will be modified at each function call (not re-entrant).
+ */
+
+/*--------------------------------------------------------------------------*/
+static char * strlwc(const char * s)
+{
+    static char l[ASCIILINESZ + 1];
+    int i;
+
+    if (s == NULL)
+    {
+        return NULL;
+    }
+
+    memset(l, 0, ASCIILINESZ + 1);
+    i = 0;
+    while (s[i] && (i < ASCIILINESZ))
+    {
+        l[i] = (char)tolower((int)s[i]);
+        i++;
+    }
+
+    l[ASCIILINESZ] = (char)0;
+    return l;
+}
+
+/*-------------------------------------------------------------------------*/
+
+/**
+  @brief    Remove blanks at the beginning and the end of a string.
+  @param    s   String to parse.
+  @return   ptr to statically allocated string.
+
+  This function returns a pointer to a statically allocated string,
+  which is identical to the input string, except that all blank
+  characters at the end and the beg. of the string have been removed.
+  Do not free or modify the returned string! Since the returned string
+  is statically allocated, it will be modified at each function call
+  (not re-entrant).
+ */
+
+/*--------------------------------------------------------------------------*/
+static char * strstrip(const char * s)
+{
+    static char l[ASCIILINESZ + 1];
+    char * last;
+
+    if (s == NULL)
+    {
+        return NULL;
+    }
+
+    while (isspace((int)*s) && *s)
+    {
+        s++;
+    }
+
+    memset(l, 0, ASCIILINESZ + 1);
+    strcpy(l, s);
+    last = l + strlen(l);
+    while (last > l)
+    {
+        if (!isspace((int)*(last - 1)))
+        {
+            break;
+        }
+
+        last--;
+    }
+
+    *last = (char)0;
+    return (char*)l;
+}
+
+/*-------------------------------------------------------------------------*/
+
+/**
+  @brief    Get number of sections in a dictionary
+  @param    d   Dictionary to examine
+  @return   int Number of sections found in dictionary
+
+  This function returns the number of sections found in a dictionary.
+  The test to recognize sections is done on the string stored in the
+  dictionary: a section name is given as "section" whereas a key is
+  stored as "section:key", thus the test looks for entries that do not
+  contain a colon.
+
+  This clearly fails in the case a section name contains a colon, but
+  this should simply be avoided.
+
+  This function returns -1 in case of error.
+ */
+
+/*--------------------------------------------------------------------------*/
+int iniparser_getnsec(dictionary * d)
+{
+    int i;
+    int nsec;
+
+    if (d == NULL)
+    {
+        return -1;
+    }
+
+    nsec = 0;
+    for (i = 0; i < d->size; i++)
+    {
+        if (d->key[i] == NULL)
+        {
+            continue;
+        }
+
+        if (strchr(d->key[i], ':') == NULL)
+        {
+            nsec++;
+        }
+    }
+
+    return nsec;
+}
+
+/*-------------------------------------------------------------------------*/
+
+/**
+  @brief    Get name for section n in a dictionary.
+  @param    d   Dictionary to examine
+  @param    n   Section number (from 0 to nsec-1).
+  @return   Pointer to char string
+
+  This function locates the n-th section in a dictionary and returns
+  its name as a pointer to a string statically allocated inside the
+  dictionary. Do not free or modify the returned string!
+
+  This function returns NULL in case of error.
+ */
+
+/*--------------------------------------------------------------------------*/
+char * iniparser_getsecname(dictionary * d, int n)
+{
+    int i;
+    int foundsec;
+
+    if ((d == NULL) || (n < 0))
+    {
+        return NULL;
+    }
+
+    foundsec = 0;
+    for (i = 0; i < d->size; i++)
+    {
+        if (d->key[i] == NULL)
+        {
+            continue;
+        }
+
+        if (strchr(d->key[i], ':') == NULL)
+        {
+            foundsec++;
+            if (foundsec > n)
+            {
+                break;
+            }
+        }
+    }
+
+    if (foundsec <= n)
+    {
+        return NULL;
+    }
+
+    return d->key[i];
+}
+
+/*-------------------------------------------------------------------------*/
+
+/**
+  @brief    Dump a dictionary to an opened file pointer.
+  @param    d   Dictionary to dump.
+  @param    f   Opened file pointer to dump to.
+  @return   void
+
+  This function prints out the contents of a dictionary, one element by
+  line, onto the provided file pointer. It is OK to specify @c stderr
+  or @c stdout as output files. This function is meant for debugging
+  purposes mostly.
+ */
+
+/*--------------------------------------------------------------------------*/
+void iniparser_dump(dictionary * d, FILE * f)
+{
+    int i;
+
+    if ((d == NULL) || (f == NULL))
+    {
+        return;
+    }
+
+    for (i = 0; i < d->size; i++)
+    {
+        if (d->key[i] == NULL)
+        {
+            continue;
+        }
+
+        if (d->val[i] != NULL)
+        {
+            fprintf(f, "[%s]=[%s]\n", d->key[i], d->val[i]);
+        }
+        else
+        {
+            fprintf(f, "[%s]=UNDEF\n", d->key[i]);
+        }
+    }
+
+    return;
+}
+
+/*-------------------------------------------------------------------------*/
+
+/**
+  @brief    Save a dictionary to a loadable ini file
+  @param    d   Dictionary to dump
+  @param    f   Opened file pointer to dump to
+  @return   void
+
+  This function dumps a given dictionary into a loadable ini file.
+  It is Ok to specify @c stderr or @c stdout as output files.
+ */
+
+/*--------------------------------------------------------------------------*/
+void iniparser_dump_ini(dictionary * d, FILE * f)
+{
+    int i;
+    int nsec;
+    char *  secname;
+
+    if ((d == NULL) || (f == NULL))
+    {
+        return;
+    }
+
+    nsec = iniparser_getnsec(d);
+    if (nsec < 1)
+    {
+        /* No section in file: dump all keys as they are */
+        for (i = 0; i < d->size; i++)
+        {
+            if (d->key[i] == NULL)
+            {
+                continue;
+            }
+
+            fprintf(f, "%s = %s\n", d->key[i], d->val[i]);
+        }
+
+        return;
+    }
+
+    for (i = 0; i < nsec; i++)
+    {
+        secname = iniparser_getsecname(d, i);
+        iniparser_dumpsection_ini(d, secname, f);
+    }
+
+    fprintf(f, "\n");
+    return;
+}
+
+/*-------------------------------------------------------------------------*/
+
+/**
+  @brief    Save a dictionary section to a loadable ini file
+  @param    d   Dictionary to dump
+  @param    s   Section name of dictionary to dump
+  @param    f   Opened file pointer to dump to
+  @return   void
+
+  This function dumps a given section of a given dictionary into a loadable ini
+  file.  It is Ok to specify @c stderr or @c stdout as output files.
+ */
+
+/*--------------------------------------------------------------------------*/
+void iniparser_dumpsection_ini(dictionary * d, char * s, FILE * f)
+{
+    int j;
+    char keym[ASCIILINESZ + 1];
+    int seclen;
+
+    if ((d == NULL) || (f == NULL))
+    {
+        return;
+    }
+
+    if (!iniparser_find_entry(d, s))
+    {
+        return;
+    }
+
+    seclen = (int)strlen(s);
+    fprintf(f, "\n[%s]\n", s);
+    sprintf(keym, "%s:", s);
+    for (j = 0; j < d->size; j++)
+    {
+        if (d->key[j] == NULL)
+        {
+            continue;
+        }
+
+        if (!strncmp(d->key[j], keym, seclen + 1))
+        {
+            fprintf(f,
+                    "%-30s = %s\n",
+                    d->key[j] + seclen + 1,
+                    d->val[j] ? d->val[j] : "");
+        }
+    }
+
+    fprintf(f, "\n");
+    return;
+}
+
+/*-------------------------------------------------------------------------*/
+
+/**
+  @brief    Get the number of keys in a section of a dictionary.
+  @param    d   Dictionary to examine
+  @param    s   Section name of dictionary to examine
+  @return   Number of keys in section
+ */
+
+/*--------------------------------------------------------------------------*/
+int iniparser_getsecnkeys(dictionary * d, char * s)
+{
+    int seclen, nkeys;
+    char keym[ASCIILINESZ + 1];
+    int j;
+
+    nkeys = 0;
+
+    if (d == NULL)
+    {
+        return nkeys;
+    }
+
+    if (!iniparser_find_entry(d, s))
+    {
+        return nkeys;
+    }
+
+    seclen = (int)strlen(s);
+    sprintf(keym, "%s:", s);
+
+    for (j = 0; j < d->size; j++)
+    {
+        if (d->key[j] == NULL)
+        {
+            continue;
+        }
+
+        if (!strncmp(d->key[j], keym, seclen + 1))
+        {
+            nkeys++;
+        }
+    }
+
+    return nkeys;
+}
+
+/*-------------------------------------------------------------------------*/
+
+/**
+  @brief    Get the number of keys in a section of a dictionary.
+  @param    d   Dictionary to examine
+  @param    s   Section name of dictionary to examine
+  @return   pointer to statically allocated character strings
+
+  This function queries a dictionary and finds all keys in a given section.
+  Each pointer in the returned char pointer-to-pointer is pointing to
+  a string allocated in the dictionary; do not free or modify them.
+
+  This function returns NULL in case of error.
+ */
+
+/*--------------------------------------------------------------------------*/
+char ** iniparser_getseckeys(dictionary * d, char * s)
+{
+    char **keys;
+
+    int i, j;
+    char keym[ASCIILINESZ + 1];
+    int seclen, nkeys;
+
+    keys = NULL;
+
+    if (d == NULL)
+    {
+        return keys;
+    }
+
+    if (!iniparser_find_entry(d, s))
+    {
+        return keys;
+    }
+
+    nkeys = iniparser_getsecnkeys(d, s);
+
+    keys = (char**) malloc(nkeys * sizeof(char*));
+
+    seclen = (int)strlen(s);
+    sprintf(keym, "%s:", s);
+
+    i = 0;
+
+    for (j = 0; j < d->size; j++)
+    {
+        if (d->key[j] == NULL)
+        {
+            continue;
+        }
+
+        if (!strncmp(d->key[j], keym, seclen + 1))
+        {
+            keys[i] = d->key[j];
+            i++;
+        }
+    }
+
+    return keys;
+}
+
+/*-------------------------------------------------------------------------*/
+
+/**
+  @brief    Get the string associated to a key
+  @param    d       Dictionary to search
+  @param    key     Key string to look for
+  @param    def     Default value to return if key not found.
+  @return   pointer to statically allocated character string
+
+  This function queries a dictionary for a key. A key as read from an
+  ini file is given as "section:key". If the key cannot be found,
+  the pointer passed as 'def' is returned.
+  The returned char pointer is pointing to a string allocated in
+  the dictionary, do not free or modify it.
+ */
+
+/*--------------------------------------------------------------------------*/
+char * iniparser_getstring(dictionary * d, const char * key, char * def)
+{
+    char * lc_key;
+    char * sval;
+
+    if ((d == NULL) || (key == NULL))
+    {
+        return def;
+    }
+
+    lc_key = strlwc(key);
+    sval = dictionary_get(d, lc_key, def);
+    return sval;
+}
+
+/*-------------------------------------------------------------------------*/
+
+/**
+  @brief    Get the string associated to a key, convert to an int
+  @param    d Dictionary to search
+  @param    key Key string to look for
+  @param    notfound Value to return in case of error
+  @return   integer
+
+  This function queries a dictionary for a key. A key as read from an
+  ini file is given as "section:key". If the key cannot be found,
+  the notfound value is returned.
+
+  Supported values for integers include the usual C notation
+  so decimal, octal (starting with 0) and hexadecimal (starting with 0x)
+  are supported. Examples:
+
+  "42"      ->  42
+  "042"     ->  34 (octal -> decimal)
+  "0x42"    ->  66 (hexa  -> decimal)
+
+  Warning: the conversion may overflow in various ways. Conversion is
+  totally outsourced to strtol(), see the associated man page for overflow
+  handling.
+
+  Credits: Thanks to A. Becker for suggesting strtol()
+ */
+
+/*--------------------------------------------------------------------------*/
+int iniparser_getint(dictionary * d, const char * key, int notfound)
+{
+    char    *   str;
+
+    str = iniparser_getstring(d, key, INI_INVALID_KEY);
+    if (str == INI_INVALID_KEY)
+    {
+        return notfound;
+    }
+
+    return (int)strtol(str, NULL, 0);
+}
+
+/*-------------------------------------------------------------------------*/
+
+/**
+  @brief    Get the string associated to a key, convert to a double
+  @param    d Dictionary to search
+  @param    key Key string to look for
+  @param    notfound Value to return in case of error
+  @return   double
+
+  This function queries a dictionary for a key. A key as read from an
+  ini file is given as "section:key". If the key cannot be found,
+  the notfound value is returned.
+ */
+
+/*--------------------------------------------------------------------------*/
+double iniparser_getdouble(dictionary * d, const char * key, double notfound)
+{
+    char    *   str;
+
+    str = iniparser_getstring(d, key, INI_INVALID_KEY);
+    if (str == INI_INVALID_KEY)
+    {
+        return notfound;
+    }
+
+    return atof(str);
+}
+
+/*-------------------------------------------------------------------------*/
+
+/**
+  @brief    Get the string associated to a key, convert to a boolean
+  @param    d Dictionary to search
+  @param    key Key string to look for
+  @param    notfound Value to return in case of error
+  @return   integer
+
+  This function queries a dictionary for a key. A key as read from an
+  ini file is given as "section:key". If the key cannot be found,
+  the notfound value is returned.
+
+  A true boolean is found if one of the following is matched:
+
+  - A string starting with 'y'
+  - A string starting with 'Y'
+  - A string starting with 't'
+  - A string starting with 'T'
+  - A string starting with '1'
+
+  A false boolean is found if one of the following is matched:
+
+  - A string starting with 'n'
+  - A string starting with 'N'
+  - A string starting with 'f'
+  - A string starting with 'F'
+  - A string starting with '0'
+
+  The notfound value returned if no boolean is identified, does not
+  necessarily have to be 0 or 1.
+ */
+
+/*--------------------------------------------------------------------------*/
+int iniparser_getboolean(dictionary * d, const char * key, int notfound)
+{
+    char    *   c;
+    int ret;
+
+    c = iniparser_getstring(d, key, INI_INVALID_KEY);
+    if (c == INI_INVALID_KEY)
+    {
+        return notfound;
+    }
+
+    if ((c[0] == 'y') || (c[0] == 'Y') || (c[0] == '1') || (c[0] == 't') || (c[0] == 'T'))
+    {
+        ret = 1;
+    }
+    else if ((c[0] == 'n') || (c[0] == 'N') || (c[0] == '0') || (c[0] == 'f') || (c[0] == 'F'))
+    {
+        ret = 0;
+    }
+    else
+    {
+        ret = notfound;
+    }
+
+    return ret;
+}
+
+/*-------------------------------------------------------------------------*/
+
+/**
+  @brief    Finds out if a given entry exists in a dictionary
+  @param    ini     Dictionary to search
+  @param    entry   Name of the entry to look for
+  @return   integer 1 if entry exists, 0 otherwise
+
+  Finds out if a given entry exists in the dictionary. Since sections
+  are stored as keys with NULL associated values, this is the only way
+  of querying for the presence of sections in a dictionary.
+ */
+
+/*--------------------------------------------------------------------------*/
+int iniparser_find_entry(dictionary  *   ini,
+                         const char  *   entry)
+{
+    int found = 0;
+
+    if (iniparser_getstring(ini, entry, INI_INVALID_KEY) != INI_INVALID_KEY)
+    {
+        found = 1;
+    }
+
+    return found;
+}
+
+/*-------------------------------------------------------------------------*/
+
+/**
+  @brief    Set an entry in a dictionary.
+  @param    ini     Dictionary to modify.
+  @param    entry   Entry to modify (entry name)
+  @param    val     New value to associate to the entry.
+  @return   int 0 if Ok, -1 otherwise.
+
+  If the given entry can be found in the dictionary, it is modified to
+  contain the provided value. If it cannot be found, -1 is returned.
+  It is Ok to set val to NULL.
+ */
+
+/*--------------------------------------------------------------------------*/
+int iniparser_set(dictionary * ini, const char * entry, const char * val)
+{
+    return dictionary_set(ini, strlwc(entry), val);
+}
+
+/*-------------------------------------------------------------------------*/
+
+/**
+  @brief    Delete an entry in a dictionary
+  @param    ini     Dictionary to modify
+  @param    entry   Entry to delete (entry name)
+  @return   void
+
+  If the given entry can be found, it is deleted from the dictionary.
+ */
+
+/*--------------------------------------------------------------------------*/
+void iniparser_unset(dictionary * ini, const char * entry)
+{
+    dictionary_unset(ini, strlwc(entry));
+}
+
+/*-------------------------------------------------------------------------*/
+
+/**
+  @brief    Load a single line from an INI file
+  @param    input_line  Input line, may be concatenated multi-line input
+  @param    section     Output space to store section
+  @param    key         Output space to store key
+  @param    value       Output space to store value
+  @return   line_status value
+ */
+
+/*--------------------------------------------------------------------------*/
+static line_status iniparser_line(const char * input_line,
+                                  char *       section,
+                                  char *       key,
+                                  char *       value)
+{
+    line_status sta;
+    char line[ASCIILINESZ + 1];
+    int len;
+
+    strcpy(line, strstrip(input_line));
+    len = (int)strlen(line);
+
+    sta = LINE_UNPROCESSED;
+    if (len < 1)
+    {
+        /* Empty line */
+        sta = LINE_EMPTY;
+    }
+    else if ((line[0] == '#') || (line[0] == ';'))
+    {
+        /* Comment line */
+        sta = LINE_COMMENT;
+    }
+    else if ((line[0] == '[') && (line[len - 1] == ']'))
+    {
+        /* Section name */
+        sscanf(line, "[%[^]]", section);
+        strcpy(section, strstrip(section));
+        strcpy(section, strlwc(section));
+        sta = LINE_SECTION;
+    }
+    else if (sscanf (line, "%[^=] = \"%[^\"]\"", key, value) == 2
+             || sscanf (line, "%[^=] = '%[^\']'", key, value) == 2
+             || sscanf (line, "%[^=] = %[^;#]", key, value) == 2)
+    {
+        /* Usual key=value, with or without comments */
+        strcpy(key, strstrip(key));
+        strcpy(key, strlwc(key));
+        strcpy(value, strstrip(value));
+
+        /*
+         * sscanf cannot handle '' or "" as empty values
+         * this is done here
+         */
+        if (!strcmp(value, "\"\"") || (!strcmp(value, "''")))
+        {
+            value[0] = 0;
+        }
+
+        sta = LINE_VALUE;
+    }
+    else if (sscanf(line, "%[^=] = %[;#]", key, value) == 2
+             || sscanf(line, "%[^=] %[=]", key, value) == 2)
+    {
+        /*
+         * Special cases:
+         * key=
+         * key=;
+         * key=#
+         */
+        strcpy(key, strstrip(key));
+        strcpy(key, strlwc(key));
+        value[0] = 0;
+        sta = LINE_VALUE;
+    }
+    else
+    {
+        /* Generate syntax error */
+        sta = LINE_ERROR;
+    }
+
+    return sta;
+}
+
+/*-------------------------------------------------------------------------*/
+
+/**
+  @brief    Parse an ini file and return an allocated dictionary object
+  @param    ininame Name of the ini file to read.
+  @return   Pointer to newly allocated dictionary
+
+  This is the parser for ini files. This function is called, providing
+  the name of the file to be read. It returns a dictionary object that
+  should not be accessed directly, but through accessor functions
+  instead.
+
+  The returned dictionary must be freed using iniparser_freedict().
+ */
+
+/*--------------------------------------------------------------------------*/
+dictionary * iniparser_load(const char * ininame)
+{
+    FILE * in;
+
+    char line    [ASCIILINESZ + 1];
+    char section [ASCIILINESZ/2];
+    char key     [ASCIILINESZ/2];
+    char tmp     [ASCIILINESZ + 1];
+    char val     [ASCIILINESZ + 1];
+
+    int last = 0;
+    int len;
+    int lineno = 0;
+    int errs = 0;
+
+    dictionary * dict;
+
+    if ((in = fopen(ininame, "r")) == NULL)
+    {
+        fprintf(stderr, "iniparser: cannot open %s\n", ininame);
+        return NULL;
+    }
+
+    dict = dictionary_new(0);
+    if (!dict)
+    {
+        fclose(in);
+        return NULL;
+    }
+
+    memset(line, 0, ASCIILINESZ);
+    memset(section, 0, ASCIILINESZ/2);
+    memset(key, 0, ASCIILINESZ/2);
+    memset(val, 0, ASCIILINESZ);
+    last = 0;
+
+    while (fgets(line + last, ASCIILINESZ - last, in) != NULL)
+    {
+        lineno++;
+        len = (int)strlen(line) - 1;
+        if (len == 0)
+        {
+            continue;
+        }
+
+        /* Safety check against buffer overflows */
+        if (line[len] != '\n')
+        {
+            fprintf(stderr,
+                    "iniparser: input line too long in %s (%d)\n",
+                    ininame,
+                    lineno);
+            dictionary_del(dict);
+            fclose(in);
+            return NULL;
+        }
+
+        /* Get rid of \n and spaces at end of line */
+        while ((len >= 0)
+           && ((line[len] == '\n') || (isspace(line[len]))))
+        {
+            line[len] = 0;
+            len--;
+        }
+
+        /* Detect multi-line */
+        if (line[len] == '\\')
+        {
+            /* Multi-line value */
+            last = len;
+            continue;
+        }
+        else
+        {
+            last = 0;
+        }
+
+        switch (iniparser_line(line, section, key, val))
+        {
+        case LINE_EMPTY:
+        case LINE_COMMENT:
+            break;
+
+        case LINE_SECTION:
+            errs = dictionary_set(dict, section, NULL);
+            break;
+
+        case LINE_VALUE:
+            snprintf(tmp, sizeof(tmp), "%s:%s", section, key);
+            errs = dictionary_set(dict, tmp, val);
+            break;
+
+        case LINE_ERROR:
+            fprintf(stderr, "iniparser: syntax error in %s (%d):\n",
+                    ininame,
+                    lineno);
+            fprintf(stderr, "-> %s\n", line);
+            errs++;
+            break;
+
+        default:
+            break;
+        }
+
+        memset(line, 0, ASCIILINESZ);
+        last = 0;
+        if (errs < 0)
+        {
+            fprintf(stderr, "iniparser: memory allocation failure\n");
+            break;
+        }
+    }
+
+    if (errs)
+    {
+        dictionary_del(dict);
+        dict = NULL;
+    }
+
+    fclose(in);
+    return dict;
+}
+
+/*-------------------------------------------------------------------------*/
+
+/**
+  @brief    Free all memory associated to an ini dictionary
+  @param    d Dictionary to free
+  @return   void
+
+  Free all memory associated to an ini dictionary.
+  It is mandatory to call this function before the dictionary object
+  gets out of the current context.
+ */
+
+/*--------------------------------------------------------------------------*/
+void iniparser_freedict(dictionary * d)
+{
+    dictionary_del(d);
+}
+
+//} //end of extern "C"
+
+/* vim: set ts=4 et sw=4 tw=75 */

sample/uvc_app/common/iniparser.h

@@ -0,0 +1,340 @@
+/*
+ * Copyright (c) XMEDIA. All rights reserved.
+ */
+/*-------------------------------------------------------------------------*/
+
+/**
+   @file    iniparser.h
+   @author  N. Devillard
+   @brief   Parser for ini files.
+ */
+
+/*--------------------------------------------------------------------------*/
+
+#ifndef _INIPARSER_H_
+#define _INIPARSER_H_
+
+/*---------------------------------------------------------------------------
+                                Includes
+ ---------------------------------------------------------------------------*/
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+/*
+ * The following #include is necessary on many Unixes but not Linux.
+ * It is not needed for Windows platforms.
+ * Uncomment it if needed.
+ */
+
+/* #include <unistd.h> */
+
+#include "dictionary.h"
+
+/*-------------------------------------------------------------------------*/
+
+/**
+  @brief    Get number of sections in a dictionary
+  @param    d   Dictionary to examine
+  @return   int Number of sections found in dictionary
+
+  This function returns the number of sections found in a dictionary.
+  The test to recognize sections is done on the string stored in the
+  dictionary: a section name is given as "section" whereas a key is
+  stored as "section:key", thus the test looks for entries that do not
+  contain a colon.
+
+  This clearly fails in the case a section name contains a colon, but
+  this should simply be avoided.
+
+  This function returns -1 in case of error.
+ */
+
+/*--------------------------------------------------------------------------*/
+
+int          iniparser_getnsec(dictionary * d);
+
+/*-------------------------------------------------------------------------*/
+
+/**
+  @brief    Get name for section n in a dictionary.
+  @param    d   Dictionary to examine
+  @param    n   Section number (from 0 to nsec-1).
+  @return   Pointer to char string
+
+  This function locates the n-th section in a dictionary and returns
+  its name as a pointer to a string statically allocated inside the
+  dictionary. Do not free or modify the returned string!
+
+  This function returns NULL in case of error.
+ */
+
+/*--------------------------------------------------------------------------*/
+
+char *       iniparser_getsecname(dictionary * d, int n);
+
+/*-------------------------------------------------------------------------*/
+
+/**
+  @brief    Save a dictionary to a loadable ini file
+  @param    d   Dictionary to dump
+  @param    f   Opened file pointer to dump to
+  @return   void
+
+  This function dumps a given dictionary into a loadable ini file.
+  It is Ok to specify @c stderr or @c stdout as output files.
+ */
+
+/*--------------------------------------------------------------------------*/
+
+void         iniparser_dump_ini(dictionary * d, FILE * f);
+
+/*-------------------------------------------------------------------------*/
+
+/**
+  @brief    Save a dictionary section to a loadable ini file
+  @param    d   Dictionary to dump
+  @param    s   Section name of dictionary to dump
+  @param    f   Opened file pointer to dump to
+  @return   void
+
+  This function dumps a given section of a given dictionary into a loadable ini
+  file.  It is Ok to specify @c stderr or @c stdout as output files.
+ */
+
+/*--------------------------------------------------------------------------*/
+
+void         iniparser_dumpsection_ini(dictionary * d, char * s, FILE * f);
+
+/*-------------------------------------------------------------------------*/
+
+/**
+  @brief    Dump a dictionary to an opened file pointer.
+  @param    d   Dictionary to dump.
+  @param    f   Opened file pointer to dump to.
+  @return   void
+
+  This function prints out the contents of a dictionary, one element by
+  line, onto the provided file pointer. It is OK to specify @c stderr
+  or @c stdout as output files. This function is meant for debugging
+  purposes mostly.
+ */
+
+/*--------------------------------------------------------------------------*/
+void         iniparser_dump(dictionary * d, FILE * f);
+
+/*-------------------------------------------------------------------------*/
+
+/**
+  @brief    Get the number of keys in a section of a dictionary.
+  @param    d   Dictionary to examine
+  @param    s   Section name of dictionary to examine
+  @return   Number of keys in section
+ */
+
+/*--------------------------------------------------------------------------*/
+int          iniparser_getsecnkeys(dictionary * d, char * s);
+
+/*-------------------------------------------------------------------------*/
+
+/**
+  @brief    Get the number of keys in a section of a dictionary.
+  @param    d   Dictionary to examine
+  @param    s   Section name of dictionary to examine
+  @return   pointer to statically allocated character strings
+
+  This function queries a dictionary and finds all keys in a given section.
+  Each pointer in the returned char pointer-to-pointer is pointing to
+  a string allocated in the dictionary; do not free or modify them.
+
+  This function returns NULL in case of error.
+ */
+
+/*--------------------------------------------------------------------------*/
+char **      iniparser_getseckeys(dictionary * d, char * s);
+
+/*-------------------------------------------------------------------------*/
+
+/**
+  @brief    Get the string associated to a key
+  @param    d       Dictionary to search
+  @param    key     Key string to look for
+  @param    def     Default value to return if key not found.
+  @return   pointer to statically allocated character string
+
+  This function queries a dictionary for a key. A key as read from an
+  ini file is given as "section:key". If the key cannot be found,
+  the pointer passed as 'def' is returned.
+  The returned char pointer is pointing to a string allocated in
+  the dictionary, do not free or modify it.
+ */
+
+/*--------------------------------------------------------------------------*/
+char *       iniparser_getstring(dictionary * d, const char * key, char * def);
+
+/*-------------------------------------------------------------------------*/
+
+/**
+  @brief    Get the string associated to a key, convert to an int
+  @param    d Dictionary to search
+  @param    key Key string to look for
+  @param    notfound Value to return in case of error
+  @return   integer
+
+  This function queries a dictionary for a key. A key as read from an
+  ini file is given as "section:key". If the key cannot be found,
+  the notfound value is returned.
+
+  Supported values for integers include the usual C notation
+  so decimal, octal (starting with 0) and hexadecimal (starting with 0x)
+  are supported. Examples:
+
+  - "42"      ->  42
+  - "042"     ->  34 (octal -> decimal)
+  - "0x42"    ->  66 (hexa  -> decimal)
+
+  Warning: the conversion may overflow in various ways. Conversion is
+  totally outsourced to strtol(), see the associated man page for overflow
+  handling.
+
+  Credits: Thanks to A. Becker for suggesting strtol()
+ */
+
+/*--------------------------------------------------------------------------*/
+int          iniparser_getint(dictionary * d, const char * key, int notfound);
+
+/*-------------------------------------------------------------------------*/
+
+/**
+  @brief    Get the string associated to a key, convert to a double
+  @param    d Dictionary to search
+  @param    key Key string to look for
+  @param    notfound Value to return in case of error
+  @return   double
+
+  This function queries a dictionary for a key. A key as read from an
+  ini file is given as "section:key". If the key cannot be found,
+  the notfound value is returned.
+ */
+
+/*--------------------------------------------------------------------------*/
+double       iniparser_getdouble(dictionary * d, const char * key, double notfound);
+
+/*-------------------------------------------------------------------------*/
+
+/**
+  @brief    Get the string associated to a key, convert to a boolean
+  @param    d Dictionary to search
+  @param    key Key string to look for
+  @param    notfound Value to return in case of error
+  @return   integer
+
+  This function queries a dictionary for a key. A key as read from an
+  ini file is given as "section:key". If the key cannot be found,
+  the notfound value is returned.
+
+  A true boolean is found if one of the following is matched:
+
+  - A string starting with 'y'
+  - A string starting with 'Y'
+  - A string starting with 't'
+  - A string starting with 'T'
+  - A string starting with '1'
+
+  A false boolean is found if one of the following is matched:
+
+  - A string starting with 'n'
+  - A string starting with 'N'
+  - A string starting with 'f'
+  - A string starting with 'F'
+  - A string starting with '0'
+
+  The notfound value returned if no boolean is identified, does not
+  necessarily have to be 0 or 1.
+ */
+
+/*--------------------------------------------------------------------------*/
+int          iniparser_getboolean(dictionary * d, const char * key, int notfound);
+
+/*-------------------------------------------------------------------------*/
+
+/**
+  @brief    Set an entry in a dictionary.
+  @param    ini     Dictionary to modify.
+  @param    entry   Entry to modify (entry name)
+  @param    val     New value to associate to the entry.
+  @return   int 0 if Ok, -1 otherwise.
+
+  If the given entry can be found in the dictionary, it is modified to
+  contain the provided value. If it cannot be found, -1 is returned.
+  It is Ok to set val to NULL.
+ */
+
+/*--------------------------------------------------------------------------*/
+int          iniparser_set(dictionary * ini, const char * entry, const char * val);
+
+/*-------------------------------------------------------------------------*/
+
+/**
+  @brief    Delete an entry in a dictionary
+  @param    ini     Dictionary to modify
+  @param    entry   Entry to delete (entry name)
+  @return   void
+
+  If the given entry can be found, it is deleted from the dictionary.
+ */
+
+/*--------------------------------------------------------------------------*/
+void         iniparser_unset(dictionary * ini, const char * entry);
+
+/*-------------------------------------------------------------------------*/
+
+/**
+  @brief    Finds out if a given entry exists in a dictionary
+  @param    ini     Dictionary to search
+  @param    entry   Name of the entry to look for
+  @return   integer 1 if entry exists, 0 otherwise
+
+  Finds out if a given entry exists in the dictionary. Since sections
+  are stored as keys with NULL associated values, this is the only way
+  of querying for the presence of sections in a dictionary.
+ */
+
+/*--------------------------------------------------------------------------*/
+int          iniparser_find_entry(dictionary * ini, const char * entry);
+
+/*-------------------------------------------------------------------------*/
+
+/**
+  @brief    Parse an ini file and return an allocated dictionary object
+  @param    ininame Name of the ini file to read.
+  @return   Pointer to newly allocated dictionary
+
+  This is the parser for ini files. This function is called, providing
+  the name of the file to be read. It returns a dictionary object that
+  should not be accessed directly, but through accessor functions
+  instead.
+
+  The returned dictionary must be freed using iniparser_freedict().
+ */
+
+/*--------------------------------------------------------------------------*/
+dictionary * iniparser_load(const char * ininame);
+
+/*-------------------------------------------------------------------------*/
+
+/**
+  @brief    Free all memory associated to an ini dictionary
+  @param    d Dictionary to free
+  @return   void
+
+  Free all memory associated to an ini dictionary.
+  It is mandatory to call this function before the dictionary object
+  gets out of the current context.
+ */
+
+/*--------------------------------------------------------------------------*/
+void         iniparser_freedict(dictionary * d);
+
+#endif