PJ_GridCatalog *pj_gc_findcatalog( projCtx ctx, const char *name )
{
PJ_GridCatalog *catalog;
pj_acquire_lock();
for( catalog=grid_catalog_list; catalog != NULL; catalog = catalog->next )
{
if( strcmp(catalog->catalog_name, name) == 0 )
{
pj_release_lock();
return catalog;
}
}
pj_release_lock();
catalog = pj_gc_readcatalog( ctx, name );
if( catalog == NULL )
return NULL;
pj_acquire_lock();
catalog->next = grid_catalog_list;
grid_catalog_list = catalog;
pj_release_lock();
return catalog;
}
projCtx pj_get_default_ctx()
{
pj_acquire_lock();
if( !default_context_initialized )
{
default_context.last_errno = 0;
default_context.debug_level = PJ_LOG_NONE;
default_context.logger = pj_stderr_logger;
default_context.app_data = NULL;
default_context.fileapi = pj_get_default_fileapi();
if( getenv("PROJ_DEBUG") != NULL )
{
if( atoi(getenv("PROJ_DEBUG")) > 0 )
default_context.debug_level = atoi(getenv("PROJ_DEBUG"));
else
default_context.debug_level = PJ_LOG_DEBUG_MINOR;
}
default_context_initialized = 1;
}
pj_release_lock();
return &default_context;
}
void pj_clear_initcache()
{
if( cache_alloc > 0 )
{
int i;
pj_acquire_lock();
for( i = 0; i < cache_count; i++ )
{
paralist *n, *t = cache_paralist[i];
pj_dalloc( cache_key[i] );
/* free parameter list elements */
for (; t != NULL; t = n) {
n = t->next;
pj_dalloc(t);
}
}
pj_dalloc( cache_key );
pj_dalloc( cache_paralist );
cache_count = 0;
cache_alloc= 0;
cache_key = NULL;
cache_paralist = NULL;
pj_release_lock();
}
}
PJ_INFO proj_info (void) {
/******************************************************************************
Basic info about the current instance of the PROJ.4 library.
Returns PJ_INFO struct.
******************************************************************************/
const char * const *paths;
size_t i, n;
size_t buf_size = 0;
char *buf = 0;
pj_acquire_lock ();
if (0!=info_initialized) {
pj_release_lock ();
return info;
}
info.major = PROJ_VERSION_MAJOR;
info.minor = PROJ_VERSION_MINOR;
info.patch = PROJ_VERSION_PATCH;
/* This is a controlled environment, so no risk of sprintf buffer
overflow. A normal version string is xx.yy.zz which is 8 characters
long and there is room for 64 bytes in the version string. */
sprintf (version, "%d.%d.%d", info.major, info.minor, info.patch);
info.searchpath = empty;
info.version = version;
info.release = pj_get_release ();
/* build search path string */
buf = path_append (buf, getenv ("HOME"), &buf_size);
buf = path_append (buf, getenv ("PROJ_LIB"), &buf_size);
paths = proj_get_searchpath ();
n = (size_t) proj_get_path_count ();
for (i = 0; i < n; i++)
buf = path_append (buf, paths[i], &buf_size);
info.searchpath = buf ? buf : empty;
info.paths = paths;
info.path_count = n;
info_initialized = 1;
pj_release_lock ();
return info;
}
paralist *pj_search_initcache( const char *filekey )
{
int i;
paralist *result = NULL;
pj_acquire_lock();
for( i = 0; result == NULL && i < cache_count; i++)
{
if( strcmp(filekey,cache_key[i]) == 0 )
{
result = pj_clone_paralist( cache_paralist[i] );
}
}
pj_release_lock();
return result;
}
void pj_insert_initcache( const char *filekey, const paralist *list )
{
pj_acquire_lock();
/*
** Grow list if required.
*/
if( cache_count == cache_alloc )
{
char **cache_key_new;
paralist **cache_paralist_new;
cache_alloc = cache_alloc * 2 + 15;
cache_key_new = (char **) pj_malloc(sizeof(char*) * cache_alloc);
memcpy( cache_key, cache_key_new, sizeof(char*) * cache_count);
pj_dalloc( cache_key );
cache_key = cache_key_new;
cache_paralist_new = (paralist **)
pj_malloc(sizeof(paralist*) * cache_alloc);
memcpy( cache_paralist_new, cache_paralist,
sizeof(paralist*) * cache_count );
pj_dalloc( cache_paralist );
cache_paralist = cache_paralist_new;
}
/*
** Duplicate the filekey and paralist, and insert in cache.
*/
cache_key[cache_count] = (char *) pj_malloc(strlen(filekey)+1);
strcpy( cache_key[cache_count], filekey );
cache_paralist[cache_count] = pj_clone_paralist( list );
cache_count++;
pj_release_lock();
}
int pj_gridinfo_load( projCtx ctx, PJ_GRIDINFO *gi )
{
struct CTABLE ct_tmp;
if( gi == NULL || gi->ct == NULL )
return 0;
pj_acquire_lock();
if( gi->ct->cvs != NULL )
{
pj_release_lock();
return 1;
}
memcpy(&ct_tmp, gi->ct, sizeof(struct CTABLE));
/* -------------------------------------------------------------------- */
/* Original platform specific CTable format. */
/* -------------------------------------------------------------------- */
if( strcmp(gi->format,"ctable") == 0 )
{
PAFile fid;
int result;
fid = pj_open_lib( ctx, gi->filename, "rb" );
if( fid == NULL )
{
pj_ctx_set_errno( ctx, PJD_ERR_FAILED_TO_LOAD_GRID );
pj_release_lock();
return 0;
}
result = nad_ctable_load( ctx, &ct_tmp, fid );
pj_ctx_fclose( ctx, fid );
gi->ct->cvs = ct_tmp.cvs;
pj_release_lock();
return result;
}
/* -------------------------------------------------------------------- */
/* CTable2 format. */
/* -------------------------------------------------------------------- */
else if( strcmp(gi->format,"ctable2") == 0 )
{
PAFile fid;
int result;
fid = pj_open_lib( ctx, gi->filename, "rb" );
if( fid == NULL )
{
pj_ctx_set_errno( ctx, PJD_ERR_FAILED_TO_LOAD_GRID );
pj_release_lock();
return 0;
}
result = nad_ctable2_load( ctx, &ct_tmp, fid );
pj_ctx_fclose( ctx, fid );
gi->ct->cvs = ct_tmp.cvs;
pj_release_lock();
return result;
}
/* -------------------------------------------------------------------- */
/* NTv1 format. */
/* We process one line at a time. Note that the array storage */
/* direction (e-w) is different in the NTv1 file and what */
/* the CTABLE is supposed to have. The phi/lam are also */
/* reversed, and we have to be aware of byte swapping. */
/* -------------------------------------------------------------------- */
else if( strcmp(gi->format,"ntv1") == 0 )
{
double *row_buf;
int row;
PAFile fid;
fid = pj_open_lib( ctx, gi->filename, "rb" );
if( fid == NULL )
{
pj_ctx_set_errno( ctx, PJD_ERR_FAILED_TO_LOAD_GRID );
pj_release_lock();
return 0;
}
pj_ctx_fseek( ctx, fid, gi->grid_offset, SEEK_SET );
row_buf = (double *) pj_malloc(gi->ct->lim.lam * sizeof(double) * 2);
ct_tmp.cvs = (FLP *) pj_malloc(gi->ct->lim.lam*gi->ct->lim.phi*sizeof(FLP));
if( row_buf == NULL || ct_tmp.cvs == NULL )
{
pj_dalloc( row_buf );
pj_dalloc( ct_tmp.cvs );
pj_ctx_set_errno( ctx, ENOMEM );
pj_release_lock();
return 0;
}
for( row = 0; row < gi->ct->lim.phi; row++ )
{
int i;
FLP *cvs;
double *diff_seconds;
if( pj_ctx_fread( ctx, row_buf,
sizeof(double), gi->ct->lim.lam * 2, fid )
!= (size_t)( 2 * gi->ct->lim.lam ) )
{
pj_dalloc( row_buf );
pj_dalloc( ct_tmp.cvs );
pj_ctx_set_errno( ctx, PJD_ERR_FAILED_TO_LOAD_GRID );
pj_release_lock();
return 0;
}
if( IS_LSB )
swap_words( (unsigned char *) row_buf, 8, gi->ct->lim.lam*2 );
/* convert seconds to radians */
diff_seconds = row_buf;
for( i = 0; i < gi->ct->lim.lam; i++ )
{
cvs = ct_tmp.cvs + (row) * gi->ct->lim.lam
+ (gi->ct->lim.lam - i - 1);
cvs->phi = (float) (*(diff_seconds++) * ((M_PI/180.0) / 3600.0));
cvs->lam = (float) (*(diff_seconds++) * ((M_PI/180.0) / 3600.0));
}
}
pj_dalloc( row_buf );
pj_ctx_fclose( ctx, fid );
gi->ct->cvs = ct_tmp.cvs;
pj_release_lock();
return 1;
}
/* -------------------------------------------------------------------- */
/* NTv2 format. */
/* We process one line at a time. Note that the array storage */
/* direction (e-w) is different in the NTv2 file and what */
/* the CTABLE is supposed to have. The phi/lam are also */
/* reversed, and we have to be aware of byte swapping. */
/* -------------------------------------------------------------------- */
else if( strcmp(gi->format,"ntv2") == 0 )
{
float *row_buf;
int row;
PAFile fid;
pj_log( ctx, PJ_LOG_DEBUG_MINOR,
"NTv2 - loading grid %s", gi->ct->id );
fid = pj_open_lib( ctx, gi->filename, "rb" );
if( fid == NULL )
{
pj_ctx_set_errno( ctx, PJD_ERR_FAILED_TO_LOAD_GRID );
pj_release_lock();
return 0;
}
pj_ctx_fseek( ctx, fid, gi->grid_offset, SEEK_SET );
row_buf = (float *) pj_malloc(gi->ct->lim.lam * sizeof(float) * 4);
ct_tmp.cvs = (FLP *) pj_malloc(gi->ct->lim.lam*gi->ct->lim.phi*sizeof(FLP));
if( row_buf == NULL || ct_tmp.cvs == NULL )
{
pj_dalloc( row_buf );
pj_dalloc( ct_tmp.cvs );
pj_ctx_set_errno( ctx, ENOMEM );
pj_release_lock();
return 0;
}
for( row = 0; row < gi->ct->lim.phi; row++ )
{
int i;
FLP *cvs;
float *diff_seconds;
if( pj_ctx_fread( ctx, row_buf, sizeof(float),
gi->ct->lim.lam*4, fid )
!= (size_t)( 4 * gi->ct->lim.lam ) )
{
pj_dalloc( row_buf );
pj_dalloc( ct_tmp.cvs );
pj_ctx_set_errno( ctx, PJD_ERR_FAILED_TO_LOAD_GRID );
pj_release_lock();
return 0;
}
if( gi->must_swap )
swap_words( (unsigned char *) row_buf, 4,
gi->ct->lim.lam*4 );
/* convert seconds to radians */
diff_seconds = row_buf;
for( i = 0; i < gi->ct->lim.lam; i++ )
{
cvs = ct_tmp.cvs + (row) * gi->ct->lim.lam
+ (gi->ct->lim.lam - i - 1);
cvs->phi = (float) (*(diff_seconds++) * ((M_PI/180.0) / 3600.0));
cvs->lam = (float) (*(diff_seconds++) * ((M_PI/180.0) / 3600.0));
diff_seconds += 2; /* skip accuracy values */
}
}
pj_dalloc( row_buf );
pj_ctx_fclose( ctx, fid );
gi->ct->cvs = ct_tmp.cvs;
pj_release_lock();
return 1;
}
/* -------------------------------------------------------------------- */
/* GTX format. */
/* -------------------------------------------------------------------- */
else if( strcmp(gi->format,"gtx") == 0 )
{
int words = gi->ct->lim.lam * gi->ct->lim.phi;
PAFile fid;
fid = pj_open_lib( ctx, gi->filename, "rb" );
if( fid == NULL )
{
pj_ctx_set_errno( ctx, PJD_ERR_FAILED_TO_LOAD_GRID );
pj_release_lock();
return 0;
}
pj_ctx_fseek( ctx, fid, gi->grid_offset, SEEK_SET );
ct_tmp.cvs = (FLP *) pj_malloc(words*sizeof(float));
if( ct_tmp.cvs == NULL )
{
pj_ctx_set_errno( ctx, ENOMEM );
pj_release_lock();
return 0;
}
if( pj_ctx_fread( ctx, ct_tmp.cvs, sizeof(float), words, fid )
!= (size_t)words )
{
pj_dalloc( ct_tmp.cvs );
pj_ctx_set_errno( ctx, PJD_ERR_FAILED_TO_LOAD_GRID );
pj_release_lock();
return 0;
}
if( IS_LSB )
swap_words( (unsigned char *) ct_tmp.cvs, 4, words );
pj_ctx_fclose( ctx, fid );
gi->ct->cvs = ct_tmp.cvs;
pj_release_lock();
return 1;
}
else
{
pj_release_lock();
return 0;
}
}
