static int compare(grib_accessor* a,grib_accessor* b)
{
int retval=0;
char *aval=0;
char *bval=0;
size_t alen = 0;
size_t blen = 0;
int err=0;
long count=0;
err=grib_value_count(a,&count);
if (err) return err;
alen=count;
err=grib_value_count(b,&count);
if (err) return err;
blen=count;
if (alen != blen) return GRIB_COUNT_MISMATCH;
aval=(char*)grib_context_malloc(a->parent->h->context,alen*sizeof(char));
bval=(char*)grib_context_malloc(b->parent->h->context,blen*sizeof(char));
grib_unpack_string(a,aval,&alen);
grib_unpack_string(b,bval,&blen);
retval = GRIB_SUCCESS;
if (!aval || !bval || grib_inline_strcmp(aval,bval)) retval = GRIB_STRING_VALUE_MISMATCH;
grib_context_free(a->parent->h->context,aval);
grib_context_free(b->parent->h->context,bval);
return retval;
}
grib_iarray* grib_iarray_new(grib_context* c,size_t size,size_t incsize)
{
grib_iarray* v=NULL;
if (!c) c=grib_context_get_default();
v=(grib_iarray*)grib_context_malloc(c,sizeof(grib_iarray));
if (!v) {
grib_context_log(c,GRIB_LOG_ERROR,
"grib_iarray_new unable to allocate %d bytes\n",sizeof(grib_iarray));
return NULL;
}
v->context=c;
v->size=size;
v->n=0;
v->incsize=incsize;
v->v=(long*)grib_context_malloc(c,sizeof(long)*size);
v->number_of_pop_front=0;
if (!v->v) {
grib_context_log(c,GRIB_LOG_ERROR,
"grib_iarray_new unable to allocate %d bytes\n",sizeof(long)*size);
return NULL;
}
return v;
}
static int compare(grib_accessor* a, grib_accessor* b) {
int retval=0;
double *aval=0;
double *bval=0;
size_t alen = (size_t)grib_value_count(a);
size_t blen = (size_t)grib_value_count(b);
if (alen != blen) return GRIB_COUNT_MISMATCH;
aval=grib_context_malloc(a->parent->h->context,alen*sizeof(double));
bval=grib_context_malloc(b->parent->h->context,blen*sizeof(double));
b->dirty=1;
a->dirty=1;
grib_unpack_double(a,aval,&alen);
grib_unpack_double(b,bval,&blen);
retval = GRIB_SUCCESS;
while (alen != 0) {
if (*bval != *aval) retval = GRIB_DOUBLE_VALUE_MISMATCH;
alen--;
}
grib_context_free(a->parent->h->context,aval);
grib_context_free(b->parent->h->context,bval);
return GRIB_SUCCESS;
}
static int init(grib_nearest* nearest,grib_handle* h,grib_arguments* args)
{
grib_nearest_lambert_conformal* self = (grib_nearest_lambert_conformal*) nearest;
self->Ni = grib_arguments_get_name(h,args,self->cargs++);
self->Nj = grib_arguments_get_name(h,args,self->cargs++);
self->i=(int*)grib_context_malloc(h->context,2*sizeof(int));
self->j=(int*)grib_context_malloc(h->context,2*sizeof(int));
return 0;
}
static int init(grib_nearest* nearest,grib_handle* h,grib_arguments* args)
{
grib_nearest_reduced* self = (grib_nearest_reduced*) nearest;
self->Nj = grib_arguments_get_name(h,args,self->cargs++);
self->pl = grib_arguments_get_name(h,args,self->cargs++);
self->j=(int*)grib_context_malloc(h->context,2*sizeof(int));
if (!self->j) return GRIB_OUT_OF_MEMORY;
self->k=(int*)grib_context_malloc( nearest->context,4*sizeof(int));
if (!self->k) return GRIB_OUT_OF_MEMORY;
return 0;
}
static int init(grib_iterator* i,grib_handle* h,grib_arguments* args)
{
grib_iterator_regular* self = (grib_iterator_regular*)i;
int ret = GRIB_SUCCESS;
long nap;
long nam;
double idir;
double lof,lol;
long loi;
const char* longoffirst = grib_arguments_get_name(h,args,self->carg++);
const char* idirec = grib_arguments_get_name(h,args,self->carg++);
const char* nalpar = grib_arguments_get_name(h,args,self->carg++);
const char* nalmer = grib_arguments_get_name(h,args,self->carg++);
const char* iScansNegatively = grib_arguments_get_name(h,args,self->carg++);
if((ret = grib_get_double_internal(h,longoffirst, &lof))) return ret;
if((ret = grib_get_double_internal(h,"longitudeOfLastGridPointInDegrees", &lol))) return ret;
if((ret = grib_get_double_internal(h,idirec, &idir))) return ret;
if((ret = grib_get_long_internal(h,nalpar, &nap))) return ret;
if((ret = grib_get_long_internal(h,nalmer, &nam))) return ret;
if((ret = grib_get_long_internal(h,iScansNegatively,&self->iScansNegatively)))
return ret;
idir=fabs(lof-lol)/(nap-1);
if (self->iScansNegatively) {
idir=-idir;
} else {
if (lof+(nap-2)*idir>360) lof-=360;
else if (lof+nap*idir>360) idir=360.0/(float)nap;
}
self->nap = nap;
self->nam = nam;
self->las = grib_context_malloc(h->context,nam*sizeof(double));
self->los = grib_context_malloc(h->context,nap*sizeof(double));
for( loi = 0; loi < nap; loi++ ) {
self->los[loi] = lof;
lof += idir ;
}
return ret;
}
static int pack_long(grib_accessor* a, const long* val, size_t *len)
{
double* values=NULL;
size_t size=0;
int ret=0;
grib_accessor_bits_per_value* self= (grib_accessor_bits_per_value*)a;
grib_context* c=a->context;
grib_handle* h=grib_handle_of_accessor(a);
if ( (ret=grib_get_size(h,self->values,&size)) != GRIB_SUCCESS) return ret;
values=(double*)grib_context_malloc(c,size*sizeof(double));
if (!values) return GRIB_OUT_OF_MEMORY;
if((ret = grib_get_double_array_internal(h,self->values,values,&size))
!= GRIB_SUCCESS) {
grib_context_free(c,values);
return ret;
}
if((ret = grib_set_long_internal(h, self->bits_per_value,*val))
!= GRIB_SUCCESS) return ret;
if((ret = grib_set_double_array_internal(h, self->values,values,size))
!= GRIB_SUCCESS) return ret;
grib_context_free(c,values);
return GRIB_SUCCESS;
}
static int spatial_difference (grib_context *c, unsigned long* vals, long len, long order, long* bias)
{
long j = 3;
long *v = (long*)grib_context_malloc(c,(len)*sizeof(long));
for(j = 0; j< len;j++)
v[j] = vals[j];
Assert(order == 2);
*bias=v[order];
for(j = order; j< len;j++){
v[j] -= vals [j-1];
v[j] -= vals [j-1] - vals[j-2];
if(*bias>v[j])
*bias = v[j];
}
for(j = order; j< len;j++){
Assert(v[j]-*bias >=0);
vals[j] = v[j]-*bias;
}
grib_context_free(c,v);
return 0;
}
static int unpack_string(grib_accessor*a , char* v, size_t *len){
grib_accessor_md5* self = (grib_accessor_md5*)a;
unsigned mess_len;
unsigned char* mess;
unsigned char* p;
unsigned char digest[16];
long offset,length;
grib_string_list* blacklist=NULL;
grib_accessor* b=NULL;
int ret=0;
char* s=NULL;
int i=0;
struct cvs_MD5Context md5c;
if (*len <32 ) {
grib_context_log(a->parent->h->context,GRIB_LOG_ERROR,"md5: array too small");
return GRIB_ARRAY_TOO_SMALL;
}
if((ret = grib_get_long_internal(a->parent->h,self->offset,&offset))
!= GRIB_SUCCESS)
return ret;
if((ret = grib_get_long_internal(a->parent->h,self->length,&length))
!= GRIB_SUCCESS)
return ret;
mess=grib_context_malloc(a->parent->h->context,length);
memcpy(mess,a->parent->h->buffer->data+offset,length);
mess_len=length;
blacklist=a->parent->h->context->blacklist;
while (blacklist && blacklist->value) {
b=grib_find_accessor(a->parent->h,blacklist->value);
if (!b) return GRIB_NOT_FOUND;
p=mess+b->offset-offset;
for (i=0;i<b->length;i++) *(p++)=0;
blacklist=blacklist->next;
}
cvs_MD5Init(&md5c);
cvs_MD5Update(&md5c,mess,mess_len);
cvs_MD5Final(digest,&md5c);
s=v;
for (i = 0; i < 16; i++)
{
sprintf (s,"%02x", (unsigned int) digest[i]);
s+=2;
}
return ret;
}
void grib_get_buffer_ownership(const grib_context *c, grib_buffer *b)
{
unsigned char* newdata;
if(b->property == GRIB_MY_BUFFER)
return;
newdata = (unsigned char*)grib_context_malloc(c, b->length);
memcpy(newdata, b->data, b->length);
b->data = newdata;
b->property = GRIB_MY_BUFFER;
}
grib_darray* grib_darray_new(grib_context* c,size_t size,size_t incsize) {
grib_darray* v=NULL;
if (!c) c=grib_context_get_default();
v=(grib_darray*)grib_context_malloc(c,sizeof(grib_darray));
if (!v) {
grib_context_log(c,GRIB_LOG_ERROR,
"grib_darray_new unable to allocate %d bytes\n",sizeof(grib_darray));
return NULL;
}
v->size=size;
v->n=0;
v->incsize=incsize;
v->v=(double*)grib_context_malloc(c,sizeof(double)*size);
if (!v->v) {
grib_context_log(c,GRIB_LOG_ERROR,
"grib_darray_new unable to allocate %d bytes\n",sizeof(double)*size);
return NULL;
}
return v;
}
static void dump_bytes(grib_dumper* d,grib_accessor* a,const char* comment)
{
grib_dumper_c_code *self = (grib_dumper_c_code*)d;
int err =0;
size_t size = a->length;
unsigned char* buf;
if (a->flags & GRIB_ACCESSOR_FLAG_READ_ONLY)
return;
if(size == 0)
return;
buf = grib_context_malloc(d->handle->context,size);
if(!buf)
{
fprintf(self->dumper.out,"/* %s: cannot malloc(%ld) */\n",a->name,(long)size);
return;
}
err = grib_unpack_bytes(a,buf,&size);
if(err){
grib_context_free(d->handle->context,buf);
fprintf(self->dumper.out," *** ERR=%d (%s) \n}",err,grib_get_error_message(err));
return ;
}
#if 0
if(size > 100) {
more = size - 100;
size = 100;
}
k = 0;
/* if(size > 100) size = 100; */
while(k < size)
{
int j;
for(i = 0; i < d->depth + 3 ; i++) fprintf(self->dumper.out," ");
for(j = 0; j < 16 && k < size; j++, k++)
{
fprintf(self->dumper.out,"%02x",buf[k]);
if(k != size-1)
fprintf(self->dumper.out,", ");
}
fprintf(self->dumper.out,"\n");
}
#endif
grib_context_free(d->handle->context,buf);
}
static int unpack_string(grib_accessor*a , char* v, size_t *len){
grib_accessor_md5* self = (grib_accessor_md5*)a;
unsigned mess_len;
unsigned char* mess;
unsigned char* p;
long offset,length;
grib_string_list* blacklist=NULL;
grib_accessor* b=NULL;
int ret=0;
int i=0;
struct grib_md5_state md5c;
if (*len <32 ) {
grib_context_log(a->context,GRIB_LOG_ERROR,"md5: array too small");
return GRIB_ARRAY_TOO_SMALL;
}
if((ret = grib_get_long_internal(grib_handle_of_accessor(a),self->offset,&offset))
!= GRIB_SUCCESS)
return ret;
if((ret = grib_expression_evaluate_long(grib_handle_of_accessor(a),self->length,&length))
!= GRIB_SUCCESS)
return ret;
mess=(unsigned char*)grib_context_malloc(a->context,length);
memcpy(mess,grib_handle_of_accessor(a)->buffer->data+offset,length);
mess_len=length;
blacklist=a->context->blacklist;
/* passed blacklist overrides context blacklist.
Consider to modify following line to extend context blacklist.
*/
if (self->blacklist) blacklist=self->blacklist;
while (blacklist && blacklist->value) {
b=grib_find_accessor(grib_handle_of_accessor(a),blacklist->value);
if (!b) {
grib_context_free(a->context,mess);
return GRIB_NOT_FOUND;
}
p=mess+b->offset-offset;
for (i=0;i<b->length;i++) *(p++)=0;
blacklist=blacklist->next;
}
grib_md5_init(&md5c);
grib_md5_add(&md5c,mess,mess_len);
grib_md5_end(&md5c,v);
grib_context_free(a->context,mess);
return ret;
}
static int pack_double (grib_accessor* a, const double* val, size_t *len)
{
grib_accessor_ibmfloat* self = (grib_accessor_ibmfloat*)a;
int ret = 0;
unsigned long i = 0;
unsigned long rlen = *len;
size_t buflen = 0;
unsigned char *buf = NULL;
long off = 0;
if(*len < 1)
{
grib_context_log(a->parent->h->context, GRIB_LOG_ERROR, " wrong size for %s it pack at least 1 values ", a->name , rlen );
*len = 0;
return GRIB_ARRAY_TOO_SMALL;
}
if (rlen == 1){
/*
double x = 0;
grib_nearest_smaller_ibm_float(val[0],&x);
double y = grib_long_to_ibm(grib_ibm_to_long(val[0]));
printf("IBMFLOAT val=%.20f nearest_smaller_ibm_float=%.20f long_to_ibm=%.20f\n",val[0],x ,y);
*/
off = byte_offset(a)*8;
ret = grib_encode_unsigned_long(a->parent->h->buffer->data,grib_ibm_to_long(val[0]), &off, 32);
if (*len > 1) grib_context_log(a->parent->h->context, GRIB_LOG_WARNING, "grib_accessor_unsigned : Trying to pack %d values in a scalar %s, packing first value", *len, a->name );
if (ret == GRIB_SUCCESS) len[0] = 1;
return ret;
}
buflen = rlen*4;
buf = (unsigned char*)grib_context_malloc(a->parent->h->context,buflen);
for(i=0; i < rlen;i++){
grib_encode_unsigned_longb(buf,grib_ibm_to_long(val[i]), &off, 32);
}
ret = grib_set_long_internal(a->parent->h,grib_arguments_get_name(a->parent->h,self->arg,0),rlen);
if(ret == GRIB_SUCCESS)
grib_buffer_replace(a, buf, buflen,1,1);
else
*len = 0;
grib_context_free(a->parent->h->context,buf);
a->length = byte_count(a);
return ret;
}
static int compare(grib_accessor* a,grib_accessor* b) {
int retval=0;
long *aval=0;
long *bval=0;
long count=0;
size_t alen = 0;
size_t blen = 0;
int err=0;
err=grib_value_count(a,&count);
if (err) return err;
alen=count;
err=grib_value_count(b,&count);
if (err) return err;
blen=count;
if (alen != blen) return GRIB_COUNT_MISMATCH;
aval=(long*)grib_context_malloc(a->parent->h->context,alen*sizeof(long));
bval=(long*)grib_context_malloc(b->parent->h->context,blen*sizeof(long));
grib_unpack_long(a,aval,&alen);
grib_unpack_long(b,bval,&blen);
retval = GRIB_SUCCESS;
while (alen != 0) {
if (*bval != *aval) retval = GRIB_LONG_VALUE_MISMATCH;
alen--;
}
grib_context_free(a->parent->h->context,aval);
grib_context_free(b->parent->h->context,bval);
return retval;
}
static void init(grib_accessor* a,const long l, grib_arguments* c)
{
grib_accessor_statistics* self = (grib_accessor_statistics*)a;
int n = 0;
self->missing_value = grib_arguments_get_name(a->parent->h,c,n++);
self->values = grib_arguments_get_name(a->parent->h,c,n++);
a->flags |= GRIB_ACCESSOR_FLAG_READ_ONLY;
a->flags |= GRIB_ACCESSOR_FLAG_FUNCTION;
a->flags |= GRIB_ACCESSOR_FLAG_HIDDEN;
self->number_of_elements=8;
self->v=(double*)grib_context_malloc(a->parent->h->context,
sizeof(double)*self->number_of_elements);
a->length=0;
a->dirty=1;
}
static int unpack_double(grib_accessor* a, double* val,size_t *len){
size_t rlen = 0;
long count=0;
unsigned long i = 0;
long *values = NULL;
long oneval = 0;
int ret = GRIB_SUCCESS;
ret=grib_value_count(a,&count);
if (ret) return ret;
rlen=count;
if(*len < rlen)
{
grib_context_log(a->parent->h->context, GRIB_LOG_ERROR, " wrong size for %s it contains %d values ", a->name , rlen);
*len = 0;
return GRIB_ARRAY_TOO_SMALL;
}
if(rlen == 1){
ret = grib_unpack_long(a,&oneval,&rlen);
if(ret != GRIB_SUCCESS) return ret;
*val = oneval;
*len = 1;
return GRIB_SUCCESS;
}
values = (long*)grib_context_malloc(a->parent->h->context,rlen*sizeof(long));
if(!values) return GRIB_INTERNAL_ERROR;
ret = grib_unpack_long(a,values,&rlen);
if(ret != GRIB_SUCCESS){
grib_context_free(a->parent->h->context,values);
return ret;
}
for(i=0; i< rlen;i++)
val[i] = values[i];
grib_context_free(a->parent->h->context,values);
*len = rlen;
return GRIB_SUCCESS;
}
static int pack_double(grib_accessor* a, const double* val, size_t *len)
{
double* values=NULL;
size_t size=0;
double missingValue=0;
long missingValuesPresent = 0;
int ret=0,i=0;
grib_accessor_offset_values* self= (grib_accessor_offset_values*)a;
grib_context* c=a->context;
grib_handle* h=grib_handle_of_accessor(a);
if (*val==0) return GRIB_SUCCESS;
if((ret = grib_get_double_internal(h,self->missingValue,&missingValue)) != GRIB_SUCCESS) {
return ret;
}
if((ret=grib_get_long_internal(h,"missingValuesPresent",&missingValuesPresent)) != GRIB_SUCCESS) {
return ret;
}
if ( (ret=grib_get_size(h,self->values,&size)) != GRIB_SUCCESS) return ret;
values=(double*)grib_context_malloc(c,size*sizeof(double));
if (!values) return GRIB_OUT_OF_MEMORY;
if((ret = grib_get_double_array_internal(h,self->values,values,&size)) != GRIB_SUCCESS) {
grib_context_free(c,values);
return ret;
}
for (i=0;i<size;i++) {
if (missingValuesPresent) {
if (values[i]!=missingValue) values[i]+=*val;
} else {
values[i]+=*val;
}
}
if((ret = grib_set_double_array_internal(h, self->values,values,size)) != GRIB_SUCCESS) return ret;
grib_context_free(c,values);
return GRIB_SUCCESS;
}
static int pack_long (grib_accessor* a, const long* val, size_t *len)
{
long missing=255;
int ret=0;
size_t size=0;
double* values;
grib_context* c=a->parent->h->context;
grib_handle* h=a->parent->h;
grib_accessor_gds_is_present* self = (grib_accessor_gds_is_present*)a;
if (*val != 1) return GRIB_NOT_IMPLEMENTED;
if ( (ret=grib_get_size(h,self->values,&size)) != GRIB_SUCCESS) return ret;
values=(double*)grib_context_malloc(c,size*sizeof(double));
if (!values) return GRIB_OUT_OF_MEMORY;
if((ret = grib_get_double_array_internal(h,self->values,values,&size))
!= GRIB_SUCCESS) {
grib_context_free(c,values);
return ret;
}
if((ret = grib_set_long_internal(h, self->gds_present,*val))
!= GRIB_SUCCESS) return ret;
if((ret = grib_set_long_internal(h, self->bitmap_present,*val))
!= GRIB_SUCCESS) return ret;
if((ret = grib_set_long_internal(h, self->grid_definition,missing))
!= GRIB_SUCCESS) return ret;
if((ret = grib_set_double_array_internal(h, self->values,values,size))
!= GRIB_SUCCESS) return ret;
grib_context_free(c,values);
return GRIB_SUCCESS;
}
static int unpack_long(grib_accessor* a, long* val, size_t *len) {
size_t size=0;
long* vector;
grib_accessor_long_vector* self = (grib_accessor_long_vector*)a;
grib_accessor* va=NULL;
grib_accessor_abstract_long_vector* v =NULL;
va=(grib_accessor*)grib_find_accessor(a->parent->h,self->vector);
v=(grib_accessor_abstract_long_vector*)va;
/*TODO implement the dirty mechanism to avoid to unpack every time */
grib_get_size(a->parent->h,self->vector,&size);
vector=(long*)grib_context_malloc(a->parent->h->context,sizeof(long)*size);
grib_unpack_long(va,vector,&size);
grib_context_free(a->parent->h->context,vector);
*val = v->v[self->index];
return GRIB_SUCCESS;
}
static int pack_double(grib_accessor* a, const double* val, size_t *len)
{
double* values=NULL;
double missingValue=0;
size_t size=0;
int ret=0,i=0;
grib_accessor_scale_values* self= (grib_accessor_scale_values*)a;
grib_context* c=a->parent->h->context;
grib_handle* h=a->parent->h;
if (*val==1) return GRIB_SUCCESS;
if((ret = grib_get_double_internal(h,self->missingValue,&missingValue))
!= GRIB_SUCCESS) {
return ret;
}
if ( (ret=grib_get_size(h,self->values,&size)) != GRIB_SUCCESS) return ret;
values=(double*)grib_context_malloc(c,size*sizeof(double));
if (!values) return GRIB_OUT_OF_MEMORY;
if((ret = grib_get_double_array_internal(h,self->values,values,&size))
!= GRIB_SUCCESS) {
grib_context_free(c,values);
return ret;
}
for (i=0;i<size;i++)
if (values[i]!=missingValue) values[i]*=*val;
if((ret = grib_set_double_array_internal(h, self->values,values,size))
!= GRIB_SUCCESS) return ret;
grib_context_free(c,values);
return GRIB_SUCCESS;
}
static int unpack_double_element(grib_accessor* a, size_t idx,double* val)
{
grib_accessor_data_apply_boustrophedonic_bitmap* self = (grib_accessor_data_apply_boustrophedonic_bitmap*)a;
int err = 0,i=0;
size_t cidx=0;
double missing_value = 0;
double* bvals=NULL;
size_t n_vals = 0;
long nn=0;
err=grib_value_count(a,&nn);
n_vals=nn;
if (err) return err;
if(!grib_find_accessor(a->parent->h,self->bitmap))
return grib_get_double_element_internal(a->parent->h,self->coded_values,idx,val);
if((err = grib_get_double_internal(a->parent->h,self->missing_value,&missing_value)) != GRIB_SUCCESS)
return err;
if((err = grib_get_double_element_internal(a->parent->h,self->bitmap,idx,val)) != GRIB_SUCCESS)
return err;
if (*val == 0) {*val=missing_value;return GRIB_SUCCESS;}
bvals = (double*)grib_context_malloc(a->parent->h->context,n_vals*sizeof(double));
if(bvals == NULL) return GRIB_OUT_OF_MEMORY;
if((err = grib_get_double_array_internal(a->parent->h,self->bitmap,bvals,&n_vals)) != GRIB_SUCCESS)
return err;
cidx=0;
for (i=0;i<idx;i++) {cidx+=bvals[i];}
grib_context_free(a->parent->h->context,bvals);
return grib_get_double_element_internal(a->parent->h,self->coded_values,cidx,val);
}
static int init(grib_iterator* i,grib_handle *h, grib_arguments* args)
{
grib_iterator_gen* self = (grib_iterator_gen*) i;
size_t dli=0;
int ret = GRIB_SUCCESS;
const char* rawdat = NULL;
const char* snumberOfPoints=NULL;
long numberOfPoints=0;
self->carg = 1;
snumberOfPoints = grib_arguments_get_name(h,args,self->carg++);
self->missingValue = grib_arguments_get_name(h,args,self->carg++);
rawdat = grib_arguments_get_name(h,args,self->carg++);
i->h = h; /* We may not need to keep them */
i->args = args;
if( (ret = grib_get_size(h,rawdat,&dli))!= GRIB_SUCCESS) return ret;
if( (ret = grib_get_long_internal(h,snumberOfPoints,&numberOfPoints))
!= GRIB_SUCCESS)
return ret;
if (numberOfPoints!=dli) {
grib_context_log(h->context,GRIB_LOG_ERROR,"%s != size(%s) (%ld!=%ld)",
snumberOfPoints,rawdat,numberOfPoints,dli);
return GRIB_WRONG_GRID;
}
i->nv = dli;
i->data = (double*)grib_context_malloc(h->context,(i->nv)*sizeof(double));
if( (ret = grib_get_double_array_internal(h,rawdat,i->data ,&(i->nv))))
return ret;
i->e = -1;
return ret;
}
static int unpack_long(grib_accessor* a, long* val, size_t *len)
{
int ret=GRIB_SUCCESS;
long ni=0,nj=0,plpresent=0;
size_t plsize=0;
long* pl;
int i;
grib_accessor_number_of_points* self = (grib_accessor_number_of_points*)a;
grib_context* c=a->context;
if((ret = grib_get_long_internal(grib_handle_of_accessor(a), self->ni,&ni)) != GRIB_SUCCESS)
return ret;
if((ret = grib_get_long_internal(grib_handle_of_accessor(a), self->nj,&nj)) != GRIB_SUCCESS)
return ret;
if(self->plpresent &&
((ret = grib_get_long_internal(grib_handle_of_accessor(a), self->plpresent,&plpresent)) != GRIB_SUCCESS) )
return ret;
if (nj == 0) return GRIB_GEOCALCULUS_PROBLEM;
if (plpresent) {
/*reduced*/
plsize=nj;
pl=(long*)grib_context_malloc(c,sizeof(long)*plsize);
grib_get_long_array_internal(grib_handle_of_accessor(a),self->pl,pl, &plsize);
*val=0;
for (i=0;i<plsize;i++) *val+=pl[i];
grib_context_free(c,pl);
} else {
/*regular*/
*val=ni*nj;
}
return ret;
}
static void dump_values(grib_dumper* d,grib_accessor* a)
{
grib_dumper_debug *self = (grib_dumper_debug*)d;
int i,k,err =0;
int more = 0;
double* buf = NULL;
size_t size=0;
long count=0;
if( a->length == 0 &&
(d->option_flags & GRIB_DUMP_FLAG_CODED) != 0)
return;
grib_value_count(a,&count);
size=count;
if(size == 1){
dump_double(d,a,NULL);
return ;
}
buf = (double*)grib_context_malloc(d->handle->context,size * sizeof(double));
set_begin_end(d,a);
for(i = 0; i < d->depth ; i++) fprintf(self->dumper.out," ");
fprintf(self->dumper.out,"%ld-%ld %s %s = (%ld,%ld)",self->begin,self->theEnd,a->creator->op, a->name,(long)size,a->length);
aliases(d,a);
fprintf(self->dumper.out," {");
if(!buf)
{
if(size == 0)
fprintf(self->dumper.out,"}\n");
else
fprintf(self->dumper.out," *** ERR cannot malloc(%ld) }\n",(long)size);
return;
}
fprintf(self->dumper.out,"\n");
err = grib_unpack_double(a,buf,&size);
if(err){
grib_context_free(d->handle->context,buf);
fprintf(self->dumper.out," *** ERR=%d (%s) [grib_dumper_debug::dump_values]\n}",err,grib_get_error_message(err));
return ;
}
if(size > 100) {
more = size - 100;
size = 100;
}
k = 0;
while(k < size)
{
#if 1
int j;
for(i = 0; i < d->depth + 3 ; i++) fprintf(self->dumper.out," ");
for(j = 0; j < 8 && k < size; j++, k++)
{
fprintf(self->dumper.out,"%10g",buf[k]);
if(k != size-1)
fprintf(self->dumper.out,", ");
}
fprintf(self->dumper.out,"\n");
#else
fprintf(self->dumper.out,"%d %g\n",k,buf[k]);
#endif
}
if(more)
{
for(i = 0; i < d->depth + 3 ; i++) fprintf(self->dumper.out," ");
fprintf(self->dumper.out,"... %d more values\n",more);
}
for(i = 0; i < d->depth ; i++) fprintf(self->dumper.out," ");
fprintf(self->dumper.out,"} # %s %s \n",a->creator->op, a->name);
grib_context_free(d->handle->context,buf);
}
static void dump_bytes(grib_dumper* d,grib_accessor* a,const char* comment)
{
grib_dumper_debug *self = (grib_dumper_debug*)d;
int i,k,err =0;
int more = 0;
size_t size = a->length;
unsigned char* buf = (unsigned char*)grib_context_malloc(d->handle->context,size);
if( a->length == 0 &&
(d->option_flags & GRIB_DUMP_FLAG_CODED) != 0)
return;
set_begin_end(d,a);
for(i = 0; i < d->depth ; i++) fprintf(self->dumper.out," ");
fprintf(self->dumper.out,"%ld-%ld %s %s = %ld",self->begin,self->theEnd,a->creator->op, a->name,a->length);
aliases(d,a);
fprintf(self->dumper.out," {");
if(!buf)
{
if(size == 0)
fprintf(self->dumper.out,"}\n");
else
fprintf(self->dumper.out," *** ERR cannot malloc(%ld) }\n",(long)size);
return;
}
fprintf(self->dumper.out,"\n");
err = grib_unpack_bytes(a,buf,&size);
if(err){
grib_context_free(d->handle->context,buf);
fprintf(self->dumper.out," *** ERR=%d (%s) [grib_dumper_debug::dump_bytes]\n}",err,grib_get_error_message(err));
return ;
}
if(size > 100) {
more = size - 100;
size = 100;
}
k = 0;
/* if(size > 100) size = 100; */
while(k < size)
{
int j;
for(i = 0; i < d->depth + 3 ; i++) fprintf(self->dumper.out," ");
for(j = 0; j < 16 && k < size; j++, k++)
{
fprintf(self->dumper.out,"%02x",buf[k]);
if(k != size-1)
fprintf(self->dumper.out,", ");
}
fprintf(self->dumper.out,"\n");
}
if(more)
{
for(i = 0; i < d->depth + 3 ; i++) fprintf(self->dumper.out," ");
fprintf(self->dumper.out,"... %d more values\n",more);
}
for(i = 0; i < d->depth ; i++) fprintf(self->dumper.out," ");
fprintf(self->dumper.out,"} # %s %s \n",a->creator->op, a->name);
grib_context_free(d->handle->context,buf);
}
static int find(grib_nearest* nearest, grib_handle* h,
double inlat, double inlon,unsigned long flags,
double* outlats,double* outlons, double *values,
double *distances,int *indexes, size_t *len) {
grib_nearest_latlon_reduced* self = (grib_nearest_latlon_reduced*) nearest;
int ret=0,kk=0,ii=0,jj=0;
int j=0;
long* pla=NULL;
long* pl=NULL;
size_t nvalues=0;
grib_iterator* iter=NULL;
double lat=0,lon=0;
long iradius;
double radius;
int ilat=0,ilon=0;
if( (ret = grib_get_size(h,self->values_key,&nvalues))!= GRIB_SUCCESS)
return ret;
nearest->values_count = nvalues;
if (grib_is_missing(h,self->radius,&ret)) {
grib_context_log(h->context, GRIB_LOG_DEBUG,"Key '%s' is missing", self->radius);
return ret ? ret : GRIB_GEOCALCULUS_PROBLEM;
}
if( (ret = grib_get_long(h,self->radius,&iradius))!= GRIB_SUCCESS)
return ret;
radius=((double)iradius)/1000.0;
if (!nearest->h || (flags & GRIB_NEAREST_SAME_GRID)==0) {
double dummy=0;
double olat=1.e10;
long n=0;
ilat=0,ilon=0;
if (grib_is_missing(h,self->Nj,&ret)) {
grib_context_log(h->context, GRIB_LOG_DEBUG,"Key '%s' is missing", self->Nj);
return ret ? ret : GRIB_GEOCALCULUS_PROBLEM;
}
if( (ret = grib_get_long(h,self->Nj,&n))!= GRIB_SUCCESS)
return ret;
self->lats_count=n;
if (self->lats) grib_context_free(nearest->context,self->lats);
self->lats=(double*)grib_context_malloc( nearest->context,
self->lats_count* sizeof(double));
if (!self->lats) return GRIB_OUT_OF_MEMORY;
if (self->lons) grib_context_free(nearest->context,self->lons);
self->lons=(double*)grib_context_malloc( nearest->context,
nearest->values_count*sizeof(double));
if (!self->lons) return GRIB_OUT_OF_MEMORY;
iter=grib_iterator_new(h,0,&ret);
if (ret) {
grib_context_log(h->context,GRIB_LOG_ERROR,"unable to create iterator");
return ret;
}
while(grib_iterator_next(iter,&lat,&lon,&dummy)) {
if (olat!=lat) {
self->lats[ilat++]=lat;
olat=lat;
}
self->lons[ilon++]=lon;
}
self->lats_count=ilat;
grib_iterator_delete(iter);
}
nearest->h=h;
if (!self->distances || (flags & GRIB_NEAREST_SAME_POINT)==0
|| (flags & GRIB_NEAREST_SAME_GRID)==0) {
double* lons=NULL;
int nlon=0;
size_t plsize=0;
long nplm1=0;
int nearest_lons_found=0;
double lon_first,lon_last;
int islocal=0;
long plmax;
double dimin;
if ((ret=grib_get_double(h,self->lonFirst,&lon_first))!=GRIB_SUCCESS) {
grib_context_log(h->context,GRIB_LOG_ERROR,
"grib_nearest_latlon_reduced.find(): unable to get %s %s\n",self->lonFirst,
grib_get_error_message(ret));
return ret;
}
if ((ret=grib_get_double(h,self->lonLast,&lon_last))!=GRIB_SUCCESS) {
grib_context_log(h->context,GRIB_LOG_ERROR,
"grib_nearest_latlon_reduced.find(): unable to get %s %s\n",self->lonLast,
grib_get_error_message(ret));
return ret;
}
plsize=self->lats_count;
if( (ret=grib_get_size(h,self->pl,&plsize))!= GRIB_SUCCESS)
return ret;
pla=(long*)grib_context_malloc(h->context,plsize*sizeof(long));
if (!pla) return GRIB_OUT_OF_MEMORY;
if( (ret=grib_get_long_array(h,self->pl,pla,&plsize))!= GRIB_SUCCESS)
return ret;
pl=pla;
while ((*pl)==0) {pl++;}
plmax=pla[0];
for (j=0;j<plsize;j++) if (plmax<pla[j]) plmax=pla[j];
dimin=360.0/plmax;
if ( 360-fabs(lon_last-lon_first) < 2 * dimin ) {islocal=0;}
else {islocal=1;}
if (islocal)
for (j=0;j<plsize;j++) pla[j]--;
/* printf("XXXX islocal=%d\n",islocal); */
while (inlon<0) inlon+=360;
while (inlon>360) inlon-=360;
ilat=self->lats_count;
if (self->lats[ilat-1] > self->lats[0]) {
if (inlat < self->lats[0] || inlat > self->lats[ilat-1])
return GRIB_OUT_OF_AREA;
} else {
if (inlat > self->lats[0] || inlat < self->lats[ilat-1])
return GRIB_OUT_OF_AREA;
}
if (!self->distances)
self->distances=(double*)grib_context_malloc( nearest->context,4*sizeof(double));
if (!self->distances) return GRIB_OUT_OF_MEMORY;
grib_binary_search(self->lats,ilat-1,inlat,
&(self->j[0]),&(self->j[1]));
nlon=0;
for (jj=0;jj<self->j[0];jj++) nlon+=pl[jj];
nplm1=pl[self->j[0]]-1;
lons=self->lons+nlon;
nearest_lons_found=0;
if (lons[nplm1]>lons[0]) {
if (inlon< lons[0] || inlon > lons[nplm1]) {
if (lons[nplm1]-lons[0]-360 <=
lons[nplm1]-lons[nplm1-1]) {
self->k[0]=0;
self->k[1]=nplm1;
nearest_lons_found=1;
} else return GRIB_OUT_OF_AREA;
}
} else {
if (inlon >lons[0] || inlon< lons[nplm1]) {
if (lons[0]-lons[nplm1]-360 <=
lons[0]-lons[1]) {
self->k[0]=0;
self->k[1]=nplm1;
nearest_lons_found=1;
} else return GRIB_OUT_OF_AREA;
}
}
if (!nearest_lons_found) {
grib_binary_search(lons,pl[self->j[0]]-1,inlon,
&(self->k[0]),&(self->k[1]));
}
self->k[0]+=nlon;
self->k[1]+=nlon;
nlon=0;
for (jj=0;jj<self->j[1];jj++) nlon+=pl[jj];
nplm1=pl[self->j[1]]-1;
lons=self->lons+nlon;
nearest_lons_found=0;
if (lons[nplm1]>lons[0]) {
if (inlon<lons[0] || inlon>lons[nplm1]) {
if (lons[nplm1]-lons[0]-360 <=
lons[nplm1]-lons[nplm1-1]) {
self->k[2]=0;
self->k[3]=nplm1;
nearest_lons_found=1;
} else return GRIB_OUT_OF_AREA;
}
} else {
if (inlon>lons[0] || inlon<lons[nplm1]) {
if (lons[0]-lons[nplm1]-360 <=
lons[0]-lons[1]) {
self->k[2]=0;
self->k[3]=nplm1;
nearest_lons_found=1;
} else return GRIB_OUT_OF_AREA;
}
}
if (!nearest_lons_found) {
grib_binary_search(lons,pl[self->j[1]]-1,inlon,
&(self->k[2]),&(self->k[3]));
}
self->k[2]+=nlon;
self->k[3]+=nlon;
kk=0;
for (jj=0;jj<2;jj++) {
for (ii=0;ii<2;ii++) {
self->distances[kk]=grib_nearest_distance(radius,inlon,inlat,
self->lons[self->k[kk]],self->lats[self->j[jj]]);
kk++;
}
}
grib_context_free(h->context,pla);
}
kk=0;
for (jj=0;jj<2;jj++) {
for (ii=0;ii<2;ii++) {
distances[kk]=self->distances[kk];
outlats[kk]=self->lats[self->j[jj]];
outlons[kk]=self->lons[self->k[kk]];
grib_get_double_element_internal(h,self->values_key,self->k[kk],&(values[kk]));
indexes[kk]=self->k[kk];
kk++;
}
}
return GRIB_SUCCESS;
}
char* grib_context_strdup(const grib_context* c,const char* s){
char *dup = (char*)grib_context_malloc(c,(strlen(s)*sizeof(char))+1);
if(dup) strcpy(dup,s);
return dup;
}
void* grib_context_malloc_clear(const grib_context* c, size_t size){
void *p = grib_context_malloc(c,size);
if(p) memset(p,0,size);
return p;
}
static int unpack_double(grib_accessor* a, double* val, size_t *len)
{
grib_accessor_data_sh_unpacked* self = (grib_accessor_data_sh_unpacked*)a;
size_t i = 0;
int ret = GRIB_SUCCESS;
long hcount = 0;
long lcount = 0;
long hpos = 0;
long lup = 0;
long mmax = 0;
long n_vals = 0;
double *scals = NULL;
/* double *pscals=NULL; */
double dummy=0;
double s = 0;
double d = 0;
double laplacianOperator = 0;
unsigned char* buf = NULL;
unsigned char* hres = NULL;
unsigned char* lres = NULL;
unsigned long packed_offset;
long lpos = 0;
long maxv = 0;
long GRIBEX_sh_bug_present =0;
long ieee_floats = 0;
long offsetdata = 0;
long bits_per_value = 0;
double reference_value = 0;
long binary_scale_factor = 0;
long decimal_scale_factor = 0;
long sub_j= 0;
long sub_k= 0;
long sub_m= 0;
long pen_j= 0;
long pen_k= 0;
long pen_m= 0;
double operat= 0;
int err=0;
decode_float_proc decode_float = NULL;
n_vals = 0;
err=grib_value_count(a,&n_vals);
if (err) return err;
if(*len < n_vals){
*len = n_vals;
return GRIB_ARRAY_TOO_SMALL;
}
if((ret = grib_get_long_internal(grib_handle_of_accessor(a),self->offsetdata,&offsetdata))
!= GRIB_SUCCESS) return ret;
if((ret = grib_get_long_internal(grib_handle_of_accessor(a),self->GRIBEX_sh_bug_present,&GRIBEX_sh_bug_present))
!= GRIB_SUCCESS)
return ret;
if((ret = grib_get_long_internal(grib_handle_of_accessor(a),self->ieee_floats,&ieee_floats)) != GRIB_SUCCESS)
return ret;
if((ret = grib_get_long_internal(grib_handle_of_accessor(a),self->sub_j,&sub_j)) != GRIB_SUCCESS)
return ret;
if((ret = grib_get_long_internal(grib_handle_of_accessor(a),self->sub_k,&sub_k)) != GRIB_SUCCESS)
return ret;
if((ret = grib_get_long_internal(grib_handle_of_accessor(a),self->sub_m,&sub_m)) != GRIB_SUCCESS)
return ret;
if((ret = grib_get_long_internal(grib_handle_of_accessor(a),self->pen_j,&pen_j)) != GRIB_SUCCESS)
return ret;
if((ret = grib_get_long_internal(grib_handle_of_accessor(a),self->pen_k,&pen_k)) != GRIB_SUCCESS)
return ret;
if((ret = grib_get_long_internal(grib_handle_of_accessor(a),self->pen_m,&pen_m)) != GRIB_SUCCESS)
return ret;
self->dirty=0;
switch (ieee_floats) {
case 0:
decode_float=grib_long_to_ibm;
break;
case 1:
decode_float=grib_long_to_ieee;
break;
case 2:
decode_float=grib_long_to_ieee64;
break;
default:
return GRIB_NOT_IMPLEMENTED;
}
Assert (sub_j == sub_k);
Assert (sub_j == sub_m);
Assert (pen_j == pen_k);
Assert (pen_j == pen_m);
buf = (unsigned char*)grib_handle_of_accessor(a)->buffer->data;
maxv = pen_j+1;
buf += offsetdata;
hres = buf;
lres = buf;
packed_offset = offsetdata + 4*(sub_k+1)*(sub_k+2);
lpos = 8*(packed_offset-offsetdata);
s = grib_power(binary_scale_factor,2);
d = grib_power(-decimal_scale_factor,10) ;
scals = (double*)grib_context_malloc(a->context,maxv*sizeof(double));
Assert(scals);
if((ret = grib_get_double_internal(grib_handle_of_accessor(a),self->laplacianOperator,&laplacianOperator))
!= GRIB_SUCCESS)
return ret;
scals[0] = 0;
for(i=1;i<maxv;i++){
operat = pow(i*(i+1),laplacianOperator);
if(operat != 0)
scals[i] = (1.0/operat);
else{
scals[i] = 0;
}
}
i=0;
while(maxv>0)
{
lup=mmax;
if(sub_k>=0)
{
for(hcount=0;hcount<sub_k+1;hcount++)
{
val[i++] = decode_float(grib_decode_unsigned_long(hres,&hpos,32))*d;
val[i++] = decode_float(grib_decode_unsigned_long(hres,&hpos,32))*d;
if (GRIBEX_sh_bug_present && hcount==sub_k){
/* bug in ecmwf data, last row (K+1)is scaled but should not */
val[i-2] *= scals[lup];
val[i-1] *= scals[lup];
}
lup++;
}
sub_k--;
}
/* pscals=scals+lup; */
for(lcount=hcount; lcount < maxv ; lcount++)
{
dummy = (double) ((grib_decode_unsigned_long(lres, &lpos,
bits_per_value)*s)+reference_value);
dummy = (double) ((grib_decode_unsigned_long(lres, &lpos,
bits_per_value)*s)+reference_value);
lup++;
}
maxv--;
hcount=0;
mmax++;
}
Assert(*len >= i);
*len = n_vals;
if(d != 1) {
for(i=0;i<*len;i++)
val[i++] *= d;
}
(void)dummy; /* suppress gcc warning */
grib_context_free(a->context,scals);
return ret;
}
