fileSwapper.cpp

   1 /*
   2  *  fileSwapper.cpp
   3  *  openc2e
   4  *
   5  *  Created by Alyssa Milburn on Fri Jul 23 2004.
   6  *  Copyright (c) 2004 Alyssa Milburn. All rights reserved.
   7  *
   8  *  This library is free software; you can redistribute it and/or
   9  *  modify it under the terms of the GNU Lesser General Public
  10  *  License as published by the Free Software Foundation; either
  11  *  version 2 of the License, or (at your option) any later version.
  12  *
  13  *  This library is distributed in the hope that it will be useful,
  14  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16  *  Lesser General Public License for more details.
  17  *
  18  */
  19
  20 #include "fileSwapper.h"
  21 #include <fstream>
  22 #include "blkImage.h"
  23 #include "c16Image.h"
  24 #include "openc2e.h"
  25
  26 void fileSwapper::convertsprite(s16Image &img, std::string dest) {
  27         std::ofstream out(dest.c_str());
  28         assert(out.is_open());
  29
  30         img.offsets = new unsigned int[img.m_numframes];
  31
  32         // okay, now we get the exciting bit, we get to write it to disk!
  33         // step one: calculate offsets
  34         unsigned int offset = 6 + (8 * img.m_numframes);
  35         for (unsigned int i = 0; i < img.m_numframes; i++) {
  36                 img.offsets[i] = offset;
  37                 offset += img.widths[i] * img.heights[i] * 2;
  38         }
  39
  40         // step two: write data
  41         img.writeHeader(out);
  42         for (unsigned int i = 0; i < img.m_numframes; i++) {
  43                 out.write((char *)img.buffers[i], img.widths[i] * img.heights[i] * 2);
  44         }
  45
  46         delete[] img.offsets;
  47 }
  48
  49 void fileSwapper::convertc16(std::string src, std::string dest) {
  50         mmapifstream *in = new mmapifstream(src.c_str()); // auto-freed by the c16Image below
  51         if (!in->is_open()) { delete in; return; }
  52
  53         // okay. read the damn file.
  54         c16Image img(in, src);
  55
  56         shared_ptr<creaturesImage> imgcopy = img.mutableCopy();
  57         s16Image *i = dynamic_cast<s16Image *>(imgcopy.get());
  58         assert(i);
  59
  60         convertsprite(*i, dest);
  61 }
  62
  63 void fileSwapper::converts16(std::string src, std::string dest) {
  64         std::ifstream in(src.c_str());
  65         if (!in.is_open()) return;
  66
  67         // okay. read the damn file.
  68         s16Image img;
  69         img.readHeader(in);
  70
  71         img.buffers = new void *[img.m_numframes];
  72
  73         for (unsigned int i = 0; i < img.m_numframes; i++) {
  74                 img.buffers[i] = new unsigned short[img.widths[i] * img.heights[i]];
  75                 in.seekg(img.offsets[i], std::ios::beg);
  76                 in.read((char *)img.buffers[i], (img.widths[i] * img.heights[i] * 2));
  77                 for (unsigned int k = 0; k < (unsigned int) (img.widths[i] * img.heights[i]); k++) {
  78                         ((unsigned short *)img.buffers[i])[k] = swapEndianShort(((unsigned short *)img.buffers[i])[k]);
  79                 }
  80         }
  81         delete[] img.offsets;
  82
  83         convertsprite(img, dest);
  84 }
  85
  86 void fileSwapper::convertblk(std::string src, std::string dest) {
  87         std::ifstream in(src.c_str());
  88         if (!in.is_open()) return;
  89         std::ofstream out(dest.c_str());
  90         assert(out.is_open());
  91
  92         // okay. read the damn file.
  93         blkImage img;
  94         img.readHeader(in);
  95
  96         img.buffers = new void *[img.m_numframes];
  97
  98         for (unsigned int i = 0; i < img.m_numframes; i++) {
  99                 in.seekg(img.offsets[i], std::ios::beg);
 100                 img.buffers[i] = new uint16[128 * 128];
 101                 in.read((char *)img.buffers[i], 128 * 128 * 2);
 102                 for (unsigned int k = 0; k < 128 * 128; k++) {
 103                         ((unsigned short *)img.buffers[i])[k] = swapEndianShort(((unsigned short *)img.buffers[i])[k]);
 104                 }
 105         }
 106
 107         // okay, now we get the exciting bit, we get to write it to disk!
 108         // step one: calculate offsets
 109         unsigned int offset = 10 + (8 * img.m_numframes);
 110         for (unsigned int i = 0; i < img.m_numframes; i++) {
 111                 img.offsets[i] = offset;
 112                 offset += (128 * 128 * 2);
 113         }
 114
 115         // step two: write data
 116         img.writeHeader(out);
 117         for (unsigned int i = 0; i < img.m_numframes; i++) {
 118                 out.write((char *)img.buffers[i], 128 * 128 * 2);
 119         }
 120
 121         for (unsigned int i = 0; i < img.m_numframes; i++) {
 122                 delete[] (uint16 *)img.buffers[i];
 123         }
 124 }
 125 /* vim: set noet: */