splitshp.cc

Go to the documentation of this file.

/*
Copyright (C) 2001  The Exult Team

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.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
*/

#ifdef HAVE_CONFIG_H
#  include <config.h>
#endif

#include <iostream>

#ifndef ALPHA_LINUX_CXX
#  include <cstdio>
#  include <cstring>
#  include <string>
#endif

#include "exult_types.h"


using std::cout;
using std::endl;
using std::cerr;
using std::string;
using std::strlen;
using std::strrchr;
using std::strcpy;
using std::memcpy;
using std::exit;

struct u7frame {
  bool tile;
  uint32 datalen;
  uint8 *data;
};

struct u7shape {
  int num_frames;
  struct u7frame *frames;
};

unsigned int read1(FILE *f)
{
  unsigned char b0;
  b0 = fgetc(f);
  return b0;
}

unsigned int read2(FILE *f)
{
  unsigned char b0, b1;
  b0 = fgetc(f);
  b1 = fgetc(f);
  return (b0 + (b1<<8));
}

signed int read2signed(FILE *f)
{
  unsigned char b0, b1;
  signed int i0;
  b0 = fgetc(f);
  b1 = fgetc(f);
  i0 = b0 + (b1<<8);
  if (i0 >= 32768) { i0 -= 65536; }
  return (i0);
}

unsigned int read4(FILE *f)
{
  unsigned char b0, b1, b2, b3;
  b0 = fgetc(f);
  b1 = fgetc(f);
  b2 = fgetc(f);
  b3 = fgetc(f);
  return (b0 + (b1<<8) + (b2<<16) + (b3<<24));
}

void write4(FILE *f, unsigned int b)
{
  fputc(b & 0xFF, f);
  fputc((b >> 8) & 0xFF, f);
  fputc((b >> 16) & 0xFF, f);
  fputc((b >> 24) & 0xFF, f);
}

char* framefilename(char * shapefilename, int frame)
{
  char *fn = new char[strlen(shapefilename)+5];  //_xxx\0
  char *dot = strrchr(shapefilename, '.');
#ifdef WIN32
  char *slash = strrchr(shapefilename, '\\');
#else
  char *slash = strrchr(shapefilename, '/');
#endif
  int dotpos;

  if (dot == 0 || slash > dot)
    dotpos = strlen(shapefilename);
  else
    dotpos = dot - shapefilename;

  memcpy(fn, shapefilename, dotpos);
  sprintf(fn + dotpos, "_%03i", frame);
  strcpy(fn + dotpos + 4, shapefilename + dotpos);

  return fn;
}

void split_shape(char* filename)
{
  FILE *shpfile, *framefile;
  int file_size, shape_size, hdr_size;
  int frame_offset, next_frame_offset;
  int num_frames;
  int datalen;
  uint8 *data;
  char *framename;
  int i;
  
  shpfile = fopen (filename, "rb");
  if (!shpfile) {
    cerr << "Can't open " << filename << endl;
    return;
  }
  fseek(shpfile, 0, SEEK_END);
  file_size = ftell(shpfile);
  fseek(shpfile, 0, SEEK_SET);
  
  shape_size = read4(shpfile);
  
  if(file_size!=shape_size) { /* 8x8 tile */
    num_frames = file_size/64;
    fseek(shpfile, 0, SEEK_SET);    /* Return to start of file */
    cout << "num_frames = " << num_frames << endl;
    data = new uint8[64];
    for(i=0; i<num_frames; i++) {
      framename = framefilename(filename, i);
      cout << "writing " << framename << "..." << endl;
      framefile = fopen(framename, "wb");
      fread(data, 1, 64, shpfile);
      fwrite(data, 1, 64, framefile);
      fclose(framefile);
      delete[] framename;
    }
    delete[] data;
  } else {
    hdr_size = read4(shpfile);
    num_frames = (hdr_size-4)/4;
    
    cout << "num_frames = "<< num_frames << endl;
    
    for(i=0; i<num_frames; i++) {
      framename = framefilename(filename, i);
      cout << "writing " << framename << "..." << endl;
      framefile = fopen(framename, "wb");

      // Go to where frame offset is stored
      fseek(shpfile, (i+1)*4, SEEK_SET);
      frame_offset = read4(shpfile);

      if (i+1 < num_frames)
        next_frame_offset = read4(shpfile);
      else
        next_frame_offset = shape_size;

      fseek(shpfile, frame_offset, SEEK_SET);
      datalen = next_frame_offset - frame_offset;

      write4(framefile, datalen+8);
      write4(framefile, 8);

      data = new uint8[datalen];
      fread(data, 1, datalen, shpfile);
      fwrite(data, 1, datalen, framefile);
      fclose(framefile);
      delete[] framename;
      delete[] data;
    }
  }
  cout << "done" << endl;

  fclose(shpfile);
}

void merge_frames(char *shapefile, char** framefiles, int numframefiles)
{
  FILE *shpfile, *framefile;
  int i;
  bool tiles = false;
  int file_size, shape_size, hdr_size, frame_size;
  int total_size;
  uint8 *data;

  shpfile = fopen(shapefile, "wb");

  total_size = 4 + 4*numframefiles;

  for (i=0; i<numframefiles; i++) {
    framefile = fopen(framefiles[i], "rb");

    cout << "reading " << framefiles[i] << "..." << endl;
    
    fseek(framefile, 0, SEEK_END);
    file_size = ftell(framefile);
    fseek(framefile, 0, SEEK_SET);
    shape_size = read4(framefile);

    if (file_size != shape_size) { // 8x8 tile
      if (i > 0 && !tiles) {
        cout << "Error: can't mix 8x8 tiles and non-tile shapes!" << endl;
        exit(1);
      }

      tiles = true;

      fseek(framefile, 0, SEEK_SET);
      fseek(shpfile, 64*i, SEEK_SET);

      data = new uint8[64];

      fread(data, 1, 64, framefile);
      fwrite(data, 1, 64, shpfile);
      fclose(framefile);

      delete [] data;
    } else {
      if (tiles) {
        cout << "Error: can't mix 8x8 tiles and non-tile shapes!" << endl;
        exit(1);
      }

      hdr_size = read4(framefile);
      
      if (hdr_size > 8) {
        frame_size = read4(framefile);
        frame_size -= hdr_size;
      } else {
        frame_size = shape_size - hdr_size;
      }

      data = new uint8[frame_size];
      fseek(framefile, hdr_size, SEEK_SET);
      fread(data, 1, frame_size, framefile);
      fclose(framefile);

      fseek(shpfile, 4 + (i*4), SEEK_SET);
      write4(shpfile, total_size);
      fseek(shpfile, total_size, SEEK_SET);
      fwrite(data, 1, frame_size, shpfile);

      total_size += frame_size;
      delete [] data;
    }
  }

  if (!tiles) {
    fseek(shpfile, 0, SEEK_SET);
    write4(shpfile, total_size);
  }

  cout << "done" << endl;

  fclose(shpfile);
}

int main(int argc, char *argv[])
{
  char* shapefile;
  int numframefiles;
  char* framefiles[255];
  u7shape* sh;
  
  if (argc < 2) {
    cout << "Usage: To split: splitshp [shape file]" << endl
           << "     or to pack: splitshp [shape file] [frame files]" << endl;
    return 0;
  }
  
  shapefile = argv[1];

  if (argc > 2) {
    numframefiles = argc - 2;
    for (int i=0; i<numframefiles; i++)
      framefiles[i] = argv[i+2];
    merge_frames(shapefile, framefiles, numframefiles);
  } else {
    split_shape(shapefile);
  }

  return 0;
}

---