File indexing completed on 2024-12-29 04:11:47

 /***************************************************************************
  *                                                                         *
  *   copyright : (C) 2015 C. Barth Netterfield                             *
  *                   netterfield@astro.utoronto.ca                         *
  *                                                                         *
  *   This program is free software; you can redistribute it and/or modify  *
  *   it under the terms of the GNU General Public License as published by  *
  *   the Free Software Foundation; either version 2 of the License, or     *
  *   (at your option) any later version.                                   *
  *                                                                         *
  ***************************************************************************/
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <sys/types.h>
 #include <sys/stat.h>
 #include <fcntl.h>
 #include <unistd.h>
 #include <stdint.h>
 
 #include "its.h"
 
 char *ITS_ERRORSTR[] = {"OK", "Could not open file", "Unknown file format"};
 
 
 ITSfile *ITSopen(char *filename) {
   ITSfile *its;
   char *index_filename;
   
   its = (ITSfile*) malloc(sizeof(ITSfile));
   
   its->status = ITS_OK;
   
   its->fileName = malloc (strlen(filename)+1);
   index_filename = malloc (strlen(filename)+5);
 
   sprintf(index_filename, "%s.its", filename);
   strcpy(its->fileName,filename);
     
   its->fp_data = open(filename, O_RDONLY);
   if (its->fp_data<0) {
     its->status = ITS_NOOPEN;
   free(index_filename);
   return (its);
   }
 
   its->fp_index = open(index_filename, O_RDONLY);
   free(index_filename);
   if (its->fp_index<0) {
     its->status = ITS_NOOPEN;
     return (its);
   }
 
   return (its);
 }
 
 
 void ITSclose(ITSfile *its) {
   if (its->status != ITS_NOOPEN) {
     if (its->fp_index > 0) {
       close(its->fp_index);
     }
     if (its->fp_data > 0) {
       close(its->fp_data);
     }
   }
 
   free(its->fileName);
   free(its);
 }
 
 
 /* initialize the image into a empty image, ready for use */
 /* this is essentially a constructor, and should be called on */
 /* any new its image before use! */
 void ITSInitImage(ITSimage *image) {
   image->w = image->h = image->x = image->y = 0;
   image->allocated = 0;
   image->img = NULL;
 }
 
 
 /* free any memory allocated to the its image */
 /* note: the image is still valid and can be used again */
 /* without calling ITSInitImage */
 void ITSFreeImage(ITSimage *image) {
   if (image->img) {
     free(image->img);
   }
   ITSInitImage(image);
 }
 
 
 int isITSfile(char *filename) {
   ITSfile *its;
   int is_its;
   
   its = ITSopen(filename);
   is_its = (its->status == ITS_OK);
   ITSclose(its);
   
   return (is_its);
 }
 
 int checkHeader(unsigned char *h) {
   unsigned char sw[] = {0xeb, 0x90, 0x14, 0x6f, 0x00};
   unsigned char crc = 0;
   int i;
 
   for (i=0; i<5; i++) {
     if (h[i] != sw[i]) {
       fprintf(stderr, "bad byte %d in checkHeader\n", i);
       return (0);
     }
   }
   for (i=0; i<14; i++) {
     crc ^= h[i];
   }
   if (crc != h[14]) {
     fprintf(stderr, "bad checksum in header\n");
     return 0;
   }
 
   return(1);
 }
 
 // how many frames in the file?  Check the length of the index.
 int ITSnframes(ITSfile *its) {
   off_t bytes;
   
   bytes = lseek(its->fp_index,0,SEEK_END);
   
   if (bytes<0) bytes = 0L;
 
   return (bytes/INDEX_WORD_SIZE);
 }
 
 int ITSreadimage(ITSfile *its, int frame, int i_img, ITSimage *I) {
   int nframes;
   off_t offset;
   int nr;
   uint64_t index;
   unsigned char buf_in[1024];
   unsigned short w, h;
   unsigned char ni;
   int img_size;
 
   nframes = ITSnframes(its);
   if (frame < 0) { // last frame
     frame = nframes - 1;
   }
 
   if ((frame >= nframes) || (nframes<1)) { // can't read past end;
     I->w = I->h = I->x = I->y = 0;
     return 0;
   }
 
   // First read the index file to find the index.
   offset = lseek(its->fp_index,frame*INDEX_WORD_SIZE, SEEK_SET);
   if (offset != frame*INDEX_WORD_SIZE) {
     I->w = I->h = I->x = I->y = 0;
     return 0;
   }
 
   nr = read(its->fp_index, &index, INDEX_WORD_SIZE);
   if (nr != INDEX_WORD_SIZE) {
     I->w = I->h = I->x = I->y = 0;
     return 0;
   }
 
   // Second: read the header in the data file
   offset = lseek(its->fp_data, index, SEEK_SET);
   if (offset != index) {
     I->w = I->h = I->x = I->y = 0;
     return 0;
   }
 
   nr = read(its->fp_data, buf_in, 15);
   if (nr != 15) {
     I->w = I->h = I->x = I->y = 0;
     return 0;
   }
 
   if (!checkHeader(buf_in)) {
     I->w = I->h = I->x = I->y = 0;
     return 0;
   }
 
   w = *((unsigned short *)(buf_in+9));
   h = *((unsigned short *)(buf_in+11));
   ni = *((unsigned char *)(buf_in+13));
 
   if (i_img >= ni) {
     I->w = I->h = I->x = I->y = 0;
     return 0;
   }
 
   img_size = w * h;
   if (I->allocated < img_size) {
     I->img = realloc(I->img, img_size+1);
     I->allocated = img_size;
   }
 
   // Now read in the actual image
   offset = lseek(its->fp_data, i_img*(img_size + 4), SEEK_CUR);
   if (offset>=0) {
     nr  = read(its->fp_data, &(I->x), 2);
     nr += read(its->fp_data, &(I->y), 2);
     nr += read(its->fp_data, I->img, img_size);
   }
   if ((offset<0) || (nr != img_size + 4)) {
     I->w = I->h = I->x = I->y = 0;
     return 0;
   }
 
   I->w = w;
   I->h = h;
 
   return 1;
 }