开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > 流媒体/Mpeg4/MP4 > 查看源码
asarray.c
资源名称：NETVIDEO.rar　[点击查看]
上传用户：sun1608
上传日期：2007-02-02
资源大小：6116k
文件大小：4k
源码类别：

流媒体/Mpeg4/MP4

开发平台：

Visual C++

asarray.c：源码内容
  1. /*
  2.  * FILE:    asarray.c
  3.  *
  4.  * AUTHORS: Orion Hodson
  5.  *
  6.  * Copyright (c) 1999-2000 University College London
  7.  * All rights reserved.
  8.  */
  9.  
  10. #ifndef HIDE_SOURCE_STRINGS
  11. static const char cvsid[] = 
  12. "$Id: asarray.c,v 1.3 2002/01/10 23:27:27 wmay Exp $";
  13. #endif /* HIDE_SOURCE_STRINGS */
  15. #include "config_unix.h"
  16. #include "config_win32.h"
  18. #include "debug.h"
  19. #include "memory.h"
  20. #include "util.h"
  22. #include "asarray.h"
  24. typedef struct s_hash_tuple {
  25.         uint32_t hash;
  26.         char *key;
  27.         char *value;
  28.         struct s_hash_tuple *next;
  29. } hash_tuple;
  31. #define ASARRAY_SIZE 11
  33. struct _asarray {
  34.         hash_tuple *table[ASARRAY_SIZE];
  35.         int32_t     nitems[ASARRAY_SIZE];
  36. };
  38. static uint32_t 
  39. asarray_hash(const char *key)
  40. {
  41.         uint32_t hash = 0;
  43.         while(*key != '') {
  44.                 hash = hash * 31;
  45.                 hash += ((uint32_t)*key) + 1;
  46.                 key++;
  47.         }
  49.         return hash;
  50. }
  52. int32_t
  53. asarray_add(asarray *pa, const char *key, const char *value)
  54. {
  55.         hash_tuple *t;
  56.         int row;
  58.         t = (hash_tuple*)xmalloc(sizeof(hash_tuple));
  59.         if (t) {
  60.                 /* transfer values */
  61.                 t->hash  = asarray_hash(key);
  62.                 t->key   = xstrdup(key);
  63.                 t->value = xstrdup(value);
  64.                 /* Add to table */
  65.                 row            = t->hash % ASARRAY_SIZE;
  66.                 t->next        = pa->table[row];
  67.                 pa->table[row] = t;
  68.                 pa->nitems[row]++;
  69.                 return TRUE;
  70.         }
  71.         return FALSE;
  72. }
  74. void
  75. asarray_remove(asarray *pa, const char *key)
  76. {
  77.         hash_tuple **t, *e;
  78.         uint32_t hash;
  79.         int row;
  81.         hash = asarray_hash(key);
  82.         row  = hash % ASARRAY_SIZE;
  83.         t    = &pa->table[row];
  84.         while((*t) != NULL) {
  85.                 if ((hash == (*t)->hash) && 
  86.                     (strcmp(key, (*t)->key) == 0)) {
  87.                         e = *t;
  88.                         *t = e->next;
  89.                         xfree(e->key);
  90.                         xfree(e->value);
  91.                         xfree(e);
  92.                         pa->nitems[row]--;
  93.                         ASSERT(pa->nitems[row] >= 0);
  94.                         break;
  95.                 } else {
  96.                         t = &(*t)->next;
  97.                 }
  98.         }
  99. }
  101. const char* 
  102. asarray_get_key_no(asarray *pa, int32_t index)
  103. {
  104.         int32_t row = 0;
  106.         index += 1;
  107.         while (row < ASARRAY_SIZE && index > pa->nitems[row]) {
  108.                 index -= pa->nitems[row];
  109.                 row++;
  110.         }
  112.         if (row < ASARRAY_SIZE) {
  113.                 hash_tuple *t;
  114.                 t = pa->table[row];
  115.                 while(--index > 0) {
  116.                         ASSERT(t->next != NULL);
  117.                         t = t->next;
  118.                 }
  119.                 return t->key;
  120.         }
  121.         return NULL;
  122. }
  124. /* asarray_lookup points value at actual value        */
  125. /* and return TRUE if key found.                      */
  126. int32_t
  127. asarray_lookup(asarray *pa, const char *key, char **value)
  128. {
  129.         hash_tuple *t;
  130.         int          row;
  131.         uint32_t     hash;
  133.         hash = asarray_hash(key);
  134.         row  = hash % ASARRAY_SIZE;
  136.         t = pa->table[row];
  137.         while(t != NULL) {
  138.                 if (t->hash == hash && strcmp(key, t->key) == 0) {
  139.                         *value = t->value;
  140.                         return TRUE;
  141.                 }
  142.                 t = t->next;
  143.         }
  144.         *value = NULL;
  145.         return FALSE;
  146. }
  148. int32_t
  149. asarray_create(asarray **ppa)
  150. {
  151.         asarray *pa;
  152.         pa = (asarray*)xmalloc(sizeof(asarray));
  153.         if (pa != NULL) {
  154.                 memset(pa, 0, sizeof(asarray));
  155.                 *ppa = pa;
  156.                 return TRUE;
  157.         }
  158.         return FALSE;
  159. }
  161. void
  162. asarray_destroy(asarray **ppa)
  163. {
  164.         asarray    *pa;
  165.         const char *key;
  167.         pa = *ppa;
  168.         ASSERT(pa != NULL);
  170.         while ((key = asarray_get_key_no(pa, 0)) != NULL) {
  171.                 asarray_remove(pa, key);
  172.         }
  174.         xfree(pa);
  175.         *ppa = NULL;
  176.         xmemchk();
  177. }