static int pack_long(grib_accessor* a, const long* val, size_t *len)
{
int ret=0;
long v = val[0];
grib_accessor_time* self = (grib_accessor_time*)a;
long hour = 0;
long minute = 0;
long second = 0;
if(*len != 1)
return GRIB_WRONG_ARRAY_SIZE;
hour = v / 100;
minute = v % 100;
second = 0; /* We ignore the 'seconds' in our time calculation! */
if ((ret=grib_set_long_internal(a->parent->h,self->hour,hour))!=GRIB_SUCCESS)
return ret;
if ((ret=grib_set_long_internal(a->parent->h,self->minute,minute))!=GRIB_SUCCESS)
return ret;
if ((ret=grib_set_long_internal(a->parent->h,self->second,second))!=GRIB_SUCCESS)
return ret;
return GRIB_SUCCESS;
}
static int pack_long(grib_accessor* a, const long* val, size_t *len)
{
int ret=0;
long v = val[0];
grib_accessor_budgdate* self = (grib_accessor_budgdate*)a;
long year = 0;
long month = 0;
long day = 0;
if(*len != 1)
return GRIB_WRONG_ARRAY_SIZE;
year = v / 10000; v %= 10000;
month = v / 100; v %= 100;
day = v;
year -= 1900;
Assert(year < 255);
if ((ret=grib_set_long_internal(a->parent->h,self->day,day))!=GRIB_SUCCESS)
return ret;
if ((ret=grib_set_long_internal(a->parent->h,self->month,month))!=GRIB_SUCCESS)
return ret;
if ((ret=grib_set_long_internal(a->parent->h,self->year,year))!=GRIB_SUCCESS)
return ret;
return ret;
}
static int pack_double(grib_accessor* a, const double* val, size_t *len)
{
grib_accessor_data_apply_bitmap* self = (grib_accessor_data_apply_bitmap*)a;
int err = 0;
size_t bmaplen = *len;
long coded_n_vals = 0;
double* coded_vals = NULL;
long i = 0;
long j = 0;
double missing_value = 0;
if (*len ==0) return GRIB_NO_VALUES;
if(!grib_find_accessor(a->parent->h,self->bitmap)){
err = grib_set_double_array_internal(a->parent->h,self->coded_values,val,*len);
/*printf("SETTING TOTAL number_of_data_points %s %ld\n",self->number_of_data_points,*len);*/
if(self->number_of_data_points)
grib_set_long_internal(a->parent->h,self->number_of_data_points,*len);
return err;
}
if((err = grib_get_double_internal(a->parent->h,self->missing_value,&missing_value)) != GRIB_SUCCESS)
return err;
if((err = grib_set_double_array_internal(a->parent->h,self->bitmap,val,bmaplen)) != GRIB_SUCCESS)
return err;
coded_n_vals = *len;
if(coded_n_vals < 1){
err = grib_set_double_array_internal(a->parent->h,self->coded_values,NULL,0);
return err;
}
coded_vals = (double*)grib_context_malloc_clear(a->parent->h->context,coded_n_vals*sizeof(double));
if(!coded_vals) return GRIB_OUT_OF_MEMORY;
for(i=0; i<*len ; i++)
{
if(val[i] != missing_value) {
coded_vals[j++] = val[i];
}
}
err = grib_set_double_array_internal(a->parent->h,self->coded_values,coded_vals,j);
if (j==0) {
if (self->number_of_values)
err=grib_set_long_internal(a->parent->h,self->number_of_values,0);
if (self->binary_scale_factor)
err=grib_set_long_internal(a->parent->h,self->binary_scale_factor,0);
}
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_g1param* self = (grib_accessor_g1param*)a;
long parameter = *val % 1000;
long table = *val / 1000;
int err = 0;
if(table == 0) table = 128;
err = grib_set_long_internal(a->parent->h,self->parameter,parameter);
if(err) return err;
err = grib_set_long_internal(a->parent->h,self->table,table);
return err;
}
static int pack_long(grib_accessor* a, const long* val, size_t *len)
{
grib_accessor_times* self = (grib_accessor_times*)a;
int ret = 0;
long value = 0;
long factor,v,divisor=1;
if (*val==GRIB_MISSING_LONG)
return grib_set_missing(a->parent->h,self->value);
ret = grib_get_long_internal(a->parent->h, self->factor,&factor);
if(ret ) return ret;
if (self->divisor)
ret = grib_get_long_internal(a->parent->h, self->divisor,&divisor);
if(ret ) return ret;
/*Assert((*val%self->factor)==0);*/
v=*val*divisor;
if ((v%factor)==0) {
value = v/factor;
} else {
value = v > 0 ? ((double)v)/factor+0.5 :
((double)v)/factor-0.5;
/* grib_context_log(a->parent->h->context,GRIB_LOG_WARNING,"%s/%ld = %ld/%ld = %ld. Rounding to convert key.",a->name,self->factor,*val,self->factor,value); */
}
ret = grib_set_long_internal(a->parent->h, self->value,value);
if(ret ) return ret;
*len = 1;
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 pack_double(grib_accessor* a, const double* val, size_t *len)
{
grib_accessor_g2latlon* self = (grib_accessor_g2latlon*)a;
int ret = 0;
double grid[6];
size_t size = 6;
if(*len < 1){
ret = GRIB_ARRAY_TOO_SMALL;
return ret;
}
if(self->given)
{
long given = *val != GRIB_MISSING_DOUBLE;
if((ret = grib_set_long_internal(a->parent->h, self->given,given)) != GRIB_SUCCESS)
return ret;
}
if((ret = grib_get_double_array_internal(a->parent->h, self->grid,grid,&size)) != GRIB_SUCCESS)
return ret;
if ( (self->index == 1 || self->index == 3) && *val < 0 ) grid[self->index] = 360+*val;
else grid[self->index] = *val;
return grib_set_double_array_internal(a->parent->h, self->grid,grid,size);
}
static int pack_double(grib_accessor* a, const double* val, size_t *len)
{
grib_accessor_data_g2shsimple_packing* self = (grib_accessor_data_g2shsimple_packing*)a;
int err = GRIB_SUCCESS;
size_t coded_n_vals = *len-1;
size_t n_vals = *len;
if (*len ==0) return GRIB_NO_VALUES;
self->dirty=1;
if((err = grib_set_double_internal(grib_handle_of_accessor(a),self->real_part,*val)) != GRIB_SUCCESS)
return err;
{
/* Make sure we can decode it again */
double ref = 1e-100;
grib_get_double_internal(grib_handle_of_accessor(a),self->real_part,&ref);
Assert(ref == *val);
}
val++;
if((err = grib_set_double_array_internal(grib_handle_of_accessor(a),self->coded_values,val,coded_n_vals)) != GRIB_SUCCESS)
return err;
*len = n_vals;
if((err = grib_set_long_internal(grib_handle_of_accessor(a),self->numberOfValues,(long)n_vals)) != GRIB_SUCCESS)
return err;
return err;
}
static int pack_long(grib_accessor* a, const long* val, size_t *len)
{
grib_accessor_g2step* self = (grib_accessor_g2step*)a;
int err = 0;
long forecast_time = *val;
long unit = 1;
Assert(forecast_time >= 0);
err = grib_set_long_internal(a->parent->h,self->unit,unit);
if(err) return err;
err = grib_set_long_internal(a->parent->h,self->forecast_time,forecast_time);
if(err) return err;
return GRIB_SUCCESS;
}
static int pack_long(grib_accessor* a, const long* val, size_t *len)
{
grib_accessor_step_in_units* self = (grib_accessor_step_in_units*)a;
grib_handle* h=grib_handle_of_accessor(a);
int err = 0;
long codedStep,codedUnits,stepUnits;
long oldStep=0;
long indicatorOfUnitForTimeRange,lengthOfTimeRange;
if((err = grib_get_long_internal(h,self->codedUnits,&codedUnits))) return err;
if((err = grib_get_long_internal(h,self->stepUnits,&stepUnits))) return err;
unpack_long(a,&oldStep,len);
if (stepUnits!=codedUnits) {
codedStep=*val * u2s[stepUnits];
if (codedStep%u2s2[codedUnits]!=0) {
codedUnits=stepUnits;
err = grib_set_long_internal(h,self->codedUnits,codedUnits);
if (err!=GRIB_SUCCESS) return err;
codedStep=*val;
}
else {
codedStep = codedStep / u2s2[codedUnits];
}
}
else {
codedStep = *val;
}
if (self->indicatorOfUnitForTimeRange) {
if((err = grib_get_long_internal(h,
self->indicatorOfUnitForTimeRange,&indicatorOfUnitForTimeRange))) return err;
if((err = grib_get_long_internal(h,
self->lengthOfTimeRange,&lengthOfTimeRange))) return err;
if (codedUnits == indicatorOfUnitForTimeRange )
lengthOfTimeRange-=codedStep-oldStep;
else lengthOfTimeRange-=codedStep * u2s2[codedUnits]/u2s2[indicatorOfUnitForTimeRange];
lengthOfTimeRange = lengthOfTimeRange > 0 ? lengthOfTimeRange : 0 ;
err = grib_set_long_internal(grib_handle_of_accessor(a),self->lengthOfTimeRange,lengthOfTimeRange);
if (err!=GRIB_SUCCESS) return err;
}
return grib_set_long_internal(grib_handle_of_accessor(a),self->codedStep,codedStep);
}
static int pack_long(grib_accessor* a, const long* val, size_t *len)
{
int ret=0;
long v = val[0];
grib_accessor_g1date* self = (grib_accessor_g1date*)a;
long year = 0;
long century = 0;
long month = 0;
long day = 0;
if(*len != 1)
return GRIB_WRONG_ARRAY_SIZE;
{
long d = grib_julian_to_date((long)grib_date_to_julian(v));
if(v != d)
{
grib_context_log(a->parent->h->context,GRIB_LOG_ERROR,"grib_accessor_g1date: pack_long invalid date %ld, changed to %ld",v,d);
return GRIB_ENCODING_ERROR;
}
}
century = v / 1000000; v %= 1000000;
year = v / 10000; v %= 10000;
month = v / 100; v %= 100;
day = v;
if(year == 0)
year = 100;
else
century++;
if ((ret=grib_set_long_internal(a->parent->h,self->century,century))!=GRIB_SUCCESS)
return ret;
if ((ret=grib_set_long_internal(a->parent->h,self->day,day))!=GRIB_SUCCESS)
return ret;
if ((ret=grib_set_long_internal(a->parent->h,self->month,month))!=GRIB_SUCCESS)
return ret;
if ((ret=grib_set_long_internal(a->parent->h,self->year,year))!=GRIB_SUCCESS)
return ret;
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 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 pack_double(grib_accessor* a, const double* val, size_t *len)
{
grib_accessor_scale* self = (grib_accessor_scale*)a;
int ret = 0;
long value = 0;
long divisor = 0;
long multiplier = 0;
long truncating=0;
double x;
ret = grib_get_long_internal(a->parent->h, self->divisor,&divisor);
if(ret != GRIB_SUCCESS) {
grib_context_log(a->parent->h->context, GRIB_LOG_ERROR, "Accessor %s cannont gather value for %s error %d \n", a->name, self->divisor, ret);
return ret;
}
ret = grib_get_long_internal(a->parent->h, self->multiplier,&multiplier);
if(ret != GRIB_SUCCESS){
grib_context_log(a->parent->h->context, GRIB_LOG_ERROR, "Accessor %s cannont gather value for %s error %d \n", a->name, self->divisor, ret);
return ret;
}
if (self->truncating) {
ret = grib_get_long_internal(a->parent->h, self->truncating,&truncating);
if(ret != GRIB_SUCCESS){
grib_context_log(a->parent->h->context, GRIB_LOG_ERROR, "Accessor %s cannont gather value for %s error %d \n", a->name, self->truncating, ret);
return ret;
}
}
if (multiplier == 0) {
grib_context_log(a->parent->h->context, GRIB_LOG_ERROR, "Accessor %s cannont divide by a zero multiplier %s error %d \n", a->name, self->multiplier, ret);
return GRIB_ENCODING_ERROR;
}
x=*val * (double)divisor / (double)multiplier;
if (*val == GRIB_MISSING_DOUBLE) value = GRIB_MISSING_LONG;
else if (truncating) {
value = (long)x;
} else {
value = x > 0 ? (long)(x+0.5) : (long)(x-0.5) ;
}
ret = grib_set_long_internal(a->parent->h, self->value,value);
if(ret )
grib_context_log(a->parent->h->context, GRIB_LOG_ERROR, "Accessor %s cannont pack value for %s error %d \n", a->name, self->value, ret);
if (ret == GRIB_SUCCESS) *len = 1;
return ret;
}
static int pack_double(grib_accessor* a, const double* val, size_t *len)
{
grib_accessor_julian_day* self = (grib_accessor_julian_day*)a;
int ret=0;
long hour=0;
long minute=0;
long second=0;
long date=0;
long year,month,day;
ret=grib_julian_to_datetime(*val,&year,&month,&day,&hour,&minute,&second);
date=year * 10000 + month * 100 + day;
ret=grib_set_long_internal(a->parent->h,self->date,date);
if (ret!=0) return ret;
ret=grib_set_long_internal(a->parent->h,self->hour,hour);
if (ret!=0) return ret;
ret=grib_set_long_internal(a->parent->h,self->minute,minute);
if (ret!=0) return ret;
ret=grib_set_long_internal(a->parent->h,self->second,second);
return ret;
}
static int pack_double(grib_accessor* a, const double* val, size_t *len)
{
grib_accessor_data_g2complex_packing* self = (grib_accessor_data_g2complex_packing*)a;
int ret = GRIB_SUCCESS;
grib_accessor_class* super = *(a->cclass->super);
if (*len ==0) return GRIB_NO_VALUES;
ret = super->pack_double(a,val,len);
if(ret == GRIB_SUCCESS)
ret = grib_set_long_internal(a->parent->h,self->numberOfValues,*len) ;
return ret;
}
static int unpack_long(grib_accessor* a, long* val, size_t *len)
{
grib_accessor_octect_number* self = (grib_accessor_octect_number*)a;
int ret = 0;
long offset;
offset=a->offset+self->right;
/*printf("-------- setting %s to %ld\n", self->left,offset);*/
if((ret = grib_set_long_internal(a->parent->h, self->left,offset)) != GRIB_SUCCESS)
return ret;
*val = offset;
*len =1;
return ret;
}
static int pack_double(grib_accessor* a, const double* val,size_t *len){
grib_accessor_g1bitmap* self = (grib_accessor_g1bitmap*)a;
size_t tlen;
unsigned char* buf = NULL;
long i;
int err = 0;
long pos = 0;
long bmaplen = 0;
const int bit_padding = 16;
double miss_values = 0;
tlen = ((*len+bit_padding-1)/bit_padding*bit_padding)/8;
if((err = grib_get_double_internal(a->parent->h, self->missing_value, &miss_values))
!= GRIB_SUCCESS)
return err;
buf = grib_context_malloc_clear(a->parent->h->context,tlen);
if(!buf) return GRIB_OUT_OF_MEMORY;
pos=0;
for(i=0;i<*len;i++)
{
if (val[i] == miss_values)
pos++;
else{
bmaplen++;
grib_set_bit_on(buf, &pos);
}
}
if((err = grib_set_long_internal(a->parent->h, self->unusedBits,tlen*8 - *len ))
!= GRIB_SUCCESS)
return err;
grib_buffer_replace(a, buf, tlen,1,1);
grib_context_free(a->parent->h->context,buf);
return GRIB_SUCCESS;
}
static int pack_double(grib_accessor* a, const double* val, size_t *len)
{
grib_accessor_data_dummy_field* self = (grib_accessor_data_dummy_field*)a;
size_t n_vals = *len;
int err = 0;
long bits_per_value = 0;
long half_byte = 0;
size_t buflen = 0;
unsigned char* buf = NULL;
if (*len ==0) return GRIB_NO_VALUES;
if((err = grib_get_long_internal(a->parent->h,self->bits_per_value,&bits_per_value)) != GRIB_SUCCESS)
return err;
buflen = (1+((bits_per_value*n_vals)/8))*sizeof(unsigned char);
buf = (unsigned char*)grib_context_malloc_clear(a->parent->h->context,buflen);
if (!buf) return GRIB_OUT_OF_MEMORY;
half_byte = (buflen*8)-((*len)*bits_per_value);
if((err = grib_set_long_internal(a->parent->h,self->half_byte, half_byte)) != GRIB_SUCCESS) {
grib_context_free(a->parent->h->context,buf);
return err;
}
grib_buffer_replace(a, buf, buflen,1,1);
grib_context_free(a->parent->h->context,buf);
return GRIB_SUCCESS;
}
static int unpack_long(grib_accessor* a, long* val, size_t *len)
{
grib_accessor_step_in_units* self = (grib_accessor_step_in_units*)a;
int err = 0;
long codedStep,codedUnits,stepUnits;
grib_handle* h=grib_handle_of_accessor(a);
int factor=0;
long u2sf,u2sf_step_unit;
if((err = grib_get_long_internal(h,self->codedUnits,&codedUnits))) return err;
if((err = grib_get_long_internal(h,self->stepUnits,&stepUnits))) return err;
if((err = grib_get_long_internal(h,self->codedStep,&codedStep))) return err;
if (stepUnits!=codedUnits) {
*val=codedStep*u2s2[codedUnits];
if (*val<0) {
factor=60;
if (u2s2[codedUnits] % factor) return GRIB_DECODING_ERROR;
if (u2s[stepUnits] % factor) return GRIB_DECODING_ERROR;
u2sf=u2s2[codedUnits]/factor;
*val=codedStep*u2sf;
u2sf_step_unit=u2s[stepUnits]/factor;
} else {
u2sf_step_unit=u2s[stepUnits];
}
if (*val % u2sf_step_unit!=0) {
err = grib_set_long_internal(h,self->stepUnits,codedUnits);
*val=codedStep;
return err;
}
*val = *val / u2sf_step_unit;
} else *val=codedStep;
return GRIB_SUCCESS;
}
static int pack_long(grib_accessor* a, const long* val, size_t *len)
{
long bitsPerValue=0;
double* values=NULL;
size_t size=0;
int ret=0;
grib_accessor_decimal_precision* self= (grib_accessor_decimal_precision*)a;
grib_context* c=a->parent->h->context;
grib_handle* h=a->parent->h;
if (!self->values) {
if((ret = grib_set_long_internal(h, self->bits_per_value,0))
!= GRIB_SUCCESS) return ret;
if((ret = grib_set_long_internal(h, self->decimal_scale_factor,*val))
!= GRIB_SUCCESS) return ret;
if((ret = grib_set_long_internal(h, self->changing_precision,1))
!= GRIB_SUCCESS) {
grib_context_free(c,values);
return ret;
}
return GRIB_SUCCESS;
}
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_buffer_free(c,values);
return ret;
}
if((ret = grib_set_long_internal(h, self->decimal_scale_factor,*val))
!= GRIB_SUCCESS) {
grib_context_buffer_free(c,values);
return ret;
}
if((ret = grib_set_long_internal(h, self->bits_per_value,bitsPerValue))
!= GRIB_SUCCESS) {
grib_context_free(c,values);
return ret;
}
if((ret = grib_set_long_internal(h, self->changing_precision,1))
!= GRIB_SUCCESS) {
grib_context_free(c,values);
return ret;
}
if((ret = grib_set_double_array_internal(h, self->values,values,size))
!= GRIB_SUCCESS) {
grib_context_buffer_free(c,values);
return ret;
}
grib_context_free(c,values);
return GRIB_SUCCESS;
}
static int pack_double(grib_accessor* a, const double* cval, size_t *len)
{
grib_accessor_data_g1simple_packing* self = (grib_accessor_data_g1simple_packing*)a;
grib_accessor_class* super = *(a->cclass->super);
size_t n_vals = *len;
long half_byte = 0;
int ret = 0;
long offsetdata = 0;
long offsetsection = 0;
double reference_value = 0;
long binary_scale_factor = 0;
long bits_per_value = 0;
long decimal_scale_factor = 0;
double decimal = 1;
size_t buflen = 0;
unsigned char* buf = NULL;
unsigned char* encoded = NULL;
double divisor = 1;
int i;
long off = 0;
grib_context* c=a->parent->h->context;
grib_handle* h=a->parent->h;
char* ieee_packing_s=NULL;
char* packingType_s=NULL;
char* precision_s=NULL;
double units_factor=1.0;
double units_bias=0.0;
double* val=(double*)cval;
double missingValue=9999.0;
long constantFieldHalfByte=0;
int err=0;
if(*len != 0) {
if(self->units_factor &&
(grib_get_double_internal(a->parent->h,self->units_factor,&units_factor)== GRIB_SUCCESS)) {
grib_set_double_internal(a->parent->h,self->units_factor,1.0);
}
if(self->units_bias &&
(grib_get_double_internal(a->parent->h,self->units_bias,&units_bias)== GRIB_SUCCESS)) {
grib_set_double_internal(a->parent->h,self->units_bias,0.0);
}
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;
if (c->ieee_packing && self->ieee_packing) {
long precision=c->ieee_packing==32 ? 1 : 2;
size_t lenstr=strlen(self->ieee_packing);
packingType_s=grib_context_strdup(c,self->packingType);
ieee_packing_s=grib_context_strdup(c,self->ieee_packing);
precision_s=grib_context_strdup(c,self->precision);
grib_set_string(h,packingType_s,ieee_packing_s,&lenstr);
grib_set_long(h,precision_s,precision);
grib_context_free(c,packingType_s);
grib_context_free(c,ieee_packing_s);
grib_context_free(c,precision_s);
return grib_set_double_array(h,"values",val,*len);
}
}
ret = super->pack_double(a,val,len);
switch (ret) {
case GRIB_CONSTANT_FIELD:
ret=grib_get_long(a->parent->h,"constantFieldHalfByte",&constantFieldHalfByte);
if (ret) constantFieldHalfByte=0;
if((ret = grib_set_long_internal(a->parent->h,self->half_byte, constantFieldHalfByte))
!= GRIB_SUCCESS)
return ret;
grib_buffer_replace(a, NULL, 0,1,1);
return GRIB_SUCCESS;
break;
case GRIB_NO_VALUES:
ret=grib_get_long(a->parent->h,"constantFieldHalfByte",&constantFieldHalfByte);
if (ret) constantFieldHalfByte=0;
/* TODO move to def file */
grib_get_double(a->parent->h,"missingValue", &missingValue);
if((err = grib_set_double_internal(a->parent->h,self->reference_value, missingValue)) !=
GRIB_SUCCESS)
return err;
if((ret = grib_set_long_internal(a->parent->h,self->binary_scale_factor, binary_scale_factor))
!= GRIB_SUCCESS)
return ret;
if((ret = grib_set_long_internal(a->parent->h,self->half_byte, constantFieldHalfByte))
!= GRIB_SUCCESS)
return ret;
grib_buffer_replace(a, NULL, 0,1,1);
return GRIB_SUCCESS;
break;
case GRIB_INVALID_BPV:
grib_context_log(a->parent->h->context,GRIB_LOG_ERROR,"unable to compute packing parameters\n");
return ret;
case GRIB_SUCCESS:
break;
default:
grib_context_log(a->parent->h->context,GRIB_LOG_FATAL,"unable to compute packing parameters\n");
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->bits_per_value,&bits_per_value)) !=
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->offsetdata,&offsetdata)) != GRIB_SUCCESS)
return ret;
if((ret = grib_get_long_internal(a->parent->h,self->offsetsection,&offsetsection)) != GRIB_SUCCESS)
return ret;
decimal = grib_power(decimal_scale_factor,10) ;
divisor = grib_power(-binary_scale_factor,2);
buflen = (((bits_per_value*n_vals)+7)/8)*sizeof(unsigned char);
if((buflen + (offsetdata-offsetsection)) %2) {
buflen++;
/*
a->length++;
a->parent->h->buffer->ulength++;
*/
}
half_byte = (buflen*8)-((*len)*bits_per_value);
grib_context_log(a->parent->h->context,GRIB_LOG_DEBUG,
"HALF byte: buflen=%d bits_per_value=%ld len=%d half_byte=%ld\n",
buflen,bits_per_value,*len,half_byte);
Assert(half_byte <= 0x0f);
if((ret = grib_set_long_internal(a->parent->h,self->half_byte, half_byte))
!= GRIB_SUCCESS)
return ret;
buf = (unsigned char*)grib_context_buffer_malloc_clear(a->parent->h->context,buflen);
encoded = buf;
grib_encode_double_array(n_vals,val,bits_per_value,reference_value,decimal,divisor,encoded,&off);
grib_context_log(a->parent->h->context, GRIB_LOG_DEBUG,
"grib_accessor_data_g1simple_packing : pack_double : packing %s, %d values", a->name, n_vals);
grib_buffer_replace(a, buf, buflen,1,1);
grib_context_buffer_free(a->parent->h->context,buf);
return GRIB_SUCCESS;
}
static int pack_double(grib_accessor* a, const 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 s = 0;
double d = 0;
unsigned char* buf = NULL;
size_t buflen = 0;
size_t hsize = 0;
size_t lsize = 0;
unsigned char* hres = NULL;
unsigned char* lres = NULL;
long lpos = 0;
long maxv = 0;
long offsetdata = 0;
long bits_per_value = 0;
double reference_value = 0;
long binary_scale_factor = 0;
long decimal_scale_factor = 0;
long laplacianOperatorIsSet = 0;
double laplacianOperator = 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;
long GRIBEX_sh_bug_present =0;
long ieee_floats =0;
double min = 0;
double max = 0;
double current_val = 0;
short mixmax_unset = 0;
int bytes;
encode_float_proc encode_float = NULL;
if (*len ==0) return GRIB_NO_VALUES;
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_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_long_internal(a->parent->h,self->laplacianOperatorIsSet,&laplacianOperatorIsSet)) != 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=1;
switch (ieee_floats) {
case 0:
encode_float =grib_ibm_to_long;
bytes=4;
break;
case 1:
encode_float =grib_ieee_to_long;
bytes=4;
break;
case 2:
encode_float =grib_ieee64_to_long;
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);
n_vals = (pen_j+1)*(pen_j+2);
d = grib_power(decimal_scale_factor,10) ;
if(*len != n_vals){
grib_context_log(a->parent->h->context,GRIB_LOG_ERROR,"COMPLEX_PACKING : wrong number of values, expected %d - got %d",n_vals,*len);
return GRIB_INTERNAL_ERROR;
}
if (pen_j == sub_j) {
double* values;
if (d) {
values=(double*)grib_context_malloc_clear(a->parent->h->context,sizeof(double)*n_vals);
for (i=0;i<n_vals;i++) values[i]=val[i]*d;
} else {
values=(double*)val;
}
buflen=n_vals*bytes;
buf = (unsigned char*)grib_context_malloc_clear(a->parent->h->context,buflen);
grib_ieee_encode_array(a->parent->h->context,values,n_vals,bytes,buf);
if (d) grib_context_free(a->parent->h->context,values);
grib_buffer_replace(a, buf, buflen,1,1);
grib_context_free(a->parent->h->context,buf);
return 0;
}
if(!laplacianOperatorIsSet) {
laplacianOperator = calculate_pfactor(a->parent->h->context,val,pen_j,sub_j);
if((ret = grib_set_double_internal(a->parent->h,self->laplacianOperator,laplacianOperator))
!= GRIB_SUCCESS) return ret;
grib_get_double_internal(a->parent->h,self->laplacianOperator,&laplacianOperator);
}
/*
printf("PACKING LAPLACE set=%ld value=%.20f\n",laplacianOperatorIsSet,laplacianOperator);
*/
hsize = 4*(sub_k+1)*(sub_k+2);
lsize = ((n_vals - ((sub_k+1)*(sub_k+2)))*bits_per_value)/8;
buflen = hsize+lsize;
buf = (unsigned char*)grib_context_malloc(a->parent->h->context,buflen);
hres = buf;
lres = buf+hsize;
maxv = pen_j+1;
lpos = 0;
hpos = 0;
scals = (double*) grib_context_malloc(a->parent->h->context,maxv*sizeof(double));
Assert(scals);
scals[0] =0;
for(i=1;i<maxv;i++)
scals[i] = ((double)pow(i*(i+1),laplacianOperator));
i=0;
mmax = 0;
maxv = pen_j+1;
i=0;
lcount=0;
hcount=0;
sub_k = sub_j;
while(maxv>0)
{
lup=mmax;
if(sub_k>=0)
{
i += 2*(sub_k+1);
lup += sub_k+1 ;
hcount += sub_k+1 ;
sub_k--;
}
for(lcount=hcount; lcount < maxv ; lcount++)
{
current_val = ((val[i++]*d) * scals[lup]);
if(mixmax_unset == 0){
max = current_val;
min = current_val;
mixmax_unset = 1;
}
if(current_val > max) max = current_val;
if(current_val < min) min = current_val;
current_val = ((val[i++]*d) * scals[lup]);
if(current_val > max) max = current_val;
if(current_val < min) min = current_val;
lup++;
}
maxv--;
hcount=0;
mmax++;
}
if (grib_get_nearest_smaller_value(a->parent->h,self->reference_value,min,&reference_value)
!=GRIB_SUCCESS) {
grib_context_log(a->parent->h->context,GRIB_LOG_ERROR,
"unable to find nearest_smaller_value of %g for %s",min,self->reference_value);
exit(GRIB_INTERNAL_ERROR);
}
binary_scale_factor = grib_get_binary_scale_fact(max,reference_value,bits_per_value,&ret);
if (ret==GRIB_UNDERFLOW) {
d=0;
binary_scale_factor = 0;
reference_value=0;
}
s = grib_power(-binary_scale_factor,2);
/* printf("D : %.30f\n",d); */
i=0;
mmax = 0;
maxv = pen_j+1;
i=0;
lcount=0;
hcount=0;
sub_k = sub_j;
while(maxv>0)
{
lup=mmax;
if(sub_k>=0)
{
for(hcount=0;hcount<sub_k+1;hcount++)
{
if ( GRIBEX_sh_bug_present && hcount==sub_k ) {
/* _test(val[i]*d*scals[lup],1); */
grib_encode_unsigned_long(hres, encode_float((val[i++]*d)*scals[lup]) , &hpos, 32);
/* _test(val[i]*d*scals[lup],1); */
grib_encode_unsigned_long(hres, encode_float((val[i++]*d)*scals[lup]) , &hpos, 32);
}else{
/* _test(val[i]*d,0); */
grib_encode_unsigned_long(hres, encode_float(val[i++]*d) , &hpos, 32);
/* _test(val[i]*d,0); */
grib_encode_unsigned_long(hres, encode_float(val[i++]*d) , &hpos, 32);
}
lup++;
}
sub_k--;
}
#if FAST_BIG_ENDIAN
grib_encode_double_array_complex((maxv-hcount)*2,&(val[i]),bits_per_value,reference_value,&(scals[lup]),d,s,lres,&lpos);
i+=(maxv-hcount)*2;
#else
if (bits_per_value % 8) {
for(lcount=hcount; lcount < maxv ; lcount++)
{
current_val = (((((val[i++]*d) * scals[lup])-reference_value)*s)+0.5);
if(current_val < 0)
grib_context_log(a->parent->h->context,GRIB_LOG_ERROR,
"COMPLEX_PACKING : negative coput before packing (%g)", current_val);
grib_encode_unsigned_longb(lres, current_val, &lpos, bits_per_value);
current_val = (((((val[i++]*d) * scals[lup])-reference_value)*s)+0.5);
if(current_val < 0)
grib_context_log(a->parent->h->context,GRIB_LOG_ERROR,
"COMPLEX_PACKING : negative coput before packing (%g)", current_val);
grib_encode_unsigned_longb(lres, current_val, &lpos, bits_per_value);
lup++;
}
} else {
for(lcount=hcount; lcount < maxv ; lcount++)
{
current_val = (((((val[i++]*d) * scals[lup])-reference_value)*s)+0.5);
if(current_val < 0)
grib_context_log(a->parent->h->context,GRIB_LOG_ERROR,
"COMPLEX_PACKING : negative coput before packing (%g)", current_val);
grib_encode_unsigned_long(lres, current_val, &lpos, bits_per_value);
current_val = (((((val[i++]*d) * scals[lup])-reference_value)*s)+0.5);
if(current_val < 0)
grib_context_log(a->parent->h->context,GRIB_LOG_ERROR,
"COMPLEX_PACKING : negative coput before packing (%g)", current_val);
grib_encode_unsigned_long(lres, current_val, &lpos, bits_per_value);
lup++;
}
}
#endif
maxv--;
hcount=0;
mmax++;
}
if(((hpos/8) != hsize) &&((lpos/8) != lsize))
{
grib_context_log(a->parent->h->context,GRIB_LOG_ERROR,
"COMPLEX_PACKING : Mismatch in packing between high resolution and low resolution part");
grib_context_free(a->parent->h->context,buf);
grib_context_free(a->parent->h->context,scals);
return GRIB_INTERNAL_ERROR;
}
buflen = ((hpos + lpos)/8);
if((ret = grib_set_double_internal(a->parent->h,self->reference_value, reference_value)) != GRIB_SUCCESS)
return ret;
{
/* Make sure we can decode it again */
double ref = 1e-100;
grib_get_double_internal(a->parent->h,self->reference_value,&ref);
Assert(ref == reference_value);
}
if((ret = grib_set_long_internal(a->parent->h,self->binary_scale_factor, binary_scale_factor)) != GRIB_SUCCESS)
return ret;
grib_buffer_replace(a, buf, buflen,1,1);
grib_context_free(a->parent->h->context,buf);
grib_context_free(a->parent->h->context,scals);
return ret;
}
static int pack_double(grib_accessor* a, const double* val, size_t *len)
{
grib_accessor_data_g2secondary_bitmap* self = (grib_accessor_data_g2secondary_bitmap*)a;
int err = 0;
long primary_len = 0;
long secondary_len = 0;
double* primary_bitmap = NULL;
double* secondary_bitmap = NULL;
long i = 0;
long j = 0;
long on = 0;
long k;
long m;
double missing_value = 0;
double present_value = 0;
long expand_by =0;
if (*len ==0) return GRIB_NO_VALUES;
if((err = grib_get_long(a->parent->h,self->expand_by,&expand_by)) != GRIB_SUCCESS)
return err;
if((err = grib_get_double_internal(a->parent->h,self->missing_value,&missing_value)) != GRIB_SUCCESS)
return err;
Assert(expand_by);
if(*len % expand_by)
{
/*TODO: issue warning */
return GRIB_ENCODING_ERROR;
}
primary_len = *len / expand_by;
primary_bitmap= (double*)grib_context_malloc_clear(a->parent->h->context,primary_len*sizeof(double));
if(!primary_bitmap) return GRIB_OUT_OF_MEMORY;
secondary_len = *len ;
secondary_bitmap= (double*)grib_context_malloc_clear(a->parent->h->context,secondary_len*sizeof(double));
if(!secondary_bitmap) {
grib_context_free(a->parent->h->context,primary_bitmap);
return GRIB_OUT_OF_MEMORY;
}
if(missing_value == 0)
present_value = 1;
else
present_value = 0;
k = 0;
m = 0;
for(i=0; i<*len ; i += expand_by)
{
int cnt = 0;
for(j = 0; j < expand_by; j++)
if(val[i+j] == missing_value)
cnt++;
if(cnt == expand_by) /* all expand_by values are missing */
primary_bitmap[k++] = missing_value;
else {
primary_bitmap[k++] = present_value;
for(j = 0; j < expand_by; j++)
secondary_bitmap[m++] = val[i+j];
on++;
}
}
*len = k;
Assert(k == primary_len);
err = grib_set_double_array_internal(a->parent->h,self->primary_bitmap,primary_bitmap,k);
if(err == GRIB_SUCCESS)
err = grib_set_double_array_internal(a->parent->h,self->secondary_bitmap,secondary_bitmap,m);
grib_context_free(a->parent->h->context,primary_bitmap);
grib_context_free(a->parent->h->context,secondary_bitmap);
if(err == GRIB_SUCCESS)
err = grib_set_long_internal(a->parent->h,self->number_of_values,*len * expand_by);
return err;
}
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 pack_double(grib_accessor* a, const double* val, size_t *len)
{
grib_accessor_data_apply_boustrophedonic_bitmap* self = (grib_accessor_data_apply_boustrophedonic_bitmap*)a;
int err = 0;
size_t bmaplen = *len;
size_t irow = 0;
long coded_n_vals = 0;
double* coded_vals = NULL;
double *values=0;
long i = 0;
long j = 0;
long numberOfPoints, numberOfRows, numberOfColumns;
double missing_value = 0;
if (*len ==0) return GRIB_NO_VALUES;
if(!grib_find_accessor(a->parent->h,self->bitmap)){
err = grib_set_double_array_internal(a->parent->h,self->coded_values,val,*len);
/*printf("SETTING TOTAL number_of_data_points %s %ld\n",self->number_of_data_points,*len);*/
/*if(self->number_of_data_points)
grib_set_long_internal(a->parent->h,self->number_of_data_points,*len);*/
return err;
}
if((err = grib_get_double_internal(a->parent->h,self->missing_value,&missing_value)) != GRIB_SUCCESS)
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(numberOfPoints == bmaplen);
/* Create a copy of the incoming 'val' array because we're going to change it */
values = (double*)grib_context_malloc_clear(a->parent->h->context, sizeof(double)*numberOfPoints);
if (!values) return GRIB_OUT_OF_MEMORY;
for(i=0; i<numberOfPoints; ++i) {
values[i] = val[i];
}
/* Boustrophedonic ordering must be applied to the bitmap (See GRIB-472) */
for(irow=0; irow<numberOfRows; ++irow)
{
if (irow%2)
{
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)
{
double temp = values[start+k];
values[start+k] = values[end-k];
values[end-k] = temp;
}
}
}
/* Now set the bitmap based on the array with the boustrophedonic ordering */
if((err = grib_set_double_array_internal(a->parent->h,self->bitmap,values,bmaplen)) != GRIB_SUCCESS)
return err;
grib_context_free(a->parent->h->context,values);
coded_n_vals = *len;
if(coded_n_vals < 1){
err = grib_set_double_array_internal(a->parent->h,self->coded_values,NULL,0);
return err;
}
coded_vals = (double*)grib_context_malloc_clear(a->parent->h->context,coded_n_vals*sizeof(double));
if(!coded_vals) return GRIB_OUT_OF_MEMORY;
for(i=0; i<*len ; i++)
{
/* To set the coded values, look at 'val' (the original array) */
/* NOT 'values' (bitmap) which we swapped about */
if(val[i] != missing_value) {
coded_vals[j++] = val[i];
}
}
err = grib_set_double_array_internal(a->parent->h,self->coded_values,coded_vals,j);
if (j==0) {
/*if (self->number_of_values)
err=grib_set_long_internal(a->parent->h,self->number_of_values,0);*/
if (self->binary_scale_factor)
err=grib_set_long_internal(a->parent->h,self->binary_scale_factor,0);
}
grib_context_free(a->parent->h->context,coded_vals);
return err;
}
static int pack_double(grib_accessor* a, const double* val, size_t *len)
{
grib_accessor_latlon_increment* self = (grib_accessor_latlon_increment*)a;
int ret = 0;
long codedNumberOfPoints=0;
long directionIncrementGiven=0;
long directionIncrement=0;
long angleDivisor=1;
long angleMultiplier=1;
double first = 0;
double last = 0;
long numberOfPoints = 0;
long numberOfPointsInternal = 0;
long scansPositively = 0;
double directionIncrementDouble=0;
ret = grib_get_double_internal(a->parent->h, self->first,&first);
if(ret != GRIB_SUCCESS) return ret;
ret = grib_get_double_internal(a->parent->h, self->last,&last);
if(ret != GRIB_SUCCESS) return ret;
if((ret = grib_get_long_internal(a->parent->h, self->directionIncrementGiven,&directionIncrementGiven))
!= GRIB_SUCCESS) return ret;
if((ret = grib_get_long_internal(a->parent->h, self->numberOfPoints,&numberOfPoints)) != GRIB_SUCCESS) return ret;
if((ret = grib_get_long_internal(a->parent->h, self->scansPositively,&scansPositively))
!= GRIB_SUCCESS) return ret;
if((ret = grib_get_long_internal(a->parent->h, self->angleMultiplier,&angleMultiplier)) != GRIB_SUCCESS) return ret;
if((ret = grib_get_long_internal(a->parent->h, self->angleDivisor,&angleDivisor)) != GRIB_SUCCESS) return ret;
if (self->isLongitude) {
if (last < first && scansPositively) last+=360;
if (last > first && !scansPositively) first-=360;
}
if (*val == GRIB_MISSING_DOUBLE) {
directionIncrement=GRIB_MISSING_LONG;
directionIncrementGiven=1;
numberOfPoints=GRIB_MISSING_LONG;
} else {
numberOfPointsInternal = 1+rint(fabs((last-first) / *val));
directionIncrementDouble = rint (*val * (double)angleDivisor / (double)angleMultiplier);
directionIncrement=(long)directionIncrementDouble;
if (directionIncrement == 0 ) {
directionIncrement=GRIB_MISSING_LONG;
directionIncrementGiven=0;
}
}
/*ret = grib_set_long_internal(a->parent->h, self->numberOfPoints,numberOfPoints);
if(ret )
grib_context_log(a->parent->h->context, GRIB_LOG_ERROR, "Accessor %s cannot pack value for %s error %d \n", a->name, self->numberOfPoints, ret);
*/
grib_get_long_internal(a->parent->h, self->numberOfPoints,&codedNumberOfPoints);
ret = grib_set_long_internal(a->parent->h, self->directionIncrement,directionIncrement);
if(ret ) return ret;
ret = grib_set_long_internal(a->parent->h, self->directionIncrementGiven,directionIncrementGiven);
if(ret )return ret;
#if 0
printf("pack -- %s=%ld %s=%ld \n ------- %s=%f %s=%f \n ------- %s=%ld codedNumberOfPoints=%ld %s=%f\n",
self->directionIncrementGiven,directionIncrementGiven,
self->directionIncrement,directionIncrement,
self->last,last,
self->first,first,
self->numberOfPoints,numberOfPoints,
codedNumberOfPoints,
a->name,*val);
#endif
if (ret == GRIB_SUCCESS) *len = 1;
return ret;
}
static int pack_long(grib_accessor* a, const long* val, size_t *len)
{
grib_accessor_g2end_step* self = (grib_accessor_g2end_step*)a;
grib_handle* h=a->parent->h;
int err = 0;
long year;
long month;
long day;
long hour;
long minute;
long second;
long start_step;
long unit,coded_unit;
long year_of_end_of_interval;
long month_of_end_of_interval;
long day_of_end_of_interval;
long hour_of_end_of_interval;
long minute_of_end_of_interval = 0;
long second_of_end_of_interval = 0;
long coded_time_range,time_range, typeOfTimeIncrement;
double dend, dstep;
/*point in time */
if (self->year == NULL) {
err = grib_set_long_internal(h,self->start_step,*val);
return err;
}
if((err = grib_get_long_internal(h,self->coded_unit,&coded_unit))) return err;
if((err = grib_get_long_internal(h,self->unit,&unit))) return err;
if((err = grib_get_long_internal(h,self->year,&year))) return err;
if((err = grib_get_long_internal(h,self->month,&month))) return err;
if((err = grib_get_long_internal(h,self->day,&day))) return err;
if((err = grib_get_long_internal(h,self->hour,&hour))) return err;
if((err = grib_get_long_internal(h,self->minute,&minute))) return err;
if((err = grib_get_long_internal(h,self->second,&second))) return err;
if((err = grib_get_long_internal(h,self->start_step,&start_step))) return err;
if((err = grib_get_long_internal(h,self->typeOfTimeIncrement, &typeOfTimeIncrement))) return err;
time_range = *val-start_step;
if (time_range<0){
grib_context_log(h->context,GRIB_LOG_ERROR,
"endStep < startStep (%ld < %ld)",*val,start_step);
return GRIB_WRONG_STEP;
}
err=grib_datetime_to_julian(year,month,day,hour,minute,second,&dend);
if (err!=GRIB_SUCCESS) return err;
dstep=(((double)(*val))*u2s[unit])/u2s[2];
dend+=dstep;
err=grib_julian_to_datetime(dend,&year_of_end_of_interval,&month_of_end_of_interval,
&day_of_end_of_interval,&hour_of_end_of_interval,
&minute_of_end_of_interval,&second_of_end_of_interval);
if (err!=GRIB_SUCCESS) return err;
if((err = grib_set_long_internal(a->parent->h,self->year_of_end_of_interval, year_of_end_of_interval))) return err;
if((err = grib_set_long_internal(a->parent->h,self->month_of_end_of_interval, month_of_end_of_interval))) return err;
if((err = grib_set_long_internal(a->parent->h,self->day_of_end_of_interval, day_of_end_of_interval))) return err;
if((err = grib_set_long_internal(a->parent->h,self->hour_of_end_of_interval, hour_of_end_of_interval))) return err;
if((err = grib_set_long_internal(a->parent->h,self->minute_of_end_of_interval, minute_of_end_of_interval))) return err;
if((err = grib_set_long_internal(a->parent->h,self->second_of_end_of_interval, second_of_end_of_interval))) return err;
if (time_range*u2s[unit]%u2s2[coded_unit]) {
coded_unit=unit;
if((err = grib_set_long_internal(a->parent->h,self->coded_unit, coded_unit))) return err;
coded_time_range=time_range;
} else
coded_time_range=(time_range*u2s[unit])/u2s2[coded_unit];
if (typeOfTimeIncrement != 1) {
/* 1 means "Successive times processed have same forecast time, start time of forecast is incremented" */
/* Note: For this case, length of timeRange is not related to step and so should NOT be used to calculate step */
if((err = grib_set_long_internal(a->parent->h,self->coded_time_range, coded_time_range))) return err;
}
return GRIB_SUCCESS;
}
static int pack_double(grib_accessor* a, const double* val, size_t *len)
{
grib_accessor_data_g1complex_packing* self =
(grib_accessor_data_g1complex_packing*)a;
int ret = GRIB_SUCCESS;
long seclen=0;
long sub_j= 0;
long sub_k= 0;
long sub_m= 0;
long n= 0;
long half_byte= 0;
long bits_per_value =0;
size_t buflen =0;
grib_context* c=a->parent->h->context;
grib_handle* h=a->parent->h;
char* ieee_packing_s=NULL;
char* packingType_s=NULL;
char* precision_s=NULL;
grib_accessor_class* super = *(a->cclass->super);
if (*len ==0) return GRIB_NO_VALUES;
if (c->ieee_packing && self->ieee_packing) {
long precision=c->ieee_packing==32 ? 1 : 2;
size_t lenstr=strlen(self->ieee_packing);
packingType_s=grib_context_strdup(c,self->packingType);
ieee_packing_s=grib_context_strdup(c,self->ieee_packing);
precision_s=grib_context_strdup(c,self->precision);
grib_set_string(h,packingType_s,ieee_packing_s,&lenstr);
grib_set_long(h,precision_s,precision);
grib_context_free(c,packingType_s);
grib_context_free(c,ieee_packing_s);
grib_context_free(c,precision_s);
return grib_set_double_array(h,"values",val,*len);
}
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;
self->dirty=1;
Assert ((sub_j== sub_k) && (sub_m== sub_j));
ret = super->pack_double(a,val,len);
if(ret == GRIB_SUCCESS){
n = a->offset + 4*((sub_k+1)*(sub_k+2));
#if 1
/* Octet number starts from beginning of message but shouldn't */
if((ret = grib_set_long_internal(a->parent->h,self->N,n)) != GRIB_SUCCESS)
return ret;
#else
ret = grib_get_long_internal(a->parent->h,self->offsetsection,&offsetsection);
if(ret != GRIB_SUCCESS) return ret;
if((ret = grib_set_long_internal(a->parent->h,self->N,n-offsetsection))
!= GRIB_SUCCESS) return ret;
#endif
ret = grib_get_long_internal(a->parent->h,self->bits_per_value,&bits_per_value);
if(ret != GRIB_SUCCESS) return ret;
ret = grib_get_long_internal(a->parent->h,self->seclen,&seclen);
if(ret != GRIB_SUCCESS) return ret;
buflen = 32*(sub_k+1)*(sub_k+2)+(*len-(sub_k+1)*(sub_k+2))*bits_per_value+18*8;
half_byte = seclen*8-buflen;
if (a->parent->h->context->debug==-1) {
printf("GRIB_API DEBUG: half_byte=%ld\n",half_byte);
}
ret = grib_set_long_internal(a->parent->h,self->half_byte, half_byte);
if(ret != GRIB_SUCCESS) return ret;
}
return ret;
}
static int pack_long(grib_accessor* a, const long* val, size_t *len)
{
grib_accessor_g1forecastmonth* self = (grib_accessor_g1forecastmonth*)a;
return grib_set_long_internal(a->parent->h,self->fcmonth, *val);
}
