← Back to branch summary

~baltix/+junk/irrlicht-test

« back to all changes in this revision

Viewing changes to source/Irrlicht/libpng/contrib/pngminus/png2pnm.c

  • Committer: Mantas Kriaučiūnas
  • Date: 2011-07-18 13:06:25 UTC
  • Revision ID: mantas@akl.lt-20110718130625-c5pvifp61e7kj1ol
Included whole irrlicht SVN libraries to work around launchpad recipe issue with quilt, see https://answers.launchpad.net/launchpad/+question/165193

Show diffs side-by-side

added added

removed removed

Lines of Context:
source/Irrlicht/libpng/contrib/pngminus/png2pnm.c
 
1
/*
 
2
 *  png2pnm.c --- conversion from PNG-file to PGM/PPM-file
 
3
 *  copyright (C) 1999 by Willem van Schaik <willem@schaik.com>
 
4
 *
 
5
 *  version 1.0 - 1999.10.15 - First version.
 
6
 *
 
7
 *  Permission to use, copy, modify, and distribute this software and
 
8
 *  its documentation for any purpose and without fee is hereby granted,
 
9
 *  provided that the above copyright notice appear in all copies and
 
10
 *  that both that copyright notice and this permission notice appear in
 
11
 *  supporting documentation. This software is provided "as is" without
 
12
 *  express or implied warranty.
 
13
 */
 
14
 
 
15
#include <stdio.h>
 
16
#include <stdlib.h>
 
17
#ifdef __TURBOC__
 
18
#include <mem.h>
 
19
#include <fcntl.h>
 
20
#endif
 
21
 
 
22
#ifndef BOOL
 
23
#define BOOL unsigned char
 
24
#endif
 
25
#ifndef TRUE
 
26
#define TRUE (BOOL) 1
 
27
#endif
 
28
#ifndef FALSE
 
29
#define FALSE (BOOL) 0
 
30
#endif
 
31
 
 
32
#ifdef __TURBOC__
 
33
#define STDIN  0
 
34
#define STDOUT 1
 
35
#define STDERR 2
 
36
#endif
 
37
 
 
38
/* to make png2pnm verbose so we can find problems (needs to be before png.h) */
 
39
#ifndef PNG_DEBUG
 
40
#define PNG_DEBUG 0
 
41
#endif
 
42
 
 
43
#include "png.h"
 
44
 
 
45
/* Define png_jmpbuf() in case we are using a pre-1.0.6 version of libpng */
 
46
#ifndef png_jmpbuf
 
47
#  define png_jmpbuf(png_ptr) ((png_ptr)->jmpbuf)
 
48
#endif
 
49
 
 
50
/* function prototypes */
 
51
 
 
52
int  main (int argc, char *argv[]);
 
53
void usage ();
 
54
BOOL png2pnm (FILE *png_file, FILE *pnm_file, FILE *alpha_file, BOOL raw, BOOL alpha);
 
55
 
 
56
/*
 
57
 *  main
 
58
 */
 
59
 
 
60
int main(int argc, char *argv[])
 
61
{
 
62
  FILE *fp_rd = stdin;
 
63
  FILE *fp_wr = stdout;
 
64
  FILE *fp_al = NULL;
 
65
  BOOL raw = TRUE;
 
66
  BOOL alpha = FALSE;
 
67
  int argi;
 
68
 
 
69
  for (argi = 1; argi < argc; argi++)
 
70
  {
 
71
    if (argv[argi][0] == '-')
 
72
    {
 
73
      switch (argv[argi][1])
 
74
      {
 
75
        case 'n':
 
76
          raw = FALSE;
 
77
          break;
 
78
        case 'r':
 
79
          raw = TRUE;
 
80
          break;
 
81
        case 'a':
 
82
          alpha = TRUE;
 
83
          argi++;
 
84
          if ((fp_al = fopen (argv[argi], "wb")) == NULL)
 
85
          {
 
86
            fprintf (stderr, "PNM2PNG\n");
 
87
            fprintf (stderr, "Error:  can not create alpha-channel file %s\n", argv[argi]);
 
88
            exit (1);
 
89
          }
 
90
          break;
 
91
        case 'h':
 
92
        case '?':
 
93
          usage();
 
94
          exit(0);
 
95
          break;
 
96
        default:
 
97
          fprintf (stderr, "PNG2PNM\n");
 
98
          fprintf (stderr, "Error:  unknown option %s\n", argv[argi]);
 
99
          usage();
 
100
          exit(1);
 
101
          break;
 
102
      } /* end switch */
 
103
    }
 
104
    else if (fp_rd == stdin)
 
105
    {
 
106
      if ((fp_rd = fopen (argv[argi], "rb")) == NULL)
 
107
      {
 
108
             fprintf (stderr, "PNG2PNM\n");
 
109
            fprintf (stderr, "Error:  file %s does not exist\n", argv[argi]);
 
110
            exit (1);
 
111
      }
 
112
    }
 
113
    else if (fp_wr == stdout)
 
114
    {
 
115
      if ((fp_wr = fopen (argv[argi], "wb")) == NULL)
 
116
      {
 
117
        fprintf (stderr, "PNG2PNM\n");
 
118
        fprintf (stderr, "Error:  can not create file %s\n", argv[argi]);
 
119
        exit (1);
 
120
      }
 
121
    }
 
122
    else
 
123
    {
 
124
      fprintf (stderr, "PNG2PNM\n");
 
125
      fprintf (stderr, "Error:  too many parameters\n");
 
126
      usage();
 
127
      exit(1);
 
128
    }
 
129
  } /* end for */
 
130
 
 
131
#ifdef __TURBOC__
 
132
  /* set stdin/stdout if required to binary */
 
133
  if (fp_rd == stdin)
 
134
  {
 
135
    setmode (STDIN, O_BINARY);
 
136
  }
 
137
  if ((raw) && (fp_wr == stdout))
 
138
  {
 
139
    setmode (STDOUT, O_BINARY);
 
140
  }
 
141
#endif
 
142
 
 
143
  /* call the conversion program itself */
 
144
  if (png2pnm (fp_rd, fp_wr, fp_al, raw, alpha) == FALSE)
 
145
  {
 
146
    fprintf (stderr, "PNG2PNM\n");
 
147
    fprintf (stderr, "Error:  unsuccessful convertion of PNG-image\n");
 
148
    exit(1);
 
149
  }
 
150
 
 
151
  /* close input file */
 
152
  fclose (fp_rd);
 
153
  /* close output file */
 
154
  fclose (fp_wr);
 
155
  /* close alpha file */
 
156
  if (alpha)
 
157
    fclose (fp_al);
 
158
 
 
159
  return 0;
 
160
}
 
161
 
 
162
/*
 
163
 *  usage
 
164
 */
 
165
 
 
166
void usage()
 
167
{
 
168
  fprintf (stderr, "PNG2PNM\n");
 
169
  fprintf (stderr, "   by Willem van Schaik, 1999\n");
 
170
#ifdef __TURBOC__
 
171
  fprintf (stderr, "   for Turbo-C and Borland-C compilers\n");
 
172
#else
 
173
  fprintf (stderr, "   for Linux (and Unix) compilers\n");
 
174
#endif
 
175
  fprintf (stderr, "Usage:  png2pnm [options] <file>.png [<file>.pnm]\n");
 
176
  fprintf (stderr, "   or:  ... | png2pnm [options]\n");
 
177
  fprintf (stderr, "Options:\n");
 
178
  fprintf (stderr, "   -r[aw]   write pnm-file in binary format (P4/P5/P6) (default)\n");
 
179
  fprintf (stderr, "   -n[oraw] write pnm-file in ascii format (P1/P2/P3)\n");
 
180
  fprintf (stderr, "   -a[lpha] <file>.pgm write PNG alpha channel as pgm-file\n");
 
181
  fprintf (stderr, "   -h | -?  print this help-information\n");
 
182
}
 
183
 
 
184
/*
 
185
 *  png2pnm
 
186
 */
 
187
 
 
188
BOOL png2pnm (FILE *png_file, FILE *pnm_file, FILE *alpha_file, BOOL raw, BOOL alpha)
 
189
{
 
190
  png_struct    *png_ptr = NULL;
 
191
  png_info      *info_ptr = NULL;
 
192
  png_byte      buf[8];
 
193
  png_byte      *png_pixels = NULL;
 
194
  png_byte      **row_pointers = NULL;
 
195
  png_byte      *pix_ptr = NULL;
 
196
  png_uint_32   row_bytes;
 
197
 
 
198
  png_uint_32   width;
 
199
  png_uint_32   height;
 
200
  int           bit_depth;
 
201
  int           channels;
 
202
  int           color_type;
 
203
  int           alpha_present;
 
204
  int           row, col;
 
205
  int           ret;
 
206
  int           i;
 
207
  long          dep_16;
 
208
 
 
209
  /* read and check signature in PNG file */
 
210
  ret = fread (buf, 1, 8, png_file);
 
211
  if (ret != 8)
 
212
    return FALSE;
 
213
 
 
214
  ret = png_sig_cmp (buf, 0, 8);
 
215
  if (ret)
 
216
    return FALSE;
 
217
 
 
218
  /* create png and info structures */
 
219
 
 
220
  png_ptr = png_create_read_struct (PNG_LIBPNG_VER_STRING,
 
221
    NULL, NULL, NULL);
 
222
  if (!png_ptr)
 
223
    return FALSE;   /* out of memory */
 
224
 
 
225
  info_ptr = png_create_info_struct (png_ptr);
 
226
  if (!info_ptr)
 
227
  {
 
228
    png_destroy_read_struct (&png_ptr, NULL, NULL);
 
229
    return FALSE;   /* out of memory */
 
230
  }
 
231
 
 
232
  if (setjmp (png_jmpbuf(png_ptr)))
 
233
  {
 
234
    png_destroy_read_struct (&png_ptr, &info_ptr, NULL);
 
235
    return FALSE;
 
236
  }
 
237
 
 
238
  /* set up the input control for C streams */
 
239
  png_init_io (png_ptr, png_file);
 
240
  png_set_sig_bytes (png_ptr, 8);  /* we already read the 8 signature bytes */
 
241
 
 
242
  /* read the file information */
 
243
  png_read_info (png_ptr, info_ptr);
 
244
 
 
245
  /* get size and bit-depth of the PNG-image */
 
246
  png_get_IHDR (png_ptr, info_ptr,
 
247
    &width, &height, &bit_depth, &color_type,
 
248
    NULL, NULL, NULL);
 
249
 
 
250
  /* set-up the transformations */
 
251
 
 
252
  /* transform paletted images into full-color rgb */
 
253
  if (color_type == PNG_COLOR_TYPE_PALETTE)
 
254
    png_set_expand (png_ptr);
 
255
  /* expand images to bit-depth 8 (only applicable for grayscale images) */
 
256
  if (color_type == PNG_COLOR_TYPE_GRAY && bit_depth < 8)
 
257
    png_set_expand (png_ptr);
 
258
  /* transform transparency maps into full alpha-channel */
 
259
  if (png_get_valid (png_ptr, info_ptr, PNG_INFO_tRNS))
 
260
    png_set_expand (png_ptr);
 
261
 
 
262
#ifdef NJET
 
263
  /* downgrade 16-bit images to 8 bit */
 
264
  if (bit_depth == 16)
 
265
    png_set_strip_16 (png_ptr);
 
266
  /* transform grayscale images into full-color */
 
267
  if (color_type == PNG_COLOR_TYPE_GRAY ||
 
268
    color_type == PNG_COLOR_TYPE_GRAY_ALPHA)
 
269
    png_set_gray_to_rgb (png_ptr);
 
270
  /* only if file has a file gamma, we do a correction */
 
271
  if (png_get_gAMA (png_ptr, info_ptr, &file_gamma))
 
272
    png_set_gamma (png_ptr, (double) 2.2, file_gamma);
 
273
#endif
 
274
 
 
275
  /* all transformations have been registered; now update info_ptr data,
 
276
   * get rowbytes and channels, and allocate image memory */
 
277
 
 
278
  png_read_update_info (png_ptr, info_ptr);
 
279
 
 
280
  /* get the new color-type and bit-depth (after expansion/stripping) */
 
281
  png_get_IHDR (png_ptr, info_ptr, &width, &height, &bit_depth, &color_type,
 
282
    NULL, NULL, NULL);
 
283
 
 
284
  /* check for 16-bit files */
 
285
  if (bit_depth == 16)
 
286
  {
 
287
    raw = FALSE;
 
288
#ifdef __TURBOC__
 
289
    pnm_file->flags &= ~((unsigned) _F_BIN);
 
290
#endif
 
291
  }
 
292
 
 
293
  /* calculate new number of channels and store alpha-presence */
 
294
  if (color_type == PNG_COLOR_TYPE_GRAY)
 
295
    channels = 1;
 
296
  else if (color_type == PNG_COLOR_TYPE_GRAY_ALPHA)
 
297
    channels = 2;
 
298
  else if (color_type == PNG_COLOR_TYPE_RGB)
 
299
    channels = 3;
 
300
  else if (color_type == PNG_COLOR_TYPE_RGB_ALPHA)
 
301
    channels = 4;
 
302
  else
 
303
    channels = 0; /* should never happen */
 
304
  alpha_present = (channels - 1) % 2;
 
305
 
 
306
  /* check if alpha is expected to be present in file */
 
307
  if (alpha && !alpha_present)
 
308
  {
 
309
    fprintf (stderr, "PNG2PNM\n");
 
310
    fprintf (stderr, "Error:  PNG-file doesn't contain alpha channel\n");
 
311
    exit (1);
 
312
  }
 
313
 
 
314
  /* row_bytes is the width x number of channels x (bit-depth / 8) */
 
315
  row_bytes = png_get_rowbytes (png_ptr, info_ptr);
 
316
 
 
317
  if ((png_pixels = (png_byte *) malloc (row_bytes * height * sizeof (png_byte))) == NULL) {
 
318
    png_destroy_read_struct (&png_ptr, &info_ptr, NULL);
 
319
    return FALSE;
 
320
  }
 
321
 
 
322
  if ((row_pointers = (png_byte **) malloc (height * sizeof (png_bytep))) == NULL)
 
323
  {
 
324
    png_destroy_read_struct (&png_ptr, &info_ptr, NULL);
 
325
    free (png_pixels);
 
326
    png_pixels = NULL;
 
327
    return FALSE;
 
328
  }
 
329
 
 
330
  /* set the individual row_pointers to point at the correct offsets */
 
331
  for (i = 0; i < (height); i++)
 
332
    row_pointers[i] = png_pixels + i * row_bytes;
 
333
 
 
334
  /* now we can go ahead and just read the whole image */
 
335
  png_read_image (png_ptr, row_pointers);
 
336
 
 
337
  /* read rest of file, and get additional chunks in info_ptr - REQUIRED */
 
338
  png_read_end (png_ptr, info_ptr);
 
339
 
 
340
  /* clean up after the read, and free any memory allocated - REQUIRED */
 
341
  png_destroy_read_struct (&png_ptr, &info_ptr, (png_infopp) NULL);
 
342
 
 
343
  /* write header of PNM file */
 
344
 
 
345
  if ((color_type == PNG_COLOR_TYPE_GRAY) ||
 
346
      (color_type == PNG_COLOR_TYPE_GRAY_ALPHA))
 
347
  {
 
348
    fprintf (pnm_file, "%s\n", (raw) ? "P5" : "P2");
 
349
    fprintf (pnm_file, "%d %d\n", (int) width, (int) height);
 
350
    fprintf (pnm_file, "%ld\n", ((1L << (int) bit_depth) - 1L));
 
351
  }
 
352
  else if ((color_type == PNG_COLOR_TYPE_RGB) ||
 
353
           (color_type == PNG_COLOR_TYPE_RGB_ALPHA))
 
354
  {
 
355
    fprintf (pnm_file, "%s\n", (raw) ? "P6" : "P3");
 
356
    fprintf (pnm_file, "%d %d\n", (int) width, (int) height);
 
357
    fprintf (pnm_file, "%ld\n", ((1L << (int) bit_depth) - 1L));
 
358
  }
 
359
 
 
360
  /* write header of PGM file with alpha channel */
 
361
 
 
362
  if ((alpha) &&
 
363
      ((color_type == PNG_COLOR_TYPE_GRAY_ALPHA) ||
 
364
       (color_type == PNG_COLOR_TYPE_RGB_ALPHA)))
 
365
  {
 
366
    fprintf (alpha_file, "%s\n", (raw) ? "P5" : "P2");
 
367
    fprintf (alpha_file, "%d %d\n", (int) width, (int) height);
 
368
    fprintf (alpha_file, "%ld\n", ((1L << (int) bit_depth) - 1L));
 
369
  }
 
370
 
 
371
  /* write data to PNM file */
 
372
  pix_ptr = png_pixels;
 
373
 
 
374
  for (row = 0; row < height; row++)
 
375
  {
 
376
    for (col = 0; col < width; col++)
 
377
    {
 
378
      for (i = 0; i < (channels - alpha_present); i++)
 
379
      {
 
380
        if (raw)
 
381
          fputc ((int) *pix_ptr++ , pnm_file);
 
382
        else
 
383
          if (bit_depth == 16){
 
384
            dep_16 = (long) *pix_ptr++;
 
385
            fprintf (pnm_file, "%ld ", (dep_16 << 8) + ((long) *pix_ptr++));
 
386
          }
 
387
          else
 
388
            fprintf (pnm_file, "%ld ", (long) *pix_ptr++);
 
389
      }
 
390
      if (alpha_present)
 
391
      {
 
392
        if (!alpha)
 
393
        {
 
394
          pix_ptr++; /* alpha */
 
395
          if (bit_depth == 16)
 
396
            pix_ptr++;
 
397
        }
 
398
        else /* output alpha-channel as pgm file */
 
399
        {
 
400
          if (raw)
 
401
            fputc ((int) *pix_ptr++ , alpha_file);
 
402
          else
 
403
            if (bit_depth == 16){
 
404
              dep_16 = (long) *pix_ptr++;
 
405
              fprintf (alpha_file, "%ld ", (dep_16 << 8) + (long) *pix_ptr++);
 
406
            }  
 
407
            else
 
408
              fprintf (alpha_file, "%ld ", (long) *pix_ptr++);
 
409
        }
 
410
      } /* if alpha_present */
 
411
 
 
412
      if (!raw)
 
413
        if (col % 4 == 3)
 
414
          fprintf (pnm_file, "\n");
 
415
    } /* end for col */
 
416
 
 
417
    if (!raw)
 
418
      if (col % 4 != 0)
 
419
        fprintf (pnm_file, "\n");
 
420
  } /* end for row */
 
421
 
 
422
  if (row_pointers != (unsigned char**) NULL)
 
423
    free (row_pointers);
 
424
  if (png_pixels != (unsigned char*) NULL)
 
425
    free (png_pixels);
 
426
 
 
427
  return TRUE;
 
428
 
 
429
} /* end of source */
 
430