int fitstable_open_extension(fitstable_t* tab, int ext) { if (in_memory(tab)) { fitsext_t* theext; if (ext > bl_size(tab->extensions)) { ERROR("Table has only %zu extensions, but you requested #%i", bl_size(tab->extensions), ext); return -1; } theext = bl_access(tab->extensions, ext-1); tab->table = theext->table; tab->header = theext->header; tab->rows = theext->rows; tab->extension = ext; } else { if (tab->table) { qfits_table_close(tab->table); tab->table = NULL; } assert(tab->anq); if (ext >= anqfits_n_ext(tab->anq)) { ERROR("Requested FITS extension %i in file %s, but there are only %i extensions.\n", ext, tab->fn, anqfits_n_ext(tab->anq)); return -1; } tab->table = anqfits_get_table(tab->anq, ext); if (!tab->table) { ERROR("FITS extension %i in file %s is not a table (or there was an error opening the file)", ext, tab->fn); return -1; } if (tab->header) { qfits_header_destroy(tab->header); } tab->header = anqfits_get_header(tab->anq, ext); if (!tab->header) { ERROR("Couldn't get header for FITS extension %i in file %s", ext, tab->fn); return -1; } tab->extension = ext; } return 0; }
int main(int argc, char *argv[]) { int argchar; char* infn = NULL; char* outfn = NULL; FILE* fin = NULL; FILE* fout = NULL; pl* cols; char* progname = argv[0]; int nextens; int ext; int NC; int start, size; anqfits_t* anq = NULL; qfits_table* outtable; unsigned char* buffer; cols = pl_new(16); while ((argchar = getopt (argc, argv, OPTIONS)) != -1) switch (argchar) { case 'c': pl_append(cols, optarg); break; case 'i': infn = optarg; break; case 'o': outfn = optarg; break; case '?': case 'h': printHelp(progname); return 0; default: return -1; } if (!infn || !outfn || !pl_size(cols)) { printHelp(progname); exit(-1); } fin = fopen(infn, "rb"); if (!fin) { ERROR("Failed to open input file %s: %s\n", infn, strerror(errno)); exit(-1); } fout = fopen(outfn, "wb"); if (!fout) { ERROR("Failed to open output file %s: %s\n", outfn, strerror(errno)); exit(-1); } // copy the main header exactly. anq = anqfits_open(infn); if (!anq) { ERROR("Failed to read \"%s\"", infn); exit(-1); } start = anqfits_header_start(anq, 0); size = anqfits_header_size (anq, 0); if (pipe_file_offset(fin, start, size, fout)) { ERROR("Failed to copy primary header.\n"); exit(-1); } NC = pl_size(cols); nextens = anqfits_n_ext(anq); printf("Translating %i extensions.\n", nextens); buffer = NULL; for (ext=1; ext<nextens; ext++) { int c2, c; int columns[NC]; int sizes[NC]; int offsets[NC]; int offset = 0; int off, n; int totalsize = 0; const int BLOCK=1000; qfits_table* table; qfits_header* header; qfits_header* tablehdr; if (ext%100 == 0) { printf("Extension %i.\n", ext); fflush(stdout); } if (!anqfits_is_table(anq, ext)) { ERROR("extention %i isn't a table.\n", ext); // HACK - just copy it. return -1; } table = anqfits_get_table(anq, ext); if (!table) { ERROR("failed to open table: file %s, extension %i.\n", infn, ext); return -1; } header = anqfits_get_header(anq, ext); if (!header) { ERROR("failed to read header: extension %i\n", ext); exit(-1); } outtable = qfits_table_new(outfn, QFITS_BINTABLE, 0, NC, table->nr); outtable->tab_w = 0; for (c=0; c<pl_size(cols); c++) { columns[c] = -1; } for (c=0; c<pl_size(cols); c++) { char* colname = pl_get(cols, c); qfits_col* col; c2 = fits_find_column(table, colname); if (c2 == -1) { ERROR("Extension %i: failed to find column named %s\n", ext, colname); exit(-1); } col = table->col + c2; columns[c] = c2; sizes[c] = col->atom_nb * col->atom_size; offsets[c] = offset; offset += sizes[c]; qfits_col_fill(outtable->col + c, col->atom_nb, col->atom_dec_nb, col->atom_size, col->atom_type, col->tlabel, col->tunit, col->nullval, col->tdisp, col->zero_present, col->zero, col->scale_present, col->scale, outtable->tab_w); outtable->tab_w += sizes[c]; } totalsize = offset; tablehdr = qfits_table_ext_header_default(outtable); // add any headers from the original table that aren't part of the BINTABLE extension. fits_copy_non_table_headers(tablehdr, header); qfits_header_dump(tablehdr, fout); qfits_header_destroy(tablehdr); buffer = realloc(buffer, totalsize * BLOCK); for (off=0; off<table->nr; off+=n) { if (off + BLOCK > table->nr) n = table->nr - off; else n = BLOCK; for (c=0; c<pl_size(cols); c++) qfits_query_column_seq_to_array_no_endian_swap (table, columns[c], off, n, buffer + offsets[c], totalsize); if (fwrite(buffer, totalsize, n, fout) != n) { ERROR("Error writing a block of data: ext %i: %s\n", ext, strerror(errno)); exit(-1); } } qfits_table_close(outtable); fits_pad_file(fout); qfits_header_destroy(header); qfits_table_close(table); } free(buffer); if (fclose(fout)) { ERROR("Error closing output file: %s\n", strerror(errno)); } fclose(fin); anqfits_close(anq); pl_free(cols); return 0; }
int tabsort(const char* infn, const char* outfn, const char* colname, int descending) { FILE* fin; FILE* fout; int ext, nextens; off_t start, size; void* data = NULL; int* perm = NULL; unsigned char* map = NULL; size_t mapsize = 0; anqfits_t* anq = NULL; fin = fopen(infn, "rb"); if (!fin) { SYSERROR("Failed to open input file %s", infn); return -1; } fout = fopen(outfn, "wb"); if (!fout) { SYSERROR("Failed to open output file %s", outfn); goto bailout; } // copy the main header exactly. anq = anqfits_open(infn); if (!anq) { ERROR("Failed to open \"%s\"", infn); goto bailout; } start = anqfits_header_start(anq, 0); size = anqfits_header_size (anq, 0); if (pipe_file_offset(fin, start, size, fout)) { ERROR("Failed to copy primary FITS header."); goto bailout; } nextens = anqfits_n_ext(anq); //logverb("Sorting %i extensions.\n", nextens); for (ext=1; ext<nextens; ext++) { int c; qfits_table* table; qfits_col* col; int mgap; off_t mstart; size_t msize; int atomsize; int (*sort_func)(const void*, const void*); unsigned char* tabledata; unsigned char* tablehdr; off_t hdrstart, hdrsize, datsize, datstart; int i; hdrstart = anqfits_header_start(anq, ext); hdrsize = anqfits_header_size (anq, ext); datstart = anqfits_data_start (anq, ext); datsize = anqfits_data_size (anq, ext); if (!anqfits_is_table(anq, ext)) { ERROR("Extension %i isn't a table. Skipping.\n", ext); continue; } table = anqfits_get_table(anq, ext); if (!table) { ERROR("Failed to open table: file %s, extension %i. Skipping.", infn, ext); continue; } c = fits_find_column(table, colname); if (c == -1) { ERROR("Couldn't find column named \"%s\" in extension %i. Skipping.", colname, ext); continue; } col = table->col + c; switch (col->atom_type) { case TFITS_BIN_TYPE_D: data = realloc(data, table->nr * sizeof(double)); if (descending) sort_func = compare_doubles_desc; else sort_func = compare_doubles_asc; break; case TFITS_BIN_TYPE_E: data = realloc(data, table->nr * sizeof(float)); if (descending) sort_func = compare_floats_desc; else sort_func = compare_floats_asc; break; case TFITS_BIN_TYPE_K: data = realloc(data, table->nr * sizeof(int64_t)); if (descending) sort_func = compare_int64_desc; else sort_func = compare_int64_asc; break; default: ERROR("Column %s is neither FITS type D, E, nor K. Skipping.", colname); continue; } // Grab the sort column. atomsize = fits_get_atom_size(col->atom_type); printf("Reading sort column \"%s\"\n", colname); qfits_query_column_seq_to_array(table, c, 0, table->nr, data, atomsize); // Sort it. printf("Sorting sort column\n"); perm = permuted_sort(data, atomsize, sort_func, NULL, table->nr); // mmap the input file. printf("mmapping input file\n"); start = hdrstart; size = hdrsize + datsize; get_mmap_size(start, size, &mstart, &msize, &mgap); mapsize = msize; map = mmap(NULL, mapsize, PROT_READ, MAP_SHARED, fileno(fin), mstart); if (map == MAP_FAILED) { SYSERROR("Failed to mmap input file %s", infn); map = NULL; goto bailout; } tabledata = map + (off_t)mgap + (datstart - hdrstart); tablehdr = map + (off_t)mgap; // Copy the table header without change. printf("Copying table header.\n"); if (fwrite(tablehdr, 1, hdrsize, fout) != hdrsize) { SYSERROR("Failed to write FITS table header"); goto bailout; } for (i=0; i<table->nr; i++) { unsigned char* rowptr; if (i % 100000 == 0) printf("Writing row %i\n", i); rowptr = tabledata + (off_t)(perm[i]) * (off_t)table->tab_w; if (fwrite(rowptr, 1, table->tab_w, fout) != table->tab_w) { SYSERROR("Failed to write FITS table row"); goto bailout; } } munmap(map, mapsize); map = NULL; free(perm); perm = NULL; if (fits_pad_file(fout)) { ERROR("Failed to add padding to extension %i", ext); goto bailout; } qfits_table_close(table); } free(data); if (fclose(fout)) { SYSERROR("Error closing output file"); fout = NULL; goto bailout; } fclose(fin); anqfits_close(anq); printf("Done\n"); return 0; bailout: free(data); free(perm); if (fout) fclose(fout); fclose(fin); if (map) munmap(map, mapsize); return -1; }