IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Ignore:
Timestamp:
Mar 11, 2016, 10:23:42 PM (10 years ago)
Author:
eugene
Message:

modify to pass with extremely pedantic build; force consistency for signed vs unsigned and int sizes; various relastro updates

Location:
trunk/Ohana
Files:
2 edited

Legend:

Unmodified
Added
Removed

  • trunk/Ohana

  • trunk/Ohana/src/libfits/matrix/F_uncompress_M.c

    r38989 r39457  
    44# define VERBOSE_DUMP 0
    55
    6 int gfits_distribute_gzp2 (Matrix *matrix, char *raw, int Nraw, int raw_bitpix, int *otile, int oblank, int *ztile, int zblank, float zscale, float zzero);
    7 
    8 # define ESCAPE { \
    9   fprintf (stderr, "error in %s @ line %d\n", __func__, __LINE__); \
    10   if (ztile != NULL) free (ztile); \
    11   if (optname != NULL) { \
    12     for (j = 0; j < Noptions; j++) { \
    13       free (optname[j]); \
    14       free (optvalue[j]); \
    15     } \
    16     free (optname); \
    17     free (optvalue); \
    18   } \
    19   if (out != NULL) free (out); \
    20   if (otile != NULL) free (otile); \
    21   if (ntile != NULL) free (ntile); \
    22   return (FALSE); }
    23 
    24 # define MOD_KEYWORD(ZNAME,NAME,TYPE,IN,OUT) { \
     6int gfits_distribute_gzp2 (Matrix *matrix, char *raw, unsigned long int Nraw, int raw_bitpix, int *otile, int oblank, unsigned long int *ztile, int zblank, float zscale, float zzero);
     7
     8# define ESCAPE {                                                       \
     9    fprintf (stderr, "error in %s @ line %d\n", __func__, __LINE__);    \
     10    if (ztile != NULL) free (ztile);                                    \
     11    if (optname != NULL) {                                              \
     12      int opt;                                                          \
     13      for (opt = 0; opt < Noptions; opt++) {                            \
     14        free (optname[opt]);                                            \
     15        free (optvalue[opt]);                                           \
     16      }                                                                 \
     17      free (optname);                                                   \
     18      free (optvalue);                                                  \
     19    }                                                                   \
     20    if (out != NULL) free (out);                                        \
     21    if (otile != NULL) free (otile);                                    \
     22    if (ntile != NULL) free (ntile);                                    \
     23    return (FALSE); }
     24
     25# define MOD_KEYWORD(ZNAME,NAME,TYPE,IN,OUT) {     \
    2526    if (gfits_scan (header, ZNAME, TYPE, 1, IN)) { \
    26       gfits_modify (header, NAME, TYPE, 1, OUT); \
    27     } \
     27      gfits_modify (header, NAME, TYPE, 1, OUT);   \
     28    }                                              \
    2829    gfits_delete (header, ZNAME, 1); }
    2930
    30 # define MOD_KEYWORD_ALT(ZNAME,NAME,TYPE,IN,OUT) { \
     31# define MOD_KEYWORD_ALT(ZNAME,NAME,TYPE,IN,OUT) {     \
    3132    if (gfits_scan_alt (header, ZNAME, TYPE, 1, IN)) { \
    32       gfits_modify_alt (header, NAME, TYPE, 1, OUT); \
    33     } \
     33      gfits_modify_alt (header, NAME, TYPE, 1, OUT);   \
     34    }                                                  \
    3435    gfits_delete (header, ZNAME, 1); }
    3536
    36 # define MOD_KEYWORD_REQUIRED(ZNAME,NAME,TYPE,IN,OUT) { \
    37   if (!gfits_scan (header, ZNAME, TYPE, 1, IN)) ESCAPE; \
    38   gfits_delete (header, ZNAME, 1); \
    39   gfits_modify (header, NAME, TYPE, 1, OUT); }
     37# define MOD_KEYWORD_REQUIRED(ZNAME,NAME,TYPE,IN,OUT) {         \
     38    if (!gfits_scan (header, ZNAME, TYPE, 1, IN)) ESCAPE;       \
     39    gfits_delete (header, ZNAME, 1);                            \
     40    gfits_modify (header, NAME, TYPE, 1, OUT); }
    4041
    4142int gfits_uncompress_image (Header *header, Matrix *matrix, FTable *ftable) {
    4243
     44  int status, zimage;
    4345  off_t Nzdata, Nzrows, zcol;
    44   int i, j, status, zimage, Nout, max_tile_size;
     46  unsigned long int max_tile_size;
    4547  char cmptype[80];
    4648  char zaxis[10], naxis[10], key[10], word[81], exttype[81], checksum[81], datasum[81];
    … …  
    4951  float zscale, zzero;
    5052
    51   int *ztile = NULL;
     53  unsigned long int *ztile = NULL;
    5254  int *otile = NULL;
    5355  int *ntile = NULL;
    … …  
    7779  MOD_KEYWORD_REQUIRED ("ZNAXIS",  "NAXIS",  "%d", &header->Naxes,  header->Naxes);
    7880
    79   for (i = 0; i < header->Naxes; i++) {
    80     snprintf (zaxis, 10, "ZNAXIS%d", i + 1);
    81     snprintf (naxis, 10, "NAXIS%d", i + 1);
    82     MOD_KEYWORD_REQUIRED (zaxis,  naxis,  OFF_T_FMT,  &header->Naxis[i],  header->Naxis[i]);
     81  int axis;
     82  for (axis = 0; axis < header->Naxes; axis++) {
     83    snprintf (zaxis, 10, "ZNAXIS%d", axis + 1);
     84    snprintf (naxis, 10, "NAXIS%d", axis + 1);
     85    MOD_KEYWORD_REQUIRED (zaxis,  naxis,  OFF_T_FMT,  &header->Naxis[axis],  header->Naxis[axis]);
    8386  }   
    8487
    … …  
    8689  // the actual tile size may be smaller at the edge of a dimension.  if the ZTILEn
    8790  // entries are not found, default to [Nx,1,1,...]
    88   ALLOCATE (ztile, int, header->Naxes);
    89   if (!gfits_scan (header, "ZTILE1", "%d", 1, &ztile[0])) {
     91  ALLOCATE (ztile, unsigned long int, header->Naxes);
     92  if (!gfits_scan (header, "ZTILE1", "%lu", 1, &ztile[0])) {
    9093    ztile[0] = header->Naxis[0];
    91     for (i = 1; i < header->Naxes; i++) {
    92       ztile[i] = 1;
     94    for (axis = 1; axis < header->Naxes; axis++) {
     95      ztile[axis] = 1;
    9396    }
    9497  } else {
    9598    gfits_delete (header, "ZTILE1", 1);
    96     for (i = 1; i < header->Naxes; i++) {
    97       snprintf (key, 10, "ZTILE%d", i + 1);
    98       if (!gfits_scan (header, key, "%d", 1, &ztile[i])) ESCAPE;
     99    for (axis = 1; axis < header->Naxes; axis++) {
     100      snprintf (key, 10, "ZTILE%d", axis + 1);
     101      if (!gfits_scan (header, key, "%lu", 1, &ztile[axis])) ESCAPE;
    99102      gfits_delete (header, key, 1);
    100103    }
    … …  
    199202  // find the COMPRESSED_DATA column (format should be 1PB, 1PI, 1PJ)
    200203  // is it required that this be the only column?
    201   for (i = 1; TRUE; i++) {
    202     snprintf (key, 10, "TTYPE%d", i);
     204  int colnum;
     205  for (colnum = 1; TRUE; colnum++) {
     206    snprintf (key, 10, "TTYPE%d", colnum);
    203207    if (!gfits_scan (ftable->header, key, "%s", 1, word)) ESCAPE;
    204208    if (!strcmp (word, "COMPRESSED_DATA")) break;
    205209  }
    206   zcol = i;
     210  zcol = colnum;
    207211
    208212  if (!gfits_varlength_column_define (ftable, &zdef, zcol)) ESCAPE;
    … …  
    220224  ALLOCATE (ntile, int, matrix->Naxes);
    221225  max_tile_size = 1;
    222   for (i = 0; i < matrix->Naxes; i++) {
    223     otile[i] = 0;
    224     ntile[i] = (matrix->Naxis[i] % ztile[i]) ? (matrix->Naxis[i] / ztile[i] + 1) : (matrix->Naxis[i] / ztile[i]);
    225     max_tile_size *= ztile[i];
    226 
    227     // ztile[i] is the default (or max) tile size in the i-th dimension
    228     // ntile[i] is the number of tiles in the i-th dimension
    229     // otile[i] is the current output tile counter in the i-th dimension
     226  for (axis = 0; axis < matrix->Naxes; axis++) {
     227    otile[axis] = 0;
     228    ntile[axis] = (matrix->Naxis[axis] % ztile[axis]) ? (matrix->Naxis[axis] / ztile[axis] + 1) : (matrix->Naxis[axis] / ztile[axis]);
     229    max_tile_size *= ztile[axis];
     230
     231    // ztile[axis] is the default (or max) tile size in the i-th dimension
     232    // ntile[axis] is the number of tiles in the i-th dimension
     233    // otile[axis] is the current output tile counter in the i-th dimension
    230234  }
    231235
    … …  
    254258  // fprintf (stderr, "raw_pixsize: %d, cmp_pixsize: %d, tile_pixsize: %d, raw_bitpix: %d\n", raw_pixsize, cmp_pixsize, tile_pixsize, raw_bitpix);
    255259
    256   int Nout_alloc = raw_pixsize*max_tile_size;
     260  unsigned long int Nout_alloc = raw_pixsize*max_tile_size;
    257261  ALLOCATE (out, char, Nout_alloc);
    258262
    … …  
    271275
    272276    // expected output size for this tile
    273     Nout = raw_pixsize*gfits_tile_size (matrix, otile, ztile);
     277    unsigned long Nout = raw_pixsize*gfits_tile_size (matrix, otile, ztile);
    274278
    275279    zdata = gfits_varlength_column_pointer (ftable, &zdef, row, &Nzdata);
    … …  
    297301      for (k = 0; k < 64; k++) { fprintf (stderr, "%02hhx", zdata[k]); if (k % 4 == 3) fprintf (stderr, " "); }
    298302      fprintf (stderr, "\n");
    299       fprintf (stderr, "Nout  : %d -> ", Nout);
     303      fprintf (stderr, "Nout  : %lu -> ", Nout);
    300304    }
    301305   
    … …  
    307311    if (VERBOSE_DUMP && (row == 0)) {
    308312      int k;
    309       fprintf (stderr, "%d\n", Nout);
     313      fprintf (stderr, "%lu\n", Nout);
    310314      fprintf (stderr, "unc swp: ");
    311315      for (k = 0; k < 64; k++) { fprintf (stderr, "%02hhx", out[k]); if (k % 4 == 3) fprintf (stderr, " "); }
    … …  
    315319    if (!strcasecmp(cmptype, "GZIP_1")) {
    316320      // Nout is number of pixels
    317       if (!gfits_byteswap_zdata (out, Nout * raw_pixsize, raw_pixsize)) ESCAPE;
     321      if (!gfits_byteswap_zdata (out, (off_t) (Nout * raw_pixsize), raw_pixsize)) ESCAPE;
    318322    }
    319323   
    … …  
    340344
    341345    // update the tile counters, carrying to the next dimension if needed
    342     for (j = 0; j < matrix->Naxes; j++) {
    343       otile[j] ++;
    344       if (otile[j] == ntile[j]) {
    345         otile[j] = 0;
     346    for (axis = 0; axis < matrix->Naxes; axis++) {
     347      otile[axis] ++;
     348      if (otile[axis] == ntile[axis]) {
     349        otile[axis] = 0;
    346350      } else {
    347351        break;
    … …  
    352356  FREE (ztile);
    353357  if (optname != NULL) {
    354     for (j = 0; j < Noptions; j++) {
    355       FREE (optname[j]);
    356       FREE (optvalue[j]);
     358    int opt;
     359    for (opt = 0; opt < Noptions; opt++) {
     360      FREE (optname[opt]);
     361      FREE (optvalue[opt]);
    357362    }
    358363    FREE (optname);
    … …  
    366371
    367372// bitpix is the input data size/type
    368 int gfits_distribute_data (Matrix *matrix, char *raw, int Nraw, int raw_bitpix, int *otile, int oblank, int *ztile, int zblank, float zscale, float zzero) {
    369 
    370   int i, j;
    371   int *counter = NULL;
    372   int *Ztile = NULL;
    373 
    374   ALLOCATE (counter, int, matrix->Naxes);
    375   ALLOCATE (Ztile, int, matrix->Naxes);
     373int gfits_distribute_data (Matrix *matrix, char *raw, unsigned long int Nraw, int raw_bitpix, int *otile, int oblank, unsigned long int *ztile, int zblank, float zscale, float zzero) {
     374
     375  int axis;
     376  unsigned int *counter = NULL;
     377  unsigned long int *Ztile = NULL;
     378
     379  ALLOCATE (counter, unsigned int, matrix->Naxes);
     380  ALLOCATE (Ztile, unsigned long int, matrix->Naxes);
    376381
    377382  // counter for current row in tile to copy
    378383  // true sizes of this tile (in pixels)
    379   for (i = 0; i < matrix->Naxes; i++) {
    380     counter[i] = 0;
    381     Ztile[i] = MIN ((matrix->Naxis[i] - otile[i]*ztile[i]), ztile[i]);
     384  for (axis = 0; axis < matrix->Naxes; axis++) {
     385    counter[axis] = 0;
     386    Ztile[axis] = MIN ((matrix->Naxis[axis] - otile[axis]*ztile[axis]), ztile[axis]);
    382387  }
    383388
    384389  // number of lines in the tile (in pixels)
    385   int Nline = 1;
    386   for (i = 1; i < matrix->Naxes; i++) {
    387     Nline *= Ztile[i];
     390  unsigned long int Nline = 1;
     391  for (axis = 1; axis < matrix->Naxes; axis++) {
     392    Nline *= Ztile[axis];
    388393  }
    389394
    … …  
    394399  // start = otile[0]*ztile[0] + otile[1]*ztile[1]*Naxis[0] + otile[2]*ztile[2]*Naxis[0]*Naxis[1] + ...;
    395400  // start = otile[0]*ztile[0] + Naxis[0]*(otile[1]*ztile[1] + Naxis[1]*(otile[2]*ztile[2] + ...));
    396   int start = otile[matrix->Naxes-1]*ztile[matrix->Naxes-1];
    397   for (i = matrix->Naxes - 2; i >= 0; i--) {
    398     int coord = otile[i]*ztile[i];
    399     start = start*matrix->Naxis[i] + coord;
     401  unsigned long int start = otile[matrix->Naxes-1]*ztile[matrix->Naxes-1];
     402  for (axis = matrix->Naxes - 2; axis >= 0; axis--) {
     403    unsigned long int coord = otile[axis]*ztile[axis];
     404    start = start*matrix->Naxis[axis] + coord;
    400405  }
    401406 
    402407  // pixel offset in output array relative to tile start
    403   int offset = 0;
     408  unsigned long int offset = 0;
    404409
    405410  int directCopy = (zzero == 0.0) && (zscale == 1.0);
    406411
    407412# define SCALE_AND_DIST_INT_PRINT(TYPE, SIZE) {                         \
     413    unsigned long j;                                                    \
    408414    TYPE *TILEptr = (TYPE *) &matrix->buffer[SIZE*(offset + start)];    \
    409415    for (j = 0; j < Ztile[0]; j++, TILEptr++, RAWptr++) {               \
    … …  
    418424  // this macro is used at the inner switch to run the actual loop
    419425# define SCALE_AND_DIST_INT(OTYPE, OSIZE) {                             \
     426    unsigned long j;                                                    \
    420427    OTYPE *TILEptr = (OTYPE *) &matrix->buffer[OSIZE*(offset + start)]; \
    421428    for (j = 0; j < Ztile[0]; j++, TILEptr++, RAWptr++) {               \
    … …  
    432439  // this macro is used at the inner switch to run the actual loop
    433440# define SCALE_AND_DIST_FLOAT(OTYPE, OSIZE) {                           \
     441    unsigned long j;                                                    \
    434442    OTYPE *TILEptr = (OTYPE *) &matrix->buffer[OSIZE*(offset + start)]; \
    435443    for (j = 0; j < Ztile[0]; j++, TILEptr++, RAWptr++) {               \
    … …  
    461469      case   8: SCALE_AND_DIST_INT   (char,   1); break; \
    462470      case  16: SCALE_AND_DIST_INT   (short,  2); break; \
    463       case  32: SCALE_AND_DIST_INT (int,    4); break; \
     471      case  32: SCALE_AND_DIST_INT   (int,    4); break; \
    464472      case -32: SCALE_AND_DIST_FLOAT (float,  4); break; \
    465473      case -64: SCALE_AND_DIST_FLOAT (double, 8); break; \
    … …  
    468476
    469477  // loop over lines in the tile
     478  unsigned long int i;
    470479  for (i = 0; i < Nline; i++) {
    471480    switch (raw_bitpix) {
    … …  
    479488
    480489    // update the counters, carrying to the next dimension if needed
    481     for (j = 1; j < matrix->Naxes; j++) {
    482       counter[j] ++;
    483       if (counter[j] == Ztile[j]) {
    484         counter[j] = 0;
     490    for (axis = 1; axis < matrix->Naxes; axis++) {
     491      counter[axis] ++;
     492      if (counter[axis] == Ztile[axis]) {
     493        counter[axis] = 0;
    485494      } else {
    486495        break;
    487496      }
    488497    }
    489     if (j == matrix->Naxes) assert (i == Nline - 1); // we should be done here...
     498    if (axis == matrix->Naxes) assert (i == Nline - 1); // we should be done here...
    490499
    491500    // Naxes = 3
    … …  
    495504    // determine the offset of the next line relative to the start position
    496505    offset = counter[matrix->Naxes - 1];
    497     for (j = matrix->Naxes - 2; j >= 0; j--) {
    498       offset = offset*matrix->Naxis[j] + counter[j];
     506    for (axis = matrix->Naxes - 2; axis >= 0; axis--) {
     507      offset = offset*matrix->Naxis[axis] + counter[axis];
    499508    }     
    500509  }
    … …  
    506515
    507516// bitpix is the input data size/type
    508 int gfits_distribute_gzp2 (Matrix *matrix, char *raw, int Nraw, int raw_bitpix, int *otile, int oblank, int *ztile, int zblank, float zscale, float zzero) {
    509 
    510   int i, j, k;
    511   int *counter = NULL;
    512   int *Ztile = NULL;
    513 
    514   ALLOCATE (counter, int, matrix->Naxes);
    515   ALLOCATE (Ztile, int, matrix->Naxes);
     517int gfits_distribute_gzp2 (Matrix *matrix, char *raw, unsigned long int Nraw, int raw_bitpix, int *otile, int oblank, unsigned long int *ztile, int zblank, float zscale, float zzero) {
     518  OHANA_UNUSED_PARAM(oblank);
     519  OHANA_UNUSED_PARAM(zblank);
     520  OHANA_UNUSED_PARAM(zzero);
     521  OHANA_UNUSED_PARAM(zscale);
     522
     523  int axis;
     524  unsigned int *counter = NULL;
     525  unsigned long int *Ztile = NULL;
     526
     527  ALLOCATE (counter, unsigned int, matrix->Naxes);
     528  ALLOCATE (Ztile, unsigned long int, matrix->Naxes);
    516529
    517530  // counter for current row in tile to copy
    518531  // true sizes of this tile (in pixels)
    519   for (i = 0; i < matrix->Naxes; i++) {
    520     counter[i] = 0;
    521     Ztile[i] = MIN ((matrix->Naxis[i] - otile[i]*ztile[i]), ztile[i]);
     532  for (axis = 0; axis < matrix->Naxes; axis++) {
     533    counter[axis] = 0;
     534    Ztile[axis] = MIN ((matrix->Naxis[axis] - otile[axis]*ztile[axis]), ztile[axis]);
    522535  }
    523536
    524537  // number of lines in the tile (in pixels)
    525   int Nline = 1;
    526   int Npix = matrix->Naxis[0];
    527   for (i = 1; i < matrix->Naxes; i++) {
    528     Nline *= Ztile[i];
    529     Npix  *= matrix->Naxis[i];
     538  unsigned long int Nline = 1;
     539  unsigned long int Npix = matrix->Naxis[0];
     540  for (axis = 1; axis < matrix->Naxes; axis++) {
     541    Nline *= Ztile[axis];
     542    Npix  *= matrix->Naxis[axis];
    530543  }
    531544
    … …  
    536549  // start = otile[0]*ztile[0] + otile[1]*ztile[1]*Naxis[0] + otile[2]*ztile[2]*Naxis[0]*Naxis[1] + ...;
    537550  // start = otile[0]*ztile[0] + Naxis[0]*(otile[1]*ztile[1] + Naxis[1]*(otile[2]*ztile[2] + ...));
    538   int start = otile[matrix->Naxes-1]*ztile[matrix->Naxes-1];
    539   for (i = matrix->Naxes - 2; i >= 0; i--) {
    540     int coord = otile[i]*ztile[i];
    541     start = start*matrix->Naxis[i] + coord;
     551  unsigned long int start = otile[matrix->Naxes-1]*ztile[matrix->Naxes-1];
     552  for (axis = matrix->Naxes - 2; axis >= 0; axis--) {
     553    unsigned long int coord = otile[axis]*ztile[axis];
     554    start = start*matrix->Naxis[axis] + coord;
    542555  }
    543556 
    … …  
    553566
    554567  // pixel offset in output array relative to tile start
    555   int offset = 0;
     568  unsigned long int offset = 0;
    556569
    557570  static int pass = 0;
     571  int k;
    558572  for (k = 0; k < size; k++) {
     573    unsigned long int i;
    559574    for (i = 0; i < Nline; i++) {
    560575# ifdef BYTE_SWAP     
    … …  
    564579# endif
    565580      char *rawptr = &raw[i*Ztile[0] + k*Nraw];
     581      unsigned long j;
    566582      for (j = 0; j < Ztile[0]; j++, srcptr += size, rawptr ++) {               
    567583        if (FALSE && (i == 0) && (j < 4) && (pass == 0)) {
    … …  
    574590
    575591      // update the counters, carrying to the next dimension if needed
    576       for (j = 1; j < matrix->Naxes; j++) {
    577         counter[j] ++;
    578         if (counter[j] == Ztile[j]) {
    579           counter[j] = 0;
     592      for (axis = 1; axis < matrix->Naxes; axis++) {
     593        counter[axis] ++;
     594        if (counter[axis] == Ztile[axis]) {
     595          counter[axis] = 0;
    580596        } else {
    581597          break;
    582598        }
    583599      }
    584       if (j == matrix->Naxes) assert (i == Nline - 1); // we should be done here...
     600      if (axis == matrix->Naxes) assert (i == Nline - 1); // we should be done here...
    585601
    586602      // Naxes = 3
    … …  
    590606      // determine the offset of the next line relative to the start position
    591607      offset = counter[matrix->Naxes - 1];
    592       for (j = matrix->Naxes - 2; j >= 0; j--) {
    593         offset = offset*matrix->Naxis[j] + counter[j];
     608      for (axis = matrix->Naxes - 2; axis >= 0; axis--) {
     609        offset = offset*matrix->Naxis[axis] + counter[axis];
    594610      }     
    595611    }
Note: See TracChangeset for help on using the changeset viewer.