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 unpack_long(grib_accessor* a, long* val, size_t *len)
{
grib_accessor_unsigned* self = (grib_accessor_unsigned*)a;
long rlen = 0;
unsigned long i = 0;
unsigned long missing = 0;
long count=0;
int err = 0;
long pos = a->offset*8;
err=grib_value_count(a,&count);
if (err) return err;
rlen=count;
if(*len < rlen)
{
grib_context_log(a->parent->h->context, GRIB_LOG_ERROR, " wrong size (%ld) for %s it contains %d values ",*len, a->name , rlen);
*len = 0;
return GRIB_ARRAY_TOO_SMALL;
}
if (a->flags & GRIB_ACCESSOR_FLAG_TRANSIENT) {
*val=a->vvalue->lval;
*len=1;
return GRIB_SUCCESS;
}
if(a->flags & GRIB_ACCESSOR_FLAG_CAN_BE_MISSING)
{
Assert(self->nbytes <= 4);
missing = ones[self->nbytes];
}
for(i=0; i< rlen;i++){
val[i] = (long)grib_decode_unsigned_long(a->parent->h->buffer->data , &pos, self->nbytes*8);
if(missing)
if(val[i] == missing)
val[i] = GRIB_MISSING_LONG;
}
*len = rlen;
return GRIB_SUCCESS;
}
static void init(grib_accessor* a, const long len , grib_arguments* arg )
{
grib_accessor_unsigned* self = (grib_accessor_unsigned*)a;
self->arg = NULL;
self->arg = arg;
self->nbytes = len;
if (a->flags & GRIB_ACCESSOR_FLAG_TRANSIENT) {
a->length=0;
if (!a->vvalue)
a->vvalue=(grib_virtual_value*)grib_context_malloc_clear(a->parent->h->context,sizeof(grib_virtual_value));
a->vvalue->type=GRIB_TYPE_LONG;
a->vvalue->length=len;
} else {
long count=0;
grib_value_count(a,&count);
a->length = len*count;
a->vvalue=NULL;
}
}
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 unpack_double (grib_accessor* a, double* val, size_t *len)
{
long pos = a->offset*8;
long tlen;
long i;
int err=0;
err = grib_value_count(a,&tlen);
if (err) return err;
if(*len < tlen)
{
grib_context_log(a->parent->h->context, GRIB_LOG_ERROR, "Wrong size for %s it contains %d values ", a->name , tlen );
*len = 0;
return GRIB_ARRAY_TOO_SMALL;
}
for(i=0;i<tlen;i++)
{
val[i] = (double)grib_decode_unsigned_long(a->parent->h->buffer->data, &pos,1);
}
*len = tlen;
return GRIB_SUCCESS;
}
static void dump_values(grib_dumper* d,grib_accessor* a)
{
grib_dumper_c_code *self = (grib_dumper_c_code*)d;
int k,err =0;
double* buf = NULL;
int type=0;
char stype[10];
size_t size=0;
stype[0]='\0';
if((a->flags & GRIB_ACCESSOR_FLAG_READ_ONLY)
|| ((a->flags & GRIB_ACCESSOR_FLAG_DATA)
&& (d->option_flags & GRIB_DUMP_FLAG_NO_DATA) ) )
return;
size=grib_value_count(a);
if(size == 1){
dump_double(d,a,NULL);
return ;
}
type=grib_accessor_get_native_type(a);
switch (type) {
case GRIB_TYPE_LONG:
sprintf(stype,"%s","long");
break;
case GRIB_TYPE_DOUBLE:
sprintf(stype,"%s","double");
break;
default:
return;
}
buf = grib_context_malloc(d->handle->context,size * sizeof(double));
if(!buf)
{
fprintf(self->dumper.out,"/* %s: cannot malloc(%ld) */\n",a->name,(long)size);
return;
}
err = grib_unpack_double(a,buf,&size);
if(err){
grib_context_free(d->handle->context,buf);
fprintf(self->dumper.out," /* Error accessing %s (%s) */",a->name,grib_get_error_message(err));
return ;
}
fprintf(self->dumper.out," size = %ld;\n",(long)size);
fprintf(self->dumper.out," v%s = (%s*)calloc(size,sizeof(%s));\n",stype,stype,stype);
fprintf(self->dumper.out," if(!v%s) {\n",stype);
fprintf(self->dumper.out," fprintf(stderr,\"failed to allocate %%d bytes\\n\",size*sizeof(%s));\n",stype);
fprintf(self->dumper.out," exit(1);\n");
fprintf(self->dumper.out," }\n");
fprintf(self->dumper.out,"\n ");
k = 0;
while(k < size)
{
fprintf(self->dumper.out," v%s[%4d] = %7g;",stype,k,buf[k]);
k++;
if(k%4 == 0) fprintf(self->dumper.out,"\n ");
}
if(size%4) fprintf(self->dumper.out,"\n");
fprintf(self->dumper.out,"\n");
fprintf(self->dumper.out," GRIB_CHECK(grib_set_%s_array(h,\"%s\",v%s,size),%d);\n",stype,a->name,stype,0);
fprintf(self->dumper.out," free(v%s);\n",stype);
grib_context_free(d->handle->context,buf);
}
static int unpack_double(grib_accessor* a, double* val, size_t *len)
{
grib_accessor_data_apply_gdsnotpresent* self = (grib_accessor_data_apply_gdsnotpresent*)a;
long number_of_points=0,number_of_values=0,ni=0;
long latitude_of_first_point=0;
size_t i = 0;
size_t n_vals = 0;
long nn=0;
int err=0;
size_t size=0;
long missing_value;
double* coded_vals = NULL;
err=grib_value_count(a,&nn);
n_vals=nn;
if (err) return err;
if((err = grib_get_long(a->parent->h,self->number_of_points,&number_of_points))
!= GRIB_SUCCESS) return err;
if((err = grib_get_long(a->parent->h,self->number_of_values,&number_of_values))
!= GRIB_SUCCESS) return err;
if((err = grib_get_long(a->parent->h,self->latitude_of_first_point,&latitude_of_first_point))
!= GRIB_SUCCESS) return err;
if((err = grib_get_long(a->parent->h,self->missing_value,&missing_value))
!= GRIB_SUCCESS) return err;
if((err = grib_get_long(a->parent->h,self->ni,&ni))
!= GRIB_SUCCESS) return err;
if(*len < number_of_points)
{
*len = n_vals;
return GRIB_ARRAY_TOO_SMALL;
}
if(number_of_values > 0){
coded_vals = (double*)grib_context_malloc(a->parent->h->context,number_of_values*sizeof(double));
if(coded_vals == NULL)
return GRIB_OUT_OF_MEMORY;
}
size=number_of_values;
if((err=grib_get_double_array_internal(a->parent->h,self->coded_values,coded_vals,&size))
!= GRIB_SUCCESS) {
grib_context_free(a->parent->h->context,coded_vals);
return err;
}
if (number_of_values!=size) {
grib_context_log(a->parent->h->context, GRIB_LOG_ERROR,
"grib_accessor_data_apply_gdsnotpresent : wrong numberOfValues %ld != %ld",
number_of_values,size);
}
grib_context_log(a->parent->h->context, GRIB_LOG_DEBUG,
"grib_accessor_data_apply_gdsnotpresent : unpack_double : creating %s, %d values",
a->name, number_of_points);
if (latitude_of_first_point == 0) {
for (i=0;i < number_of_values;i++) val[i]=coded_vals[i];
for (i=number_of_values;i<number_of_points;i++)
val[i]=coded_vals[number_of_values-1];
} else {
for(i=0;i<ni-1;i++) val[i]=coded_vals[0];
for(i=ni-1;i<number_of_points;i++) val[i]=coded_vals[i-ni+1];
}
*len = number_of_points;
grib_context_free(a->parent->h->context,coded_vals);
return err;
}
static int unpack_double(grib_accessor* a, double* val, size_t *len)
{
grib_accessor_data_apply_boustrophedonic_bitmap* self = (grib_accessor_data_apply_boustrophedonic_bitmap*)a;
size_t i = 0, j = 0, n_vals = 0, irow = 0;
long nn=0;
int err=0;
size_t coded_n_vals = 0;
double* coded_vals = NULL;
double missing_value = 0;
long numberOfPoints, numberOfRows, numberOfColumns;
err=grib_value_count(a,&nn);
n_vals=nn;
if (err) return err;
err=grib_get_long_internal(a->parent->h,self->numberOfRows,&numberOfRows);
if (err) return err;
err=grib_get_long_internal(a->parent->h,self->numberOfColumns,&numberOfColumns);
if (err) return err;
err=grib_get_long_internal(a->parent->h,self->numberOfPoints,&numberOfPoints);
if (err) return err;
Assert(nn == numberOfPoints);
if(!grib_find_accessor(a->parent->h,self->bitmap))
return grib_get_double_array_internal(a->parent->h,self->coded_values,val,len);
if((err = grib_get_size(a->parent->h,self->coded_values,&coded_n_vals)) != GRIB_SUCCESS)
return err;
if((err = grib_get_double_internal(a->parent->h,self->missing_value,&missing_value))
!= GRIB_SUCCESS) return err;
if(*len < n_vals) {
*len = n_vals;
return GRIB_ARRAY_TOO_SMALL;
}
if (coded_n_vals==0) {
for(i=0;i < n_vals;i++)
val[i] = missing_value;
*len=n_vals;
return GRIB_SUCCESS;
}
if((err = grib_get_double_array_internal(a->parent->h,self->bitmap,val,&n_vals))
!= GRIB_SUCCESS)
return err;
coded_vals = (double*)grib_context_malloc(a->parent->h->context,coded_n_vals*sizeof(double));
if(coded_vals == NULL) return GRIB_OUT_OF_MEMORY;
if((err = grib_get_double_array_internal(a->parent->h,self->coded_values,coded_vals,&coded_n_vals))
!= GRIB_SUCCESS)
{
grib_context_free(a->parent->h->context,coded_vals);
return err;
}
grib_context_log(a->parent->h->context, GRIB_LOG_DEBUG,
"grib_accessor_class_data_apply_boustrophedonic_bitmap: unpack_double : creating %s, %d values",
a->name, n_vals);
/* Boustrophedonic ordering (See GRIB-472):
* Values on even rank lines (the initial line scanned having rank 1) are swapped
*/
for(irow=0; irow<numberOfRows; ++irow)
{
if (irow%2)
{
/* Reverse bitmap entries */
size_t k = 0;
size_t start = irow*numberOfColumns;
size_t end = start + numberOfColumns - 1;
size_t mid = (numberOfColumns - 1)/2;
for(k=0; k<mid; ++k)
{
/* Swap value at either end */
double temp = val[start+k];
val[start+k] = val[end-k];
val[end-k] = temp;
}
}
}
for(i=0;i < n_vals;i++)
{
if(val[i] == 0 ){
val[i] = missing_value;
}
else
{
val[i] = coded_vals[j++];
if(j>coded_n_vals)
{
grib_context_free(a->parent->h->context,coded_vals);
grib_context_log(a->parent->h->context, GRIB_LOG_ERROR,
"grib_accessor_class_data_apply_boustrophedonic_bitmap [%s]:"
" unpack_double : number of coded values does not match bitmap %ld %ld",
a->name,coded_n_vals,n_vals);
return GRIB_ARRAY_TOO_SMALL;
}
}
}
*len = n_vals;
grib_context_free(a->parent->h->context,coded_vals);
return err;
}
static void dump_long(grib_dumper* d,grib_accessor* a,const char* comment)
{
grib_dumper_wmo *self = (grib_dumper_wmo*)d;
long value = 0; size_t size =0;
long *values=NULL;
int err = 0;
int i=0;
long count=0;
grib_value_count(a,&count);
size=count;
if (size>1) {
values=(long*)grib_context_malloc_clear(a->parent->h->context,sizeof(long)*size);
err=grib_unpack_long(a,values,&size);
} else {
err=grib_unpack_long(a,&value,&size);
}
if( a->length == 0 &&
(d->option_flags & GRIB_DUMP_FLAG_CODED) != 0)
return;
if( (a->flags & GRIB_ACCESSOR_FLAG_READ_ONLY) != 0 &&
(d->option_flags & GRIB_DUMP_FLAG_READ_ONLY) == 0)
return;
set_begin_end(d,a);
print_offset(self->dumper.out,self->begin,self->theEnd);
if ((d->option_flags & GRIB_DUMP_FLAG_TYPE) != 0)
fprintf(self->dumper.out,"%s ",a->creator->op);
if (size>1) {
int cols=19;
int count=0;
fprintf(self->dumper.out,"%s = { \t",a->name);
for (i=0;i<size;i++) {
if (count>cols) {fprintf(self->dumper.out,"\n\t\t\t\t");count=0;}
fprintf(self->dumper.out,"%ld ",values[i]);
count++;
}
fprintf(self->dumper.out,"}\n");
grib_context_free(a->parent->h->context,values);
} else {
if( ((a->flags & GRIB_ACCESSOR_FLAG_CAN_BE_MISSING) != 0) && grib_is_missing_internal(a) )
fprintf(self->dumper.out,"%s = MISSING",a->name);
else
fprintf(self->dumper.out,"%s = %ld",a->name,value);
print_hexadecimal(self->dumper.out,d->option_flags,a);
if(comment) fprintf(self->dumper.out," [%s]",comment);
}
if(err)
fprintf(self->dumper.out," *** ERR=%d (%s) [grib_dumper_wmo::dump_long]",err,grib_get_error_message(err));
aliases(d,a);
fprintf(self->dumper.out,"\n");
}
static int unpack_double(grib_accessor* a, double* val, size_t *len)
{
grib_accessor_data_2order_packing* self = (grib_accessor_data_2order_packing*)a;
size_t i = 0;
size_t j = 0;
size_t n_vals = 0;
int err=0;
long vcount = 0, bias = 0;
double reference_value;
long binary_scale_factor;
long bits_per_value, decimal_scale_factor;
long n1 = 0, n2 = 0, extraValues = 0, p1 = 0, p2 = 0;
long offsetsection = 0, snd_bitmap = 0, snd_ordr_wdiff = 0;
long matrix_values =0;
long general_ext =0;
long boustrophedonic =0;
long two_ordr_spd =0;
long plus1_spd =0;
long nbits_per_width =0;
long nbits_per_group_size =0;
long octet_start_group =0;
long width_spd_sp_desc =0;
grib_handle* gh = grib_handle_of_accessor(a);
unsigned char* buf_size_of_groups = (unsigned char*)gh->buffer->data;
unsigned char* buf_width_of_group = (unsigned char*)gh->buffer->data;
unsigned char* bufrefs = (unsigned char*)gh->buffer->data;
unsigned char* bufvals = (unsigned char*)gh->buffer->data;
double s = 0;
double d = 0;
double max = 0;
double min = 0;
unsigned long* sec_val = NULL;
long ref_vals = 0;
short n_sp_diff = 0;
short f_size_of_group = 0;
short f_width_of_group = 0;
long bitp = 0;
long pointer_of_group_size = 0;
long pointer_of_group_width = 0;
long refsp = 0;
long nap = 0;
long nn=0;
unsigned char* bitmap=NULL;
grib_accessor* abitmap=NULL;
size_t bitmap_len=0;
err=grib_value_count(a,&nn);
n_vals=nn;
if((err = grib_get_long_internal(gh,self->offsetsection,&offsetsection))
!= GRIB_SUCCESS) return err;
if((err = grib_get_long_internal(gh,self->bits_per_value,&bits_per_value))
!= GRIB_SUCCESS) return err;
if((err = grib_get_double_internal(gh,self->reference_value, &reference_value))
!= GRIB_SUCCESS)return err;
if((err = grib_get_long_internal(gh,self->binary_scale_factor, &binary_scale_factor))
!= GRIB_SUCCESS) return err;
if((err = grib_get_long_internal(gh,self->decimal_scale_factor, &decimal_scale_factor))
!= GRIB_SUCCESS) return err;
if((err = grib_get_long_internal(gh,self->n1,&n1)) != GRIB_SUCCESS) return err;
if((err = grib_get_long_internal(gh,self->n2, &n2)) != GRIB_SUCCESS) return err;
if((err = grib_get_long_internal(gh,self->p1, &p1)) != GRIB_SUCCESS) return err;
if((err = grib_get_long_internal(gh,self->extraValues, &extraValues)) != GRIB_SUCCESS) return err;
p1=p1+65536*extraValues;
if((err = grib_get_long_internal(gh,self->p2, &p2)) != GRIB_SUCCESS) return err;
if((err = grib_get_long_internal(gh,self->matrix_values, &matrix_values))
!= GRIB_SUCCESS)return err;
if((err = grib_get_long_internal(gh,self->snd_bitmap, &snd_bitmap))
!= GRIB_SUCCESS) return err;
if((err = grib_get_long_internal(gh,self->snd_ordr_wdiff, &snd_ordr_wdiff))
!= GRIB_SUCCESS) return err;
if((err = grib_get_long_internal(gh,self->general_ext, &general_ext))
!= GRIB_SUCCESS) return err;
if((err = grib_get_long_internal(gh,self->boustrophedonic, &boustrophedonic))
!= GRIB_SUCCESS) return err;
if((err = grib_get_long_internal(gh,self->two_ordr_spd, &two_ordr_spd))
!= GRIB_SUCCESS) return err;
if((err = grib_get_long_internal(gh,self->plus1_spd, &plus1_spd))
!= GRIB_SUCCESS) return err;
if((err = grib_get_long_internal(gh,self->width_widths, &nbits_per_width))
!= GRIB_SUCCESS) return err;
if((err = grib_get_long_internal(gh,self->width_lengths, &nbits_per_group_size))
!= GRIB_SUCCESS) return err;
if((err = grib_get_long_internal(gh,self->octet_start_group, &octet_start_group))
!= GRIB_SUCCESS) return err;
if((err = grib_get_long_internal(gh,self->width_spd_sp_desc, &width_spd_sp_desc))
!= GRIB_SUCCESS) width_spd_sp_desc=-1;
if((err = grib_get_long_internal(gh,self->nap, &nap)) != GRIB_SUCCESS) return err;
self->dirty=0;
n_sp_diff = two_ordr_spd*2+plus1_spd;
Assert(bits_per_value < (sizeof(unsigned long)*8)-1);
if ((abitmap=grib_find_accessor(gh,self->bitmap))!=NULL) {
bitmap_len=grib_byte_count(abitmap);
bitmap=(unsigned char*)grib_context_malloc_clear(a->context,sizeof(char)*bitmap_len);
err=grib_unpack_bytes(abitmap,bitmap,&bitmap_len);
if (err) {grib_context_free(a->context,bitmap); return err;}
}
if(bits_per_value == 0)
return GRIB_NOT_IMPLEMENTED;
/* I have everything now start decoding */
/*
fprintf(stdout,"\n****************************************\n");
fprintf(stdout," bits_per_value = %ld\n", bits_per_value);
fprintf(stdout," reference_value = %g\n", reference_value);
fprintf(stdout," binary_scale_factor = %ld\n", binary_scale_factor);
fprintf(stdout," decimal_scale_factor = %ld\n", decimal_scale_factor);
fprintf(stdout," n1 = %ld\n", n1);
fprintf(stdout," n2 = %ld\n", n2);
fprintf(stdout," p1 = %ld\n", p1);
fprintf(stdout," p2 = %ld\n", p2);
fprintf(stdout," matrix_values = %ld\n", matrix_values);
fprintf(stdout," snd_bitmap = %ld\n", snd_bitmap);
fprintf(stdout," snd_ordr_wdiff = %ld\n", snd_ordr_wdiff);
fprintf(stdout," general_ext = %ld\n", general_ext);
fprintf(stdout," boustrophedonic = %ld\n", boustrophedonic);
fprintf(stdout," two_ordr_spd = %ld \n", two_ordr_spd);
fprintf(stdout," plus1_spd = %ld\n", plus1_spd);
fprintf(stdout," n_sp_diff = %d\n", n_sp_diff);
fprintf(stdout," width_widths = %ld\n", nbits_per_group_size);
fprintf(stdout," width_lengths = %ld\n", nbits_per_width);
fprintf(stdout," octet_start_group = %ld\n", octet_start_group);
fprintf(stdout," width_spd_sp_desc = %ld\n", width_spd_sp_desc);
fprintf(stdout," offsetsection = %ld\n", offsetsection);
fprintf(stdout," offset w = %ld\n", octet_start_group + offsetsection);
fprintf(stdout,"\n****************************************\n");
*/
if(snd_bitmap || matrix_values)
return GRIB_NOT_IMPLEMENTED;
sec_val = (unsigned long*)grib_context_malloc(a->context,(n_vals)*sizeof(unsigned long));
buf_width_of_group += a->offset;
buf_size_of_groups += offsetsection+(octet_start_group-1); /* -1 because of documented starting at 1(and not 0)*/
bufrefs += offsetsection+n1-1; /* -1 because of documented starting at 1(and not 0)*/
pointer_of_group_size = 0;
pointer_of_group_width = 0;
refsp = 0;
for(i=0;i < n_sp_diff;i++)
sec_val[i] = grib_decode_unsigned_long(buf_width_of_group, &pointer_of_group_width, width_spd_sp_desc);
bias = grib_decode_signed_longb(buf_width_of_group, &pointer_of_group_width, width_spd_sp_desc);
bufvals += offsetsection+n2-1;
bitp = 0;
vcount = n_sp_diff;
if(pointer_of_group_width%8)
pointer_of_group_width = 8+(pointer_of_group_width-(pointer_of_group_width%8));
#if KEEP_OLD == 1
if(sd == NULL){
sd = grib_context_malloc_clear(a->context,sizeof(second_order_packed));
sd->packed_byte_count = 0;
sd->nbits_per_group_size = nbits_per_group_size;
sd->nbits_per_widths = nbits_per_width;
sd->size_of_group_array = p1;
sd->array_of_group_size = grib_context_malloc_clear(a->context,sizeof(unsigned long)*sd->size_of_group_array);
sd->array_of_group_width = grib_context_malloc_clear(a->context,sizeof(unsigned long)*sd->size_of_group_array);
sd->array_of_group_refs = grib_context_malloc_clear(a->context,sizeof( long)*sd->size_of_group_array);
}
#endif
for(i=0;i < p1;i++){
f_width_of_group = (short) grib_decode_unsigned_long(buf_width_of_group, &pointer_of_group_width, nbits_per_width);
f_size_of_group = (short) grib_decode_unsigned_long(buf_size_of_groups, &pointer_of_group_size, nbits_per_group_size);
ref_vals = grib_decode_unsigned_long(bufrefs, &refsp, bits_per_value);
#if KEEP_OLD == 1
if(sd->packed_byte_count == 0){
sd->array_of_group_width[i] = f_width_of_group;
sd->array_of_group_size[i] = f_size_of_group;
sd->array_of_group_refs[i] = ref_vals;
}
#endif
for(j=0; j < f_size_of_group;j++){
sec_val[vcount+j] = ref_vals + grib_decode_unsigned_long(bufvals, &bitp, f_width_of_group);
}
vcount += f_size_of_group;
}
#if KEEP_OLD == 1
if(sd->packed_byte_count == 0) sd->packed_byte_count = (bitp+7)/8;
#endif
Assert (n_vals == vcount);
/*for(i=0;i < 10;i++)
printf("readvalue [%d] %ld %ld bias %ld <<\n", i,sec_val[i],binary_scale_factor,bias );*/
if(snd_ordr_wdiff)
de_spatial_difference(a->context,sec_val, n_vals, n_sp_diff, bias);
if(boustrophedonic)
reverse_rows(sec_val,n_vals,nap,bitmap,bitmap_len);
s = grib_power(binary_scale_factor,2);
d = grib_power(-decimal_scale_factor,10) ;
for(i=0;i < n_vals;i++)
val[i] = (double) ((((double)sec_val[i])*s)+reference_value)*d;
max = val[0];
min = max;
for(i=0;i< n_vals;i++)
{
if ( val[i] > max )
max = val[i];
else if ( val[i] < min )
min = val[i];
}
min *= d;
max *= d;
grib_context_free(a->context,sec_val);
if (bitmap!=NULL) grib_context_free(a->context,bitmap);
return err;
}
static void dump_long(grib_dumper* d,grib_accessor* a,const char* comment)
{
grib_dumper_default *self = (grib_dumper_default*)d;
long value; size_t size = 1;
long *values=NULL;
int err = 0;
int i;
long count=0;
grib_value_count(a,&count);
size=count;
if ( (a->flags & GRIB_ACCESSOR_FLAG_DUMP) == 0)
return;
print_offset(self->dumper.out,d,a);
if ((d->option_flags & GRIB_DUMP_FLAG_TYPE) != 0){
fprintf(self->dumper.out," ");
fprintf(self->dumper.out,"# type %s \n",a->creator->op);
}
if (size>1) {
values=(long *)grib_context_malloc_clear(a->parent->h->context,sizeof(long)*size);
err=grib_unpack_long(a,values,&size);
} else {
err=grib_unpack_long(a,&value,&size);
}
aliases(d,a);
if(comment) {
fprintf(self->dumper.out," ");
fprintf(self->dumper.out,"# %s \n",comment);
}
if (a->flags & GRIB_ACCESSOR_FLAG_READ_ONLY) {
fprintf(self->dumper.out," ");
fprintf(self->dumper.out,"#-READ ONLY- ");
} else
fprintf(self->dumper.out," ");
if (size>1) {
int cols=19;
int count=0;
fprintf(self->dumper.out,"%s = { \t",a->name);
for (i=0;i<size;i++) {
if (count>cols) {fprintf(self->dumper.out,"\n\t\t\t\t");count=0;}
fprintf(self->dumper.out,"%ld ",values[i]);
count++;
}
fprintf(self->dumper.out,"}\n");
grib_context_free(a->parent->h->context,values);
} else {
if( ((a->flags & GRIB_ACCESSOR_FLAG_CAN_BE_MISSING) != 0) && grib_is_missing_internal(a) )
fprintf(self->dumper.out,"%s = MISSING;",a->name);
else
fprintf(self->dumper.out,"%s = %ld;",a->name,value);
}
if(err) {
fprintf(self->dumper.out," ");
fprintf(self->dumper.out,"# *** ERR=%d (%s) [grib_dumper_default::dump_long]",err,grib_get_error_message(err));
}
fprintf(self->dumper.out,"\n");
}
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 int unpack_double(grib_accessor* a, double* val, size_t *len)
{
grib_accessor_data_secondary_bitmap* self = (grib_accessor_data_secondary_bitmap*)a;
size_t i = 0;
size_t j = 0;
size_t k = 0;
size_t m = 0;
size_t n_vals = 0;
long nn=0;
long expand_by =0;
int err = 0;
size_t primary_len;
size_t secondary_len;
double* primary_vals;
double* secondary_vals;
err=grib_value_count(a,&nn);
n_vals=nn;
if (err) return err;
if(*len < n_vals)
{
*len = n_vals;
return GRIB_ARRAY_TOO_SMALL;
}
if((err = grib_get_long(grib_handle_of_accessor(a),self->expand_by,&expand_by)) != GRIB_SUCCESS)
return err;
if((err = grib_get_size(grib_handle_of_accessor(a),self->primary_bitmap,&primary_len)) != GRIB_SUCCESS)
return err;
if((err = grib_get_size(grib_handle_of_accessor(a),self->secondary_bitmap,&secondary_len)) != GRIB_SUCCESS)
return err;
primary_vals = (double*)grib_context_malloc(a->context,primary_len*sizeof(double));
if(!primary_vals)
return GRIB_OUT_OF_MEMORY;
secondary_vals = (double*)grib_context_malloc(a->context,secondary_len*sizeof(double));
if(!secondary_vals)
{
grib_context_free(a->context,primary_vals);
return GRIB_OUT_OF_MEMORY;
}
if((err = grib_get_double_array_internal(grib_handle_of_accessor(a),self->primary_bitmap,primary_vals,&primary_len)) != GRIB_SUCCESS)
{
grib_context_free(a->context,secondary_vals);
grib_context_free(a->context,primary_vals);
return err;
}
if((err = grib_get_double_array_internal(grib_handle_of_accessor(a),self->secondary_bitmap,secondary_vals,&secondary_len)) != GRIB_SUCCESS)
{
grib_context_free(a->context,secondary_vals);
grib_context_free(a->context,primary_vals);
return err;
}
k = 0;
m = 0;
for(i=0;i < primary_len;i++)
{
/* if(primary_vals[i]) f++; */
if(primary_vals[i])
{
for(j = 0; j < expand_by; j++)
val[k++] = secondary_vals[m++];
}
else {
for(j = 0; j < expand_by; j++)
val[k++] = 0;
}
}
Assert(k <= *len);
Assert(m <= secondary_len);
/*printf("FOOBAR %d %d %ld %d\n",f,primary_len,expand_by,n_vals);*/
*len = n_vals;
grib_context_free(a->context,primary_vals);
grib_context_free(a->context,secondary_vals);
return err;
}
static int unpack_double(grib_accessor* a, double* val, size_t *len)
{
grib_accessor_data_jpeg2000_packing *self =(grib_accessor_data_jpeg2000_packing*)a;
int err = GRIB_SUCCESS;
int i;
size_t buflen = grib_byte_count(a);
double bscale = 0;
double dscale = 0;
unsigned char* buf = NULL;
size_t n_vals = 0;
long nn=0;
long binary_scale_factor = 0;
long decimal_scale_factor = 0;
double reference_value = 0;
long bits_per_value =0;
double units_factor=1.0;
double units_bias=0.0;
n_vals = 0;
err=grib_value_count(a,&nn);
n_vals=nn;
if (err) return err;
if(self->units_factor)
grib_get_double_internal(a->parent->h,self->units_factor,&units_factor);
if(self->units_bias)
grib_get_double_internal(a->parent->h,self->units_bias,&units_bias);
if((err = grib_get_long_internal(a->parent->h,self->bits_per_value,&bits_per_value)) != GRIB_SUCCESS)
return err;
if((err = grib_get_double_internal(a->parent->h,self->reference_value, &reference_value)) != GRIB_SUCCESS)
return err;
if((err = grib_get_long_internal(a->parent->h,self->binary_scale_factor, &binary_scale_factor)) != GRIB_SUCCESS)
return err;
if((err = grib_get_long_internal(a->parent->h,self->decimal_scale_factor, &decimal_scale_factor)) != GRIB_SUCCESS)
return err;
self->dirty=0;
bscale = grib_power(binary_scale_factor,2);
dscale = grib_power(-decimal_scale_factor,10);
/* TODO: This should be called upstream */
if(*len < n_vals)
return GRIB_ARRAY_TOO_SMALL;
/* Special case */
if(bits_per_value == 0)
{
for(i = 0; i < n_vals; i++)
val[i] = reference_value;
*len = n_vals;
return GRIB_SUCCESS;
}
buf = (unsigned char*)a->parent->h->buffer->data;
buf += grib_byte_offset(a);
switch (self->jpeg_lib) {
case OPENJPEG_LIB:
if ((err = grib_openjpeg_decode(a->parent->h->context,buf,&buflen,val,&n_vals)) != GRIB_SUCCESS)
return err;
break;
case JASPER_LIB:
if ((err = grib_jasper_decode(a->parent->h->context,buf,&buflen,val,&n_vals)) != GRIB_SUCCESS)
return err;
break;
}
*len = n_vals;
for (i = 0; i < n_vals; i++) {
val[i] = (val[i] * bscale + reference_value) * dscale;
}
if (units_factor != 1.0) {
if (units_bias != 0.0)
for (i=0;i<n_vals;i++) val[i]=val[i]*units_factor+units_bias;
else
for (i=0;i<n_vals;i++) val[i]*=units_factor;
} else if (units_bias != 0.0)
for (i=0;i<n_vals;i++) val[i]+=units_bias;
return err;
}
static int unpack_double(grib_accessor* a, double* val, size_t *len)
{
grib_accessor_data_complex_packing* self = (grib_accessor_data_complex_packing*)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,*pval=NULL;
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 bytes;
int err=0;
decode_float_proc decode_float = NULL;
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(a->parent->h,self->offsetdata,&offsetdata))
!= GRIB_SUCCESS) return ret;
if((ret = grib_get_long_internal(a->parent->h,self->bits_per_value,&bits_per_value))
!= GRIB_SUCCESS) return ret;
if((ret = grib_get_double_internal(a->parent->h,self->reference_value,&reference_value))
!= GRIB_SUCCESS) return ret;
if((ret = grib_get_long_internal(a->parent->h,self->binary_scale_factor,&binary_scale_factor))
!= GRIB_SUCCESS) return ret;
if((ret = grib_get_long_internal(a->parent->h,self->decimal_scale_factor,&decimal_scale_factor))
!= GRIB_SUCCESS)
return ret;
if((ret = grib_get_long_internal(a->parent->h,self->GRIBEX_sh_bug_present,&GRIBEX_sh_bug_present))
!= GRIB_SUCCESS)
return ret;
if((ret = grib_get_long_internal(a->parent->h,self->ieee_floats,&ieee_floats)) != GRIB_SUCCESS)
return ret;
if((ret = grib_get_double_internal(a->parent->h,self->laplacianOperator,&laplacianOperator))
!= GRIB_SUCCESS)
return ret;
if((ret = grib_get_long_internal(a->parent->h,self->sub_j,&sub_j)) != GRIB_SUCCESS)
return ret;
if((ret = grib_get_long_internal(a->parent->h,self->sub_k,&sub_k)) != GRIB_SUCCESS)
return ret;
if((ret = grib_get_long_internal(a->parent->h,self->sub_m,&sub_m)) != GRIB_SUCCESS)
return ret;
if((ret = grib_get_long_internal(a->parent->h,self->pen_j,&pen_j)) != GRIB_SUCCESS)
return ret;
if((ret = grib_get_long_internal(a->parent->h,self->pen_k,&pen_k)) != GRIB_SUCCESS)
return ret;
if((ret = grib_get_long_internal(a->parent->h,self->pen_m,&pen_m)) != GRIB_SUCCESS)
return ret;
self->dirty=0;
switch (ieee_floats) {
case 0:
decode_float=grib_long_to_ibm;
bytes=4;
break;
case 1:
decode_float=grib_long_to_ieee;
bytes=4;
break;
case 2:
decode_float=grib_long_to_ieee64;
bytes=8;
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*)a->parent->h->buffer->data;
maxv = pen_j+1;
buf += grib_byte_offset(a);
hres = buf;
lres = buf;
if (pen_j == sub_j) {
n_vals = (pen_j+1)*(pen_j+2);
d = grib_power(-decimal_scale_factor,10) ;
grib_ieee_decode_array(a->parent->h->context,buf,n_vals,bytes,val);
if (d) {
for (i=0;i<n_vals;i++) val[i]*=d;
}
return 0;
}
packed_offset = grib_byte_offset(a) + 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->parent->h->context,maxv*sizeof(double));
Assert(scals);
scals[0] = 0;
for(i=1;i<maxv;i++){
operat = pow(i*(i+1),laplacianOperator);
if(operat != 0)
scals[i] = (1.0/operat);
else{
grib_context_log(a->parent->h->context,GRIB_LOG_WARNING,
"COMPLEX_PACKING : problem with operator div by zero at index %d of %d \n",
i , maxv);
scals[i] = 0;
}
}
/*
printf("UNPACKING LAPLACE=%.20f\n",laplacianOperator);
printf("packed offset=%ld\n",packed_offset);
for(i=0;i<maxv;i++)
printf("scals[%d]=%g\n",i,scals[i]);*/
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;
pval=val+i;
#if FAST_BIG_ENDIAN
grib_decode_double_array_complex(lres,
&lpos,bits_per_value,
reference_value,s,pscals,(maxv-hcount)*2,pval);
i+=(maxv-hcount)*2;
#else
(void)pscals; /* suppress gcc warning */
(void)pval; /* suppress gcc warning */
for(lcount=hcount; lcount < maxv ; lcount++)
{
val[i++] = (double) ((grib_decode_unsigned_long(lres, &lpos,
bits_per_value)*s)+reference_value)*scals[lup];
val[i++] = (double) ((grib_decode_unsigned_long(lres, &lpos,
bits_per_value)*s)+reference_value)*scals[lup];
lup++;
}
#endif
maxv--;
hcount=0;
mmax++;
}
Assert(*len >= i);
*len = i;
if(d != 1) {
for(i=0;i<*len;i++)
val[i++] *= d;
}
grib_context_free(a->parent->h->context,scals);
return ret;
}
static int unpack_double(grib_accessor* a, double* val, size_t *len)
{
grib_accessor_data_apply_bitmap* self = (grib_accessor_data_apply_bitmap*)a;
size_t i = 0;
size_t j = 0;
size_t n_vals = 0;
long nn=0;
int err=0;
size_t coded_n_vals = 0;
double* coded_vals = NULL;
double missing_value = 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_array_internal(a->parent->h,self->coded_values,val,len);
if((err = grib_get_size(a->parent->h,self->coded_values,&coded_n_vals)) != GRIB_SUCCESS)
return err;
if((err = grib_get_double_internal(a->parent->h,self->missing_value,&missing_value))
!= GRIB_SUCCESS) return err;
if(*len < n_vals) {
*len = n_vals;
return GRIB_ARRAY_TOO_SMALL;
}
if (coded_n_vals==0) {
for(i=0;i < n_vals;i++)
val[i] = missing_value;
*len=n_vals;
return GRIB_SUCCESS;
}
if((err = grib_get_double_array_internal(a->parent->h,self->bitmap,val,&n_vals))
!= GRIB_SUCCESS)
return err;
coded_vals = (double*)grib_context_malloc(a->parent->h->context,coded_n_vals*sizeof(double));
if(coded_vals == NULL) return GRIB_OUT_OF_MEMORY;
if((err = grib_get_double_array_internal(a->parent->h,self->coded_values,coded_vals,&coded_n_vals))
!= GRIB_SUCCESS)
{
grib_context_free(a->parent->h->context,coded_vals);
return err;
}
grib_context_log(a->parent->h->context, GRIB_LOG_DEBUG,
"grib_accessor_class_data_apply_bitmap: unpack_double : creating %s, %d values",
a->name, n_vals);
for(i=0;i < n_vals;i++)
{
if(val[i] == 0 ){
val[i] = missing_value;
}
else
{
val[i] = coded_vals[j++];
if(j>coded_n_vals)
{
grib_context_free(a->parent->h->context,coded_vals);
grib_context_log(a->parent->h->context, GRIB_LOG_ERROR,
"grib_accessor_class_data_apply_bitmap [%s]:"
" unpack_double : number of coded values does not match bitmap %ld %ld",
a->name,coded_n_vals,n_vals);
return GRIB_ARRAY_TOO_SMALL;
}
}
}
*len = n_vals;
grib_context_free(a->parent->h->context,coded_vals);
return err;
}
static int pack_long(grib_accessor* a, const long* val, size_t *len)
{
grib_accessor_signed* self = (grib_accessor_signed*)a;
int ret = 0;
long off = 0;
unsigned long rlen = 0;
int err=0;
long count=0;
size_t buflen = 0;
unsigned char *buf = NULL;
unsigned long i = 0;
long missing = 0;
err=grib_value_count(a,&count);
if (err) return err;
rlen=count;
if(*len < 1)
{
grib_context_log(a->parent->h->context, GRIB_LOG_ERROR, "Wrong size for %s it contains %d values ", a->name , 1 );
len[0] = 0;
return GRIB_ARRAY_TOO_SMALL;
}
if(a->flags & GRIB_ACCESSOR_FLAG_CAN_BE_MISSING)
{
Assert(self->nbytes <= 4);
missing = ones[self->nbytes];
}
if (rlen == 1){
long v = val[0];
if(missing)
if(v == GRIB_MISSING_LONG)
v = missing;
off = a->offset;
ret = grib_encode_signed_long(a->parent->h->buffer->data, v , off, a->length);
if (ret == GRIB_SUCCESS) len[0] = 1;
if (*len > 1) grib_context_log(a->parent->h->context, GRIB_LOG_WARNING, "grib_accessor_signed : Trying to pack %d values in a scalar %s, packing first value", *len, a->name );
len[0] = 1;
return ret;
}
/* TODO: We assume that there are no missing values if there are more that 1 value */
buflen = *len*a->length;
buf = (unsigned char*)grib_context_malloc(a->parent->h->context,buflen);
for(i=0; i < *len;i++){
grib_encode_signed_long(buf, val[i] , off, a->length);
off+= a->length;
}
ret = grib_set_long_internal(a->parent->h,grib_arguments_get_name(a->parent->h,self->arg,0),*len);
if(ret == GRIB_SUCCESS)
grib_buffer_replace(a, buf, buflen,1,1);
else
*len = 0;
grib_context_free(a->parent->h->context,buf);
return ret;
}
static void dump_values(grib_dumper* d,grib_accessor* a)
{
grib_dumper_default *self = (grib_dumper_default*)d;
int k,err =0;
int more = 0;
double* buf = NULL;
size_t size=0;
long count=0;
if ( (a->flags & GRIB_ACCESSOR_FLAG_DUMP) == 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));
print_offset(self->dumper.out,d,a);
if ((d->option_flags & GRIB_DUMP_FLAG_TYPE) != 0) {
fprintf(self->dumper.out," ");
fprintf(self->dumper.out,"# type %s \n",a->creator->op);
}
aliases(d,a);
if (a->flags & GRIB_ACCESSOR_FLAG_READ_ONLY) {
fprintf(self->dumper.out," ");
fprintf(self->dumper.out,"#-READ ONLY- ");
} else
fprintf(self->dumper.out," ");
fprintf(self->dumper.out,"%s(%ld) = ",a->name,(long)size);
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_default::dump_values]\n}",err,grib_get_error_message(err));
return ;
}
if(!(d->option_flags & GRIB_DUMP_FLAG_ALL_DATA) && size > 100) {
more = size - 100;
size = 100;
}
k = 0;
while(k < size) {
#if 1
int j;
fprintf(self->dumper.out," ");
for(j = 0; j < 5 && k < size; j++, k++) {
fprintf(self->dumper.out,"%.10e",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) {
fprintf(self->dumper.out," ");
fprintf(self->dumper.out,"... %d more values\n",more);
}
fprintf(self->dumper.out," ");
fprintf(self->dumper.out,"} \n");
grib_context_free(d->handle->context,buf);
}
int pack_long_unsigned_helper(grib_accessor* a, const long* val, size_t *len, int check)
{
grib_accessor_unsigned* self = (grib_accessor_unsigned*)a;
int ret = 0;
long off = 0;
long rlen = 0;
int err = 0;
size_t buflen = 0;
unsigned char *buf = NULL;
unsigned long i = 0;
unsigned long missing = 0;
err=grib_value_count(a,&rlen);
if (err) return err;
if(a->flags & GRIB_ACCESSOR_FLAG_CAN_BE_MISSING)
{
Assert(self->nbytes <= 4);
missing = ones[self->nbytes];
}
if (a->flags & GRIB_ACCESSOR_FLAG_TRANSIENT) {
a->vvalue->lval=val[0];
if(missing && val[0] == GRIB_MISSING_LONG)
a->vvalue->missing=1;
else
a->vvalue->missing=0;
return GRIB_SUCCESS;
}
if(*len < 1)
{
grib_context_log(a->parent->h->context, GRIB_LOG_ERROR, "Wrong size for %s it contains %d values ", a->name , 1 );
len[0] = 0;
return GRIB_ARRAY_TOO_SMALL;
}
if (rlen == 1) {
long v = val[0];
if (missing)
if(v == GRIB_MISSING_LONG)
v = missing;
/* Check if value fits into number of bits */
if (check) {
const long nbits = self->nbytes*8;
/* See GRIB-23 and GRIB-262 */
if (! value_is_missing(v) ) {
if (v < 0) {
grib_context_log(a->parent->h->context, GRIB_LOG_ERROR,
"Key \"%s\": Trying to encode a negative value of %ld for key of type unsigned\n", a->name, v);
return GRIB_ENCODING_ERROR;
}
if (nbits < 32) {
unsigned long maxval = (1 << nbits)-1;
if (v > maxval) {
grib_context_log(a->parent->h->context, GRIB_LOG_ERROR,
"Key \"%s\": Trying to encode value of %ld but the maximum allowable value is %ld (number of bits=%ld)\n",
a->name, v, maxval, nbits);
return GRIB_ENCODING_ERROR;
}
}
}
}
off = a->offset*8;
ret = grib_encode_unsigned_long(a->parent->h->buffer->data, v, &off, self->nbytes*8);
if (ret == GRIB_SUCCESS) len[0] = 1;
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 );
len[0] = 1;
return ret;
}
/* TODO: We assume that there are no missing values if there are more that 1 value */
buflen = *len*self->nbytes;
buf = (unsigned char*)grib_context_malloc(a->parent->h->context,buflen);
for(i=0; i < *len;i++)
grib_encode_unsigned_long(buf, val[i] , &off, self->nbytes*8);
ret = grib_set_long_internal(a->parent->h,grib_arguments_get_name(a->parent->h,self->arg,0),*len);
if(ret == GRIB_SUCCESS)
grib_buffer_replace(a, buf, buflen,1,1);
else
*len = 0;
grib_context_free(a->parent->h->context,buf);
return ret;
}
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;
}
static void dump_values(grib_dumper* d,grib_accessor* a)
{
grib_dumper_serialize *self = (grib_dumper_serialize*)d;
int k,err =0;
double* buf = NULL;
int last=0;
int columns=4;
char* values_format=NULL;
char* default_format="%.16e";
char* columns_str=NULL;
size_t len=0;
char* pc=NULL;
char* pcf=NULL;
size_t size=0;
long count=0;
values_format=default_format;
if((a->flags & GRIB_ACCESSOR_FLAG_READ_ONLY))
return;
grib_value_count(a,&count);
size=count;
if (self->format) {
if (self->format[0]=='\"') values_format=self->format+1;
else values_format=self->format;
last=strlen(values_format)-1;
if (values_format[last]=='\"') values_format[last]='\0';
}
pc = values_format;
pcf = values_format;
while( *pc!='\0' && *pc != '%') pc++;
if (strlen(pc) > 1 ) {
values_format=pc;
len=pc-pcf;
} else {
values_format=default_format;
len=0;
}
if (len>0) {
columns_str=(char*)malloc((len+1)*sizeof(char));
columns_str=(char*)memcpy(columns_str,pcf,len);
columns_str[len]='\0';
columns=atoi(columns_str);
free(columns_str);
}
if(size == 1){
dump_double(d,a,NULL);
return ;
}
if ((d->option_flags & GRIB_DUMP_FLAG_VALUES) == 0 ) return;
buf = (double*)grib_context_malloc(d->handle->context,size * sizeof(double));
fprintf(self->dumper.out,"%s (%ld) {",a->name,(long)size);
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_serialize::dump_values]\n}",err,grib_get_error_message(err));
return ;
}
k = 0;
while(k < size)
{
int j;
for(j = 0; j < columns && k < size; j++, k++)
{
fprintf(self->dumper.out,values_format,buf[k]);
if(k != size-1)
fprintf(self->dumper.out,", ");
}
fprintf(self->dumper.out,"\n");
}
fprintf(self->dumper.out,"}\n");
grib_context_free(d->handle->context,buf);
}
