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); }