applications/jpip/opj_client/opj_dec_server/cache_manager.c

   1 /*
   2  * $Id: cache_manager.c 53 2011-05-09 16:55:39Z kaori $
   3  *
   4  * Copyright (c) 2002-2011, Communications and Remote Sensing Laboratory, Universite catholique de Louvain (UCL), Belgium
   5  * Copyright (c) 2002-2011, Professor Benoit Macq
   6  * Copyright (c) 2010-2011, Kaori Hagihara
   7  * All rights reserved.
   8  *
   9  * Redistribution and use in source and binary forms, with or without
  10  * modification, are permitted provided that the following conditions
  11  * are met:
  12  * 1. Redistributions of source code must retain the above copyright
  13  *    notice, this list of conditions and the following disclaimer.
  14  * 2. Redistributions in binary form must reproduce the above copyright
  15  *    notice, this list of conditions and the following disclaimer in the
  16  *    documentation and/or other materials provided with the distribution.
  17  *
  18  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
  19  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  20  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  21  * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
  22  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  23  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  24  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  25  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  26  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  27  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  28  * POSSIBILITY OF SUCH DAMAGE.
  29  */
  30
  31 #include <stdio.h>
  32 #include <stdlib.h>
  33 #include <string.h>
  34 #include "cache_manager.h"
  35
  36 //! maximum length of channel identifier
  37 #define MAX_LENOFCID 30
  38
  39 cachelist_param_t * gene_cachelist()
  40 {
  41   cachelist_param_t *cachelist;
  42
  43   cachelist = (cachelist_param_t *)malloc( sizeof(cachelist_param_t));
  44
  45   cachelist->first = NULL;
  46   cachelist->last  = NULL;
  47
  48   return cachelist;
  49 }
  50
  51 void delete_cachelist(cachelist_param_t **cachelist)
  52 {
  53   cache_param_t *cachePtr, *cacheNext;
  54
  55   cachePtr = (*cachelist)->first;
  56   while( cachePtr != NULL){
  57     cacheNext=cachePtr->next;
  58     delete_cache( &cachePtr);
  59     cachePtr=cacheNext;
  60   }
  61   free( *cachelist);
  62 }
  63
  64 cache_param_t * gene_cache( char *targetname, int csn, char *tid, char *cid)
  65 {
  66   cache_param_t *cache;
  67
  68   cache = (cache_param_t *)malloc( sizeof(cache_param_t));
  69   strcpy( cache->filename, targetname);
  70   strcpy( cache->tid, tid);
  71   cache->csn = csn;
  72   cache->cid = (char **)malloc( sizeof(char *));
  73   *cache->cid = (char *)malloc( MAX_LENOFCID);
  74   strcpy( *cache->cid, cid);
  75   cache->numOfcid = 1;
  76 #if 1
  77   cache->metadatalist = NULL;
  78 #else
  79   cache->metadatalist = gene_metadatalist();
  80 #endif
  81   cache->ihdrbox = NULL;
  82   cache->next = NULL;
  83
  84   return cache;
  85 }
  86
  87 void delete_cache( cache_param_t **cache)
  88 {
  89   int i;
  90
  91   delete_metadatalist( &(*cache)->metadatalist);
  92
  93   if((*cache)->ihdrbox)
  94     free((*cache)->ihdrbox);
  95   for( i=0; i<(*cache)->numOfcid; i++)
  96     free( (*cache)->cid[i]);
  97   free( (*cache)->cid);
  98   free( *cache);
  99 }
 100
 101 void insert_cache_into_list( cache_param_t *cache, cachelist_param_t *cachelist)
 102 {
 103   if( cachelist->first)
 104     cachelist->last->next = cache;
 105   else
 106     cachelist->first = cache;
 107   cachelist->last = cache;
 108 }
 109
 110 cache_param_t * search_cache( char targetname[], cachelist_param_t *cachelist)
 111 {
 112   cache_param_t *foundcache;
 113
 114   foundcache = cachelist->first;
 115
 116   while( foundcache != NULL){
 117
 118     if( strcmp( targetname, foundcache->filename) == 0)
 119       return foundcache;
 120
 121     foundcache = foundcache->next;
 122   }
 123   return NULL;
 124 }
 125
 126 cache_param_t * search_cacheBycsn( int csn, cachelist_param_t *cachelist)
 127 {
 128   cache_param_t *foundcache;
 129
 130   foundcache = cachelist->first;
 131
 132   while( foundcache != NULL){
 133
 134     if(  csn == foundcache->csn)
 135       return foundcache;
 136     foundcache = foundcache->next;
 137   }
 138   return NULL;
 139 }
 140
 141 cache_param_t * search_cacheBycid( char cid[], cachelist_param_t *cachelist)
 142 {
 143   cache_param_t *foundcache;
 144   int i;
 145
 146   foundcache = cachelist->first;
 147
 148   while( foundcache != NULL){
 149     for( i=0; i<foundcache->numOfcid; i++)
 150       if( strcmp( cid, foundcache->cid[i]) == 0)
 151         return foundcache;
 152     foundcache = foundcache->next;
 153   }
 154   return NULL;
 155 }
 156
 157 cache_param_t * search_cacheBytid( char tid[], cachelist_param_t *cachelist)
 158 {
 159   cache_param_t *foundcache;
 160
 161   foundcache = cachelist->first;
 162
 163   while( foundcache != NULL){
 164     if( strcmp( tid, foundcache->tid) == 0)
 165       return foundcache;
 166     foundcache = foundcache->next;
 167   }
 168   return NULL;
 169 }
 170
 171 void add_cachecid( char *cid, cache_param_t *cache)
 172 {
 173   char **tmp;
 174   int i;
 175
 176   tmp = cache->cid;
 177
 178   cache->cid = (char **)malloc( (cache->numOfcid+1)*sizeof(char *));
 179
 180   for( i=0; i<cache->numOfcid; i++){
 181     cache->cid[i] = (char *)malloc( MAX_LENOFCID);
 182     strcpy( cache->cid[i], tmp[i]);
 183     free( tmp[i]);
 184   }
 185   free( tmp);
 186
 187   cache->cid[ cache->numOfcid] = (char *)malloc( MAX_LENOFCID);
 188   strcpy( cache->cid[ cache->numOfcid], cid);
 189
 190   cache->numOfcid ++;
 191 }
 192
 193 void update_cachetid( char *tid, cache_param_t *cache)
 194 {
 195   if( tid[0] != '0' && strcmp( tid, cache->tid) !=0){
 196     fprintf( stderr, "tid is updated to %s for %s\n", tid, cache->filename);
 197     strcpy( cache->tid, tid);
 198   }
 199 }
 200
 201 void remove_cidInCache( char *cid, cache_param_t *cache);
 202
 203 void remove_cachecid( char *cid, cachelist_param_t *cachelist)
 204 {
 205   cache_param_t *cache;
 206
 207   cache = search_cacheBycid( cid, cachelist);
 208   remove_cidInCache( cid, cache);
 209 }
 210
 211 void remove_cidInCache( char *cid, cache_param_t *cache)
 212 {
 213   int idx = -1;
 214   char **tmp;
 215   int i, j;
 216
 217   for( i=0; i<cache->numOfcid; i++)
 218     if( strcmp( cid, cache->cid[i]) == 0){
 219       idx = i;
 220       break;
 221     }
 222
 223   if( idx == -1){
 224     fprintf( stderr, "cid: %s not found\n", cid);
 225     return;
 226   }
 227
 228   tmp = cache->cid;
 229
 230   cache->cid = (char **)malloc( (cache->numOfcid-1)*sizeof(char *));
 231
 232   for( i=0, j=0; i<cache->numOfcid; i++){
 233     if( i != idx){
 234       cache->cid[j] = (char *)malloc( MAX_LENOFCID);
 235       strcpy( cache->cid[j], tmp[i]);
 236       j++;
 237     }
 238     free( tmp[i]);
 239   }
 240   free( tmp);
 241
 242   cache->numOfcid --;
 243 }
 244
 245 void print_cache( cache_param_t *cache)
 246 {
 247   int i;
 248
 249   fprintf( stdout,"cache\n");
 250   fprintf( stdout,"\t filename: %s\n", cache->filename);
 251   fprintf( stdout,"\t tid: %s\n", cache->tid);
 252   fprintf( stdout,"\t csn: %d\n", cache->csn);
 253   fprintf( stdout,"\t cid:");
 254
 255   for( i=0; i<cache->numOfcid; i++)
 256     fprintf( stdout," %s", cache->cid[i]);
 257   fprintf( stdout,"\n");
 258 }
 259
 260 void print_allcache( cachelist_param_t *cachelist)
 261 {
 262   cache_param_t *ptr;
 263
 264   fprintf( stdout,"cache list\n");
 265
 266   ptr = cachelist->first;
 267   while( ptr != NULL){
 268     print_cache( ptr);
 269     ptr=ptr->next;
 270   }
 271 }