siflib/sifloader.cpp

   1
   2 #include <stdio.h>
   3 #include <stdlib.h>
   4 #include <string.h>
   5 #include "sifloader.h"
   6 #include "sifloader.fdh"
   7
   8 #define SIF_MAGICK      'SIF2'          // SIF magick and version denotation; first 4 bytes of file
   9
  10 SIFLoader::SIFLoader()
  11 {
  12         fFP = NULL;
  13 }
  14
  15 SIFLoader::~SIFLoader()
  16 {
  17         ClearIndex();
  18         if (fFP) fclose(fFP);
  19 }
  20
  21 /*
  22 void c------------------------------() {}
  23 */
  24
  25 void SIFLoader::ClearIndex()
  26 {
  27         for(int i=0;;i++)
  28         {
  29                 SIFIndexEntry *entry = (SIFIndexEntry *)fIndex.ItemAt(i);
  30                 if (!entry) break;
  31
  32                 if (entry->data) free(entry->data);
  33                 delete entry;
  34         }
  35
  36         fIndex.MakeEmpty();
  37 }
  38
  39 void SIFLoader::CloseFile()
  40 {
  41         ClearIndex();
  42
  43         if (fFP)
  44         {
  45                 fclose(fFP);
  46                 fFP = NULL;
  47         }
  48 }
  49
  50 /*
  51 void c------------------------------() {}
  52 */
  53
  54 bool SIFLoader::LoadHeader(const char *filename)
  55 {
  56 FILE *fp;
  57 uint32_t magick;
  58
  59         ClearIndex();
  60
  61         if (fFP) fclose(fFP);
  62         fp = fFP = fileopen(filename, "rb");
  63
  64         if (!fp)
  65         {
  66                 staterr("SIFLoader::LoadHeader: failed to open file '%s'", filename);
  67                 return 1;
  68         }
  69
  70         if ((magick = fgetl(fp)) != SIF_MAGICK)
  71         {
  72                 staterr("SIFLoader::LoadHeader: magick check failed--this isn't a SIF file or is wrong version?");
  73                 staterr(" (expected %08x, got %08x)", SIF_MAGICK, magick);
  74                 return 1;
  75         }
  76
  77         int nsections = fgetc(fp);
  78         stat("SIFLoader::LoadHeader: read index of %d sections", nsections);
  79
  80         for(int i=0;i<nsections;i++)
  81         {
  82                 SIFIndexEntry *entry = new SIFIndexEntry;
  83
  84                 entry->type = fgetc(fp);                // section type
  85                 entry->foffset = fgetl(fp);             // absolute offset in file
  86                 entry->length = fgetl(fp);              // length of section data
  87                 entry->data = NULL;                             // we won't load it until asked
  88
  89                 fIndex.AddItem(entry);
  90                 //stat("  - Sect%02d @ %04x", entry->type, entry->foffset);
  91         }
  92
  93         // ..leave file handle open, its ok
  94         return 0;
  95 }
  96
  97 // load into memory and return a pointer to the section of type 'type',
  98 // or NULL if the file doesn't have a section of that type.
  99 uint8_t *SIFLoader::FindSection(int type, int *length_out)
 100 {
 101         // try and find the section in the index
 102         for(int i=0;;i++)
 103         {
 104                 SIFIndexEntry *entry = (SIFIndexEntry *)fIndex.ItemAt(i);
 105                 if (!entry) break;
 106
 107                 if (entry->type == type)
 108                 {       // got it!
 109
 110                         // haven't loaded it yet? need to fetch it from file?
 111                         if (!entry->data)
 112                         {
 113                                 if (!fFP)
 114                                 {
 115                                         staterr("SIFLoader::FindSection: entry found and need to load it, but file handle closed");
 116                                         if (length_out) *length_out = 0;
 117                                         return NULL;
 118                                 }
 119
 120                                 stat("Loading SIF section %d from address %04x", type, entry->foffset);
 121
 122                                 entry->data = (uint8_t *)malloc(entry->length);
 123                                 fseek(fFP, entry->foffset, SEEK_SET);
 124                                 fread(entry->data, entry->length, 1, fFP);
 125                         }
 126
 127                         if (length_out) *length_out = entry->length;
 128                         return entry->data;
 129                 }
 130         }
 131
 132         if (length_out) *length_out = 0;
 133         return NULL;
 134 }
 135
 136 /*
 137 void c------------------------------() {}
 138 */
 139
 140 bool SIFLoader::BeginSave()
 141 {
 142         fTotalDataAdded = 0;
 143         if (fFP) { fclose(fFP); fFP = NULL; }
 144         ClearIndex();
 145         return 0;
 146 }
 147
 148 bool SIFLoader::AddSection(int type, uint8_t *data, int datalen)
 149 {
 150         SIFIndexEntry *entry = new SIFIndexEntry;
 151
 152         entry->type = type;
 153         entry->foffset = fTotalDataAdded;               // not including index tables or header, yet
 154         entry->length = datalen;
 155         entry->data = data;
 156
 157         fTotalDataAdded += datalen;
 158         fIndex.AddItem(entry);
 159         return 0;
 160 }
 161
 162 bool SIFLoader::EndSave(const char *filename)
 163 {
 164 FILE *fp;
 165
 166         fp = fileopen(filename, "wb");
 167         if (!fp)
 168         {
 169                 stat("SIFLoader::EndSave: failed to open '%s' for writing", filename);
 170                 return 1;
 171         }
 172
 173         // write header-header
 174         fputl(SIF_MAGICK, fp);
 175         fputc(fIndex.CountItems(), fp);
 176
 177         // compute fianl length of index table so we can write the correct foffsets
 178         int indexlen = 5 + (fIndex.CountItems() * 9);
 179
 180         // write index table
 181         for(int i=0;;i++)
 182         {
 183                 SIFIndexEntry *entry = (SIFIndexEntry *)fIndex.ItemAt(i);
 184                 if (!entry) break;
 185
 186                 fputc(entry->type, fp);
 187                 fputl(entry->foffset + indexlen, fp);
 188                 fputl(entry->length, fp);
 189         }
 190
 191         // save actual section data
 192         for(int i=0;;i++)
 193         {
 194                 SIFIndexEntry *entry = (SIFIndexEntry *)fIndex.ItemAt(i);
 195                 if (!entry) break;
 196
 197                 fwrite(entry->data, entry->length, 1, fp);
 198         }
 199
 200         fclose(fp);
 201         return 0;
 202 }
 203