static int value_count(grib_accessor* a, long* numberOfPoints) { grib_accessor_data_apply_boustrophedonic *self =(grib_accessor_data_apply_boustrophedonic*)a; int ret=0; *numberOfPoints=0; ret=grib_get_long_internal(a->parent->h,self->numberOfPoints,numberOfPoints); return ret; }
static int value_count(grib_accessor* a,long* number_of_values) { grib_accessor_data_g1simple_packing *self =(grib_accessor_data_g1simple_packing*)a; *number_of_values=0; /* Special case for when values are cleared */ /*if(a->length == 0) return 0;*/ return grib_get_long_internal(a->parent->h,self->number_of_values,number_of_values); }
static int value_count(grib_accessor* a,long* numberOfSecondOrderPackedValues) { int err=0; grib_accessor_data_g1second_order_constant_width_packing *self =(grib_accessor_data_g1second_order_constant_width_packing*)a; *numberOfSecondOrderPackedValues=0; err=grib_get_long_internal(grib_handle_of_accessor(a),self->numberOfSecondOrderPackedValues,numberOfSecondOrderPackedValues); return err; }
static int is_missing(grib_accessor* a) { grib_accessor_g2latlon* self = (grib_accessor_g2latlon*)a; long given = 1; if(self->given) grib_get_long_internal(a->parent->h, self->given,&given); return !given; }
static int unpack_long(grib_accessor* a, long* val, size_t *len) { int ret=0; grib_accessor_decimal_precision* self= (grib_accessor_decimal_precision*)a; grib_handle* h=a->parent->h; if((ret = grib_get_long_internal(h,self->decimal_scale_factor,val)) != GRIB_SUCCESS) return ret; *len =1; return ret; }
static int unpack_string(grib_accessor*a , char* v, size_t *len){ grib_accessor_md5* self = (grib_accessor_md5*)a; unsigned mess_len; unsigned char* mess; unsigned char* p; long offset,length; grib_string_list* blacklist=NULL; grib_accessor* b=NULL; int ret=0; int i=0; struct grib_md5_state md5c; if (*len <32 ) { grib_context_log(a->context,GRIB_LOG_ERROR,"md5: array too small"); return GRIB_ARRAY_TOO_SMALL; } if((ret = grib_get_long_internal(grib_handle_of_accessor(a),self->offset,&offset)) != GRIB_SUCCESS) return ret; if((ret = grib_expression_evaluate_long(grib_handle_of_accessor(a),self->length,&length)) != GRIB_SUCCESS) return ret; mess=(unsigned char*)grib_context_malloc(a->context,length); memcpy(mess,grib_handle_of_accessor(a)->buffer->data+offset,length); mess_len=length; blacklist=a->context->blacklist; /* passed blacklist overrides context blacklist. Consider to modify following line to extend context blacklist. */ if (self->blacklist) blacklist=self->blacklist; while (blacklist && blacklist->value) { b=grib_find_accessor(grib_handle_of_accessor(a),blacklist->value); if (!b) { grib_context_free(a->context,mess); return GRIB_NOT_FOUND; } p=mess+b->offset-offset; for (i=0;i<b->length;i++) *(p++)=0; blacklist=blacklist->next; } grib_md5_init(&md5c); grib_md5_add(&md5c,mess,mess_len); grib_md5_end(&md5c,v); grib_context_free(a->context,mess); return ret; }
static int unpack_long(grib_accessor* a, long* val, size_t *len) { int ret=GRIB_SUCCESS; size_t size=0; size_t i; double max,min,d,b; double *values=0; long binaryScaleFactor,decimalScaleFactor; grib_accessor_second_order_bits_per_value* self = (grib_accessor_second_order_bits_per_value*)a; if (self->bitsPerValue) { *val=self->bitsPerValue; return GRIB_SUCCESS; } if((ret = grib_get_size(a->parent->h, self->values,&size)) != GRIB_SUCCESS) { *val=self->bitsPerValue; return GRIB_SUCCESS; } if((ret = grib_get_long(a->parent->h, self->binaryScaleFactor,&binaryScaleFactor)) != GRIB_SUCCESS) return ret; if((ret = grib_get_long_internal(a->parent->h, self->decimalScaleFactor,&decimalScaleFactor)) != GRIB_SUCCESS) return ret; values=grib_context_malloc_clear(a->parent->h->context,sizeof(double)*size); if (!values) { grib_context_log(a->parent->h->context,GRIB_LOG_FATAL,"%s unable to allocate %ld bytes", a->name,(long)size); return GRIB_OUT_OF_MEMORY; } if((ret = grib_get_double_array_internal(a->parent->h, self->values,values,&size)) != GRIB_SUCCESS) return ret; max=values[0]; min=max; for (i=1;i<size;i++) { if (max<values[i]) max=values[i]; if (min>values[i]) min=values[i]; } d=grib_power(-decimalScaleFactor,10); b=grib_power(-binaryScaleFactor,2); /* self->bitsPerValue=(long)ceil(log((double)((max-min)*d+1))/log(2.0))-binaryScaleFactor; */ self->bitsPerValue=number_of_bits((unsigned long)(fabs(max-min)*b*d)); *val=self->bitsPerValue; grib_context_free(a->parent->h->context,values); return ret; }
static int unpack_long(grib_accessor* a, long* val, size_t *len) { int ret=0; grib_accessor_bits_per_value* self= (grib_accessor_bits_per_value*)a; grib_handle* h=grib_handle_of_accessor(a); if((ret = grib_get_long_internal(h,self->bits_per_value,val)) != GRIB_SUCCESS) return ret; *len =1; return ret; }
static long value_count(grib_accessor* a) { grib_accessor_g1bitmap* self = (grib_accessor_g1bitmap*)a; long tlen; int err; if ((err=grib_get_long_internal(a->parent->h, self->unusedBits, &tlen)) != GRIB_SUCCESS) grib_context_log(a->parent->h->context, GRIB_LOG_ERROR, "grib_accessor_class_bitmap.value_count : cannot get %s err=%d",self->unusedBits,err); tlen = (a->length*8)-tlen; return tlen; }
static int value_count(grib_accessor* a,long* numberOfPoints) { grib_accessor_data_dummy_field* self = (grib_accessor_data_dummy_field*)a; int err=0; *numberOfPoints = 0; if((err = grib_get_long_internal(a->parent->h,self->numberOfPoints, numberOfPoints)) != GRIB_SUCCESS) { grib_context_log(a->parent->h->context,GRIB_LOG_ERROR,"unable to get count of %s (%s)",a->name,grib_get_error_message(err)); } return err; }
static void compute_size(grib_accessor* a) { long slen = 0; long off = 0; grib_accessor_bitmap* self = (grib_accessor_bitmap*)a; grib_get_long_internal(a->parent->h, self->offsetbsec,&off); grib_get_long_internal(a->parent->h, self->sLength, &slen); if(slen == 0) { grib_accessor* seclen; size_t size; /* Assume reparsing */ Assert(a->parent->h->loader != 0); if (a->parent->h->loader != 0) { seclen = grib_find_accessor(a->parent->h, self->sLength); Assert(seclen); grib_get_block_length(seclen->parent,&size); slen = size; } } #if 0 printf("compute_size off=%ld slen=%ld a->offset=%ld\n", (long)off,(long)slen,(long)a->offset); #endif a->length = off+(slen-a->offset); if(a->length < 0) { /* Assume reparsing */ /*Assert(a->parent->h->loader != 0);*/ a->length = 0; } Assert(a->length>=0); }
static int unpack_long (grib_accessor* a, long* val, size_t *len) { int ret=0; grib_handle* h=a->parent->h; grib_accessor_gds_is_present* self = (grib_accessor_gds_is_present*)a; if((ret = grib_get_long_internal(h,self->gds_present,val)) != GRIB_SUCCESS) return ret; *len=1; return GRIB_SUCCESS; }
static int unpack_long(grib_accessor* a, long* val, size_t *len) { grib_accessor_validity_date* self = (grib_accessor_validity_date*)a; int ret=0; long date = 0; long time = 0; long step = 0; long stepUnits = 0; long hours = 0, minutes=0, step_mins=0, tmp, tmp_hrs; if (self->year) { long year,month,day; if ((ret=grib_get_long_internal(a->parent->h, self->year,&year))!=GRIB_SUCCESS) return ret; if ((ret=grib_get_long_internal(a->parent->h, self->month,&month))!=GRIB_SUCCESS) return ret; if ((ret=grib_get_long_internal(a->parent->h, self->day,&day))!=GRIB_SUCCESS) return ret; *val=year*10000+month*100+day; return GRIB_SUCCESS; } if ((ret=grib_get_long_internal(a->parent->h, self->date,&date))!=GRIB_SUCCESS) return ret; if ((ret=grib_get_long_internal(a->parent->h, self->time,&time))!=GRIB_SUCCESS) return ret; if ((ret=grib_get_long_internal(a->parent->h, self->step,&step))!=GRIB_SUCCESS) return ret; if (self->stepUnits) { if ((ret=grib_get_long_internal(a->parent->h, self->stepUnits,&stepUnits))!=GRIB_SUCCESS) return ret; step_mins = convert_to_minutes(step, stepUnits); } minutes = time % 100; hours = time / 100; tmp = minutes + step_mins; /* add the step to our minutes */ tmp_hrs = tmp/60; /* how many hours and mins is that? */ /* tmp_mins = tmp%60; */ hours += tmp_hrs; /* increment hours */ date = grib_date_to_julian (date); /* does the new 'hours' exceed 24? if so increment julian */ while(hours>=24) { date ++; hours -= 24; } /* GRIB-29: Negative forecast time */ while(hours<0) { date--; hours += 24; } if(*len < 1) return GRIB_ARRAY_TOO_SMALL; *val = grib_julian_to_date(date); return GRIB_SUCCESS; }
static int value_count(grib_accessor* a,long* count) { grib_accessor_data_sh_unpacked *self =(grib_accessor_data_sh_unpacked*)a; int ret = 0; long sub_j= 0; long sub_k= 0; long sub_m= 0; if((ret = grib_get_long_internal(grib_handle_of_accessor(a),self->sub_j,&sub_j)) != GRIB_SUCCESS) return ret; if((ret = grib_get_long_internal(grib_handle_of_accessor(a),self->sub_k,&sub_k)) != GRIB_SUCCESS) return ret; if((ret = grib_get_long_internal(grib_handle_of_accessor(a),self->sub_m,&sub_m)) != GRIB_SUCCESS) return ret; if (sub_j != sub_k || sub_j!=sub_m ) { grib_context_log(a->context,GRIB_LOG_ERROR,"sub_j=%ld, sub_k=%ld, sub_m=%ld\n",sub_j,sub_k,sub_m); Assert ((sub_j == sub_k) && (sub_j == sub_m)); } *count=(sub_j+1)*(sub_j+2); return ret; }
static int unpack_long(grib_accessor* a, long* val, size_t *len) { int ret=0; grib_accessor_budgdate* self = (grib_accessor_budgdate*)a; long year = 0; long month = 0; long day = 0; if ((ret=grib_get_long_internal(a->parent->h, self->day,&day))!=GRIB_SUCCESS) return ret; if ((ret=grib_get_long_internal(a->parent->h, self->month,&month))!=GRIB_SUCCESS) return ret; if ((ret=grib_get_long_internal(a->parent->h, self->year,&year))!=GRIB_SUCCESS) return ret; if(*len < 1) return GRIB_WRONG_ARRAY_SIZE; val[0] = (1900 + year) * 10000 + month * 100 + day; return ret; }
static int unpack_long(grib_accessor* a, long* val, size_t *len) { int ret=GRIB_SUCCESS; long ni=0,nj=0,plpresent=0; size_t plsize=0; long* pl; int i; grib_accessor_number_of_points* self = (grib_accessor_number_of_points*)a; grib_context* c=a->context; if((ret = grib_get_long_internal(grib_handle_of_accessor(a), self->ni,&ni)) != GRIB_SUCCESS) return ret; if((ret = grib_get_long_internal(grib_handle_of_accessor(a), self->nj,&nj)) != GRIB_SUCCESS) return ret; if(self->plpresent && ((ret = grib_get_long_internal(grib_handle_of_accessor(a), self->plpresent,&plpresent)) != GRIB_SUCCESS) ) return ret; if (nj == 0) return GRIB_GEOCALCULUS_PROBLEM; if (plpresent) { /*reduced*/ plsize=nj; pl=(long*)grib_context_malloc(c,sizeof(long)*plsize); grib_get_long_array_internal(grib_handle_of_accessor(a),self->pl,pl, &plsize); *val=0; for (i=0;i<plsize;i++) *val+=pl[i]; grib_context_free(c,pl); } else { /*regular*/ *val=ni*nj; } return ret; }
static int unpack_one_time_range(grib_accessor* a, long* val, size_t *len) { grib_accessor_g2end_step* self = (grib_accessor_g2end_step*)a; int err = 0; long start_step; long unit; long coded_unit; long coded_time_range, typeOfTimeIncrement; int add_time_range = 1; /* whether we add lengthOfTimeRange */ grib_handle* h = a->parent->h; if((err = grib_get_long_internal(h,self->start_step,&start_step))) return err; if((err = grib_get_long_internal(h,self->unit,&unit))) return err; if((err = grib_get_long_internal(h,self->coded_unit,&coded_unit))) return err; if((err = grib_get_long_internal(h,self->coded_time_range, &coded_time_range))) return err; if((err = grib_get_long_internal(h,self->typeOfTimeIncrement, &typeOfTimeIncrement))) return err; err = convert_time_range(h, unit, coded_unit, &coded_time_range); if (err != GRIB_SUCCESS) return err; if (typeOfTimeIncrement == 1) { /* See GRIB-488 */ /* Note: For this case, lengthOfTimeRange is not related to step and should not be used to calculate step */ add_time_range = 0; if (is_special_expver(h)) { add_time_range = 1; } } if (add_time_range) { *val = start_step + coded_time_range; } else { *val = start_step; } 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 unpack_long(grib_accessor* a, long* val, size_t *len) { int ret=GRIB_SUCCESS; long bpv=0; long offsetBeforeData=0,offsetAfterData=0,unusedBits=0,numberOfValues; long JS=0,KS=0,MS=0,NS=0; grib_accessor_g1number_of_coded_values_sh_complex* self = (grib_accessor_g1number_of_coded_values_sh_complex*)a; if((ret = grib_get_long_internal(a->parent->h, self->bitsPerValue,&bpv)) != GRIB_SUCCESS) return ret; if((ret = grib_get_long_internal(a->parent->h, self->offsetBeforeData,&offsetBeforeData)) != GRIB_SUCCESS) return ret; if((ret = grib_get_long_internal(a->parent->h, self->offsetAfterData,&offsetAfterData)) != GRIB_SUCCESS) return ret; if((ret = grib_get_long_internal(a->parent->h, self->unusedBits,&unusedBits)) != GRIB_SUCCESS) return ret; if((ret = grib_get_long_internal(a->parent->h, self->JS,&JS)) != GRIB_SUCCESS) return ret; if((ret = grib_get_long_internal(a->parent->h, self->KS,&KS)) != GRIB_SUCCESS) return ret; if((ret = grib_get_long_internal(a->parent->h, self->MS,&MS)) != GRIB_SUCCESS) return ret; if (JS != KS || KS != MS) return GRIB_NOT_IMPLEMENTED; NS=(MS+1)*(MS+2); if ( bpv != 0 ) { *val =((offsetAfterData-offsetBeforeData)*8-unusedBits+NS*(bpv-32))/bpv; } else { if((ret = grib_get_long_internal(a->parent->h, self->numberOfValues,&numberOfValues)) != GRIB_SUCCESS) return ret; *val=numberOfValues; } return ret; }
static int unpack_long(grib_accessor* a, long* val, size_t *len) { int ret=0; grib_accessor_g1date* self = (grib_accessor_g1date*)a; long year = 0; long century = 0; long month = 0; long day = 0; if ((ret=grib_get_long_internal(a->parent->h, self->century,¢ury))!=GRIB_SUCCESS) return ret; if ((ret=grib_get_long_internal(a->parent->h, self->day,&day))!=GRIB_SUCCESS) return ret; if ((ret=grib_get_long_internal(a->parent->h, self->month,&month))!=GRIB_SUCCESS) return ret; if ((ret=grib_get_long_internal(a->parent->h, self->year,&year))!=GRIB_SUCCESS) return ret; if(*len < 1) return GRIB_WRONG_ARRAY_SIZE; *val = ((century-1)*100 + year) * 10000 + month * 100 + day; if(year == 255 && day == 255 && month >= 1 && month <= 12) { *val = month; } if(year == 255 && day != 255 && month >= 1 && month <= 12) { *val = month * 100 + day; } return GRIB_SUCCESS; }
static int unpack_double (grib_accessor* a, double* val, size_t *len) { grib_accessor_simple_packing_error* self = (grib_accessor_simple_packing_error*)a; int ret = 0; long binaryScaleFactor=0; long bitsPerValue=0; long decimalScaleFactor=0; double referenceValue=0; if((ret = grib_get_long_internal(a->parent->h, self->binaryScaleFactor,&binaryScaleFactor)) != GRIB_SUCCESS) return ret; if((ret = grib_get_long_internal(a->parent->h, self->bitsPerValue,&bitsPerValue)) != GRIB_SUCCESS) return ret; if((ret = grib_get_long_internal(a->parent->h, self->decimalScaleFactor,&decimalScaleFactor)) != GRIB_SUCCESS) return ret; if((ret = grib_get_double_internal(a->parent->h, self->referenceValue,&referenceValue)) != GRIB_SUCCESS) return ret; if (!strcmp(self->floatType,"ibm")) *val=grib_ibmfloat_error(referenceValue); else if (!strcmp(self->floatType,"ieee")) *val=grib_ieeefloat_error(referenceValue); else Assert(1==0); if (bitsPerValue!=0) *val=(*val+grib_power(binaryScaleFactor,2))*grib_power(-decimalScaleFactor,10)*0.5; if (ret == GRIB_SUCCESS) *len = 1; return ret; }
static long value_count(grib_accessor* a) { long number_of_values; grib_accessor_data_g1second_order_row_by_row_packing *self =(grib_accessor_data_g1second_order_row_by_row_packing*)a; /* Special case for when values are cleared */ /*if(a->length == 0) return 0;*/ if(grib_get_long_internal(a->parent->h,self->number_of_values,&number_of_values) != GRIB_SUCCESS) return 0; return number_of_values; }
static int unpack_long(grib_accessor* a, long* val, size_t *len) { grib_accessor_g1monthlydate* self = (grib_accessor_g1monthlydate*)a; long date = 0; grib_get_long_internal(a->parent->h, self->date,&date); date /= 100; date*=100; date+=1; *val = date; return GRIB_SUCCESS; }
static int unpack_double(grib_accessor* a, double* val, size_t *len) { grib_accessor_data_raw_packing *self =(grib_accessor_data_raw_packing*)a; unsigned char* buf = NULL; int bytes = 0; size_t nvals = 0; long inlen = grib_byte_count(a); long precision = 0; int code = GRIB_SUCCESS; if((code = grib_get_long_internal(a->parent->h,self->precision,&precision)) != GRIB_SUCCESS) return code; self->dirty=0; buf = (unsigned char*)a->parent->h->buffer->data; buf += grib_byte_offset(a); switch(precision) { case 1: bytes = 4; break; case 2: bytes = 8; break; default: return GRIB_NOT_IMPLEMENTED; break; } nvals = inlen / bytes; if(*len < nvals) return GRIB_ARRAY_TOO_SMALL; code=grib_ieee_decode_array(a->parent->h->context,buf,nvals,bytes,val); *len = nvals; return code; }
static int unpack_long(grib_accessor* a, long* val, size_t *len) { /* TODO properly calling grib_concept_evaluate_long ! */ const char *p = grib_concept_evaluate(a->parent->h,a->creator); if(!p) { if (a->creator->defaultkey) return grib_get_long_internal(a->parent->h,a->creator->defaultkey,val); return GRIB_NOT_FOUND; } *val = atol(p); *len = 1; return GRIB_SUCCESS; }
static int unpack_double_element(grib_accessor* a, size_t idx, double* val) { int ret=0; grib_accessor_data_raw_packing *self =(grib_accessor_data_raw_packing*)a; unsigned char* buf = NULL; int bytes = 0; size_t nvals = 0; long inlen = grib_byte_count(a); long pos; long precision = 0; if((ret = grib_get_long_internal(a->parent->h,self->precision,&precision)) != GRIB_SUCCESS) return ret; self->dirty=0; buf = (unsigned char*)a->parent->h->buffer->data; buf += grib_byte_offset(a); switch(precision) { case 1: bytes = 4; break; case 2: bytes = 8; break; default: return GRIB_NOT_IMPLEMENTED; break; } pos=bytes*idx; Assert(pos<=inlen); nvals = 1; buf+=pos; ret=grib_ieee_decode_array(a->parent->h->context,buf,nvals,bytes,val); return ret; }
static int pack_double(grib_accessor* a, const double* val, size_t *len) { double* values=NULL; size_t size=0; double missingValue=0; long missingValuesPresent = 0; int ret=0,i=0; grib_accessor_offset_values* self= (grib_accessor_offset_values*)a; grib_context* c=a->context; grib_handle* h=grib_handle_of_accessor(a); if (*val==0) return GRIB_SUCCESS; if((ret = grib_get_double_internal(h,self->missingValue,&missingValue)) != GRIB_SUCCESS) { return ret; } if((ret=grib_get_long_internal(h,"missingValuesPresent",&missingValuesPresent)) != GRIB_SUCCESS) { return ret; } if ( (ret=grib_get_size(h,self->values,&size)) != GRIB_SUCCESS) return ret; values=(double*)grib_context_malloc(c,size*sizeof(double)); if (!values) return GRIB_OUT_OF_MEMORY; if((ret = grib_get_double_array_internal(h,self->values,values,&size)) != GRIB_SUCCESS) { grib_context_free(c,values); return ret; } for (i=0;i<size;i++) { if (missingValuesPresent) { if (values[i]!=missingValue) values[i]+=*val; } else { values[i]+=*val; } } if((ret = grib_set_double_array_internal(h, self->values,values,size)) != GRIB_SUCCESS) return ret; grib_context_free(c,values); return GRIB_SUCCESS; }
static int unpack_long(grib_accessor* a, long* val, size_t *len) { grib_accessor_validity_time* self = (grib_accessor_validity_time*)a; int ret=0; long date = 0; long time = 0; long step = 0; long stepUnits = 0; long hours = 0, minutes=0, step_mins=0, tmp, tmp_hrs, tmp_mins; if (self->hours) { long hours,minutes; if ((ret=grib_get_long_internal(a->parent->h, self->hours,&hours))!=GRIB_SUCCESS) return ret; if ((ret=grib_get_long_internal(a->parent->h, self->minutes,&minutes))!=GRIB_SUCCESS) return ret; *val=hours*100+minutes; return GRIB_SUCCESS; } if ((ret=grib_get_long_internal(a->parent->h, self->date,&date))!=GRIB_SUCCESS) return ret; if ((ret=grib_get_long_internal(a->parent->h, self->time,&time))!=GRIB_SUCCESS) return ret; if ((ret=grib_get_long_internal(a->parent->h, self->step,&step))!=GRIB_SUCCESS) return ret; /* Seconds will always be zero. So convert to minutes */ if (self->stepUnits) { if ((ret=grib_get_long_internal(a->parent->h, self->stepUnits,&stepUnits))!=GRIB_SUCCESS) return ret; step_mins = convert_to_minutes(step, stepUnits); } minutes = time % 100; hours = time / 100; tmp = minutes + step_mins; /* add the step to our minutes */ tmp_hrs = tmp/60; /* how many hours and mins is that? */ tmp_mins = tmp%60; hours += tmp_hrs; /* increment hours */ if (hours>0) { hours = hours % 24; /* wrap round if >= 24 */ } else { /* GRIB-29: Negative forecast time */ while (hours<0) { hours += 24; } } time = hours * 100 + tmp_mins; if(*len < 1) return GRIB_ARRAY_TOO_SMALL; *val = time; return GRIB_SUCCESS; }
static int value_count(grib_accessor* a,long* count) { int err=0; grib_accessor_data_2order_packing* self = (grib_accessor_data_2order_packing*)a; long two_ordr_spd = 0; long plus1_spd = 0; grib_handle* gh = grib_handle_of_accessor(a); unsigned char* buf_size_of_groups = (unsigned char*)gh->buffer->data; long octet_start_group = 0; long offsetsection = 0; long nbits_per_lengths = 0; long pointer_of_group_size = 0; long p1 = 0; long extraValues=0; size_t i = 0; if((err=grib_get_long_internal(gh,self->two_ordr_spd, &two_ordr_spd)) != GRIB_SUCCESS) return err; if( (err=grib_get_long_internal(gh,self->plus1_spd, &plus1_spd)) != GRIB_SUCCESS) return err; if( (err=grib_get_long_internal(gh,self->width_lengths, &nbits_per_lengths)) != GRIB_SUCCESS) return err; if( (err=grib_get_long_internal(gh,self->offsetsection, &offsetsection)) != GRIB_SUCCESS) return err; if( (err=grib_get_long_internal(gh,self->octet_start_group, &octet_start_group)) != GRIB_SUCCESS) return err; if( (err=grib_get_long_internal(gh,self->p1, &p1)) != GRIB_SUCCESS) return err; if( (err=grib_get_long_internal(gh,self->extraValues, &extraValues)) != GRIB_SUCCESS) return err; p1+=extraValues*65536; buf_size_of_groups += offsetsection+(octet_start_group-1); *count = two_ordr_spd*2+plus1_spd; for(i=0;i < p1;i++) *count += grib_decode_unsigned_long(buf_size_of_groups, &pointer_of_group_size, nbits_per_lengths); return err; }
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; }