← Back to branch summary

~ubuntu-branches/ubuntu/raring/xblast-tnt-models/raring

« back to all changes in this revision

Viewing changes to debian/sprites/epmtools/epmarrange.c

  • Committer: Bazaar Package Importer
  • Author(s): Gerfried Fuchs
  • Date: 2009-02-06 09:51:25 UTC
  • Revision ID: james.westby@ubuntu.com-20090206095125-hk5bmd538fdyr5yc
Tags: 20050106-3
http://bugs.debian.org/512284
* Make use of the http://sf.net/$project/ hack in debian/watch instead of
  chosing a mirror on our own.
* Added Homepage source control field.
* Bumped Standards-Version to 3.8.0, no changes needed.
* Added rendering-sources of some models where the author doesn't accept the
  xblast team reasoning to accept the rendered images as accepted form for
  modifications. The images originally were submitted without sources,
  thanks to Bernhard R. Link for being able to offer the sources
  (closes: #512284). Urgency high as this is a RC fix targetted at lenny.
* Added copyright informations to copyright file for above mentioned models
  to clear things up.
* Fixed copyright information with respect to GPLv2 or later.

Show diffs side-by-side

added added

removed removed

Lines of Context:
debian/sprites/epmtools/epmarrange.c
 
1
/*
 
2
 * program epmarrange - arrange several epm files on a canvas
 
3
 *
 
4
 * (C) by Oliver Vogel (e-mail: vogel@ikp.uni-koeln.de)
 
5
 * April 5th, 1997
 
6
 *
 
7
 * This program is free software; you can redistribute it and/or modify
 
8
 * it under the terms of the GNU General Public Licence as by published
 
9
 * by the Free Software Foundation; either version 2; or (at your option)
 
10
 * any later version
 
11
 *
 
12
 * This program is distributed in the hope that it will entertaining,
 
13
 * but WITHOUT ANY WARRANTY; without even the implied warranty of 
 
14
 * MERCHANTABILTY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General
 
15
 * Public License for more details.
 
16
 *
 
17
 * $Id: epmarrange.c,v 1.1 1999/04/04 11:44:46 xblast Exp $
 
18
 * $Log: epmarrange.c,v $
 
19
 * Revision 1.1  1999/04/04 11:44:46  xblast
 
20
 * Initial revision
 
21
 *
 
22
 */
 
23
 
 
24
#include <stdio.h>
 
25
#include <stdlib.h>
 
26
#include <string.h>
 
27
 
 
28
/*
 
29
 * some type defintions
 
30
 */
 
31
typedef struct _epm_file {
 
32
  unsigned x, y;
 
33
  unsigned width, height;
 
34
  unsigned maxval, depth;
 
35
  unsigned npixel;
 
36
  long offset;
 
37
  char *fname;
 
38
  char *line;
 
39
  struct _epm_file * next;
 
40
} EpmFile;
 
41
 
 
42
typedef struct _epm_data {
 
43
  unsigned width, height;
 
44
  unsigned maxval, depth;
 
45
  unsigned npixel;
 
46
  char *layer;
 
47
} EpmData;
 
48
 
 
49
/*
 
50
 * local variables
 
51
 */
 
52
static char *progname;
 
53
 
 
54
/*
 
55
 * parse_input: parse the input file for epmfile names and positions
 
56
 */
 
57
#ifdef __STDC__
 
58
static EpmFile *
 
59
parse_input (char *filename) 
 
60
#else
 
61
static EpmFile *
 
62
parse_input (filename) 
 
63
  char *filename;
 
64
#endif
 
65
{
 
66
  FILE *fp;
 
67
  static char line[1024];
 
68
  static char epmname[1024];
 
69
  unsigned x, y;
 
70
  EpmFile *new, *last = NULL, *root = NULL;
 
71
 
 
72
  if ( (NULL == filename) || (0 == strcmp (filename, "-") ) ) {
 
73
    /* use stdin */
 
74
    fp = stdin;
 
75
  } else {
 
76
    if (NULL == (fp = fopen(filename, "r") ) ) {
 
77
      perror(progname);
 
78
      return NULL;
 
79
    }
 
80
  }
 
81
  
 
82
  while (NULL != fgets(line, sizeof(line), fp) ) {
 
83
    if (3 == sscanf(line, "%u %u %s", &x, &y, epmname) ) {
 
84
      if ( (NULL == (new = (EpmFile *) malloc(sizeof(EpmFile) ) ) ) ||
 
85
           (NULL == (new->fname = (char *) malloc(strlen(epmname)+1) ) ) ) {
 
86
        fprintf(stderr, "%s: alloc failed\n", progname);
 
87
        return NULL;
 
88
      }
 
89
      /* set entries */
 
90
      new->x = x;
 
91
      new->y = y;
 
92
      strcpy(new->fname, epmname);
 
93
#ifdef DEBUG
 
94
      fprintf(stderr, "EPM %s at (%u,%u)\n", new->fname, new->x, new->y);
 
95
#endif
 
96
      if (root == NULL) {
 
97
        root = last = new;
 
98
      } else {
 
99
        last->next = new;
 
100
        last = new;
 
101
      }
 
102
    }
 
103
  }
 
104
  return root;
 
105
}
 
106
 
 
107
#ifdef __STDC__
 
108
static int
 
109
check_epm (EpmFile *epm)
 
110
#else
 
111
static int
 
112
check_epm (epm)
 
113
  EpmFile *epm;
 
114
#endif
 
115
{
 
116
  FILE *fp;
 
117
  char magic[256];
 
118
 
 
119
  for (; epm != NULL; epm = epm->next) {
 
120
    /* open file */
 
121
    if (NULL == (fp = fopen(epm->fname, "r") ) ) {
 
122
      perror(progname);
 
123
      return 1;
 
124
    }
 
125
    /* read header */
 
126
    if (5 != fscanf(fp, "%s%d%d%d%d%*c", magic, &(epm->width), &(epm->height), 
 
127
                    &(epm->maxval), &(epm->depth) ) ) {
 
128
      fprintf(stderr, "%s: Failed to read epm header\n",progname);
 
129
      return 1;
 
130
    }
 
131
    /* test magic */
 
132
    if (0 != strcmp(magic,"PX")) {
 
133
      fprintf(stderr, "%s: Wrong magic word \"%s\".\n", progname, magic);
 
134
      return 1;
 
135
    }
 
136
    /* get offset of pixel data */
 
137
    epm->offset = ftell(fp);
 
138
    /* close file */
 
139
    fclose(fp);
 
140
    /* alloc line buffer */
 
141
    if (NULL == (epm->line = malloc(epm->width) ) ) {
 
142
      fprintf(stderr, "%s: alloc failed\n", progname);
 
143
      return 1;
 
144
    }
 
145
    /* set total number of pixel */
 
146
    epm->npixel = epm->width * epm->height;
 
147
  }
 
148
 
 
149
  return 0;
 
150
}
 
151
 
 
152
 
 
153
#ifdef __STDC__
 
154
static EpmData *
 
155
init_epm (EpmFile *epm)
 
156
#else
 
157
static EpmData *
 
158
init_epm (epm)
 
159
  EpmFile *epm,
 
160
#endif
 
161
{
 
162
  EpmData *new;
 
163
  unsigned w, h;
 
164
 
 
165
  if (NULL == (new = calloc(1, sizeof(EpmData) ) ) ) {
 
166
    fprintf(stderr, "%s: alloc failed\n", progname);
 
167
    return NULL;
 
168
  }
 
169
 
 
170
  for (; epm != NULL; epm = epm->next) {
 
171
    /* new width ? */
 
172
    w = epm->x + epm->width;
 
173
    if (w > new->width) {
 
174
      new->width = w;
 
175
    }
 
176
    /* new height ? */
 
177
    h = epm->y + epm->height;
 
178
    if (h > new->height) {
 
179
      new->height = h;
 
180
    }
 
181
    /* new maxval */
 
182
    if (epm->maxval > new->maxval) {
 
183
      new->maxval = epm->maxval;
 
184
    }
 
185
    /* new depth */
 
186
    if (epm->depth > new->depth) {
 
187
      new->depth = epm->depth;
 
188
    }
 
189
  }
 
190
  new->npixel = new->width * new->height;
 
191
 
 
192
  /* alloc one layer */
 
193
  if (NULL == (new->layer = malloc(new->npixel) ) ) {
 
194
    fprintf(stderr, "%s: alloc failed\n", progname);
 
195
    return NULL;
 
196
  }
 
197
 
 
198
  return new;
 
199
}
 
200
 
 
201
#ifdef __STDC__
 
202
static int
 
203
draw_one_layer (EpmData *dst,
 
204
                EpmFile *src,
 
205
                unsigned layer)
 
206
#else
 
207
static int
 
208
draw_one_layer (dst, src, layer)
 
209
  EpmData *dst;
 
210
  EpmFile *src;
 
211
  unsigned layer;
 
212
#endif
 
213
{
 
214
  FILE *fp;
 
215
  char *ptr;
 
216
  unsigned y;
 
217
 
 
218
  /* clear it first */
 
219
  memset(dst->layer, 0, src->npixel);
 
220
 
 
221
  for (; src != NULL; src = src->next) {
 
222
    if (layer < src->depth) {
 
223
      /* open src file */
 
224
      if (NULL == (fp = fopen(src->fname, "r") ) ) {
 
225
        perror(progname);
 
226
        return 1;
 
227
      }
 
228
      /* skip to layer data */
 
229
      if (0 > fseek(fp, src->offset + layer * src->npixel, SEEK_SET) ) {
 
230
        perror(progname);
 
231
        return 1;
 
232
      }
 
233
      /* draw pixels */
 
234
      ptr = dst->layer + src->x + src->y*dst->width;
 
235
      for (y=0; y<src->height; y++) {
 
236
        /* read line */
 
237
        if (src->width != fread (src->line, 1, src->width, fp) ) {
 
238
          if (feof(fp)) {
 
239
            fprintf(stderr, "%s: premature eof in file %s\n",
 
240
                    progname, src->fname);
 
241
          } else {
 
242
            perror(progname);
 
243
          }
 
244
          return 1;
 
245
        }
 
246
        /* copy to dest epm */
 
247
        memcpy (ptr, src->line, src->width);
 
248
        ptr += dst->width;
 
249
      }
 
250
      /* close file */
 
251
      fclose(fp);
 
252
    }
 
253
  }
 
254
  return 0;
 
255
}
 
256
 
 
257
#ifdef __STDC__       
 
258
static FILE *
 
259
epm_open (EpmData *epm,
 
260
          char *filename)
 
261
#else
 
262
static FILE *
 
263
epm_open (epm, filename)
 
264
  EpmData *epm;
 
265
  char *filename;
 
266
#endif
 
267
{
 
268
  FILE *fp;
 
269
 
 
270
  if ( (NULL == filename) || (0 == strcmp (filename, "-") ) ){
 
271
    fp = stdout;
 
272
  } else {
 
273
    if (NULL == (fp = fopen(filename, "w") ) ) {
 
274
      perror(progname);
 
275
      return NULL;
 
276
    }
 
277
  }
 
278
 
 
279
  /* write header */
 
280
  fprintf(fp,"PX\n");
 
281
  fprintf(fp,"%u %u %u %u\n", epm->width,epm->height,epm->maxval,epm->depth);
 
282
  
 
283
  return fp;
 
284
}
 
285
 
 
286
 
 
287
#ifdef __STDC__
 
288
static int
 
289
write_layer (FILE *fp,
 
290
             EpmData *epm)
 
291
#else
 
292
static int
 
293
write_layer (fp, epm)
 
294
  FILE *fp;
 
295
  EpmData *epm;
 
296
#endif
 
297
{
 
298
  if (epm->npixel != fwrite(epm->layer, 1, epm->npixel, fp) ) {
 
299
    perror(progname);
 
300
    return 1;
 
301
  }
 
302
 
 
303
  return 0;
 
304
}
 
305
 
 
306
 
 
307
 
 
308
/*
 
309
 * the main program
 
310
 */
 
311
 
 
312
#ifdef __STDC__
 
313
int
 
314
main (int argc,
 
315
      char *argv[])
 
316
#else
 
317
int
 
318
main (argc, argv)
 
319
  int argc;
 
320
  char *argv[];
 
321
#endif
 
322
{
 
323
  char *input  = NULL;
 
324
  char *output = NULL;
 
325
  EpmFile *epm_list;
 
326
  EpmData *new_epm;
 
327
  FILE *fp;
 
328
  int layer;
 
329
 
 
330
  /* parse commandline args */
 
331
  switch (argc) {
 
332
    /* correct number */
 
333
  case 3:
 
334
    output   = argv[2];
 
335
  case 2:
 
336
    input    = argv[1];
 
337
  case 1:
 
338
    progname = argv[0];
 
339
    break;
 
340
 
 
341
  default:
 
342
    /* print usage message */
 
343
    fprintf(stderr, "usage: %s [datafile [outputfile]]\n", argv[0]);
 
344
    return 1;
 
345
  }
 
346
  /* inits */
 
347
  if (NULL == (epm_list = parse_input(input) ) ) {
 
348
    return 1;
 
349
  }
 
350
  if (check_epm (epm_list) ){
 
351
    return 1;
 
352
  }
 
353
  if (NULL == (new_epm = init_epm(epm_list) ) ) {
 
354
    return 1;
 
355
  }
 
356
  /* open output file */
 
357
  if (NULL == (fp = epm_open(new_epm, output) ) ) {
 
358
    return 1;
 
359
  }
 
360
  for (layer = 0; layer < new_epm->depth; layer++) {
 
361
    if (draw_one_layer(new_epm, epm_list, layer) ) {
 
362
      return 1;
 
363
    }
 
364
    if (write_layer(fp, new_epm) ) {
 
365
      return 1;
 
366
    }
 
367
  }
 
368
  fclose(fp);
 
369
 
 
370
  return 0;
 
371
}
 
372