~baltix/+junk/irrlicht-test

« back to all changes in this revision

Viewing changes to source/Irrlicht/jpeglib/rdcolmap.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:
 
1
/*
 
2
 * rdcolmap.c
 
3
 *
 
4
 * Copyright (C) 1994-1996, Thomas G. Lane.
 
5
 * This file is part of the Independent JPEG Group's software.
 
6
 * For conditions of distribution and use, see the accompanying README file.
 
7
 *
 
8
 * This file implements djpeg's "-map file" switch.  It reads a source image
 
9
 * and constructs a colormap to be supplied to the JPEG decompressor.
 
10
 *
 
11
 * Currently, these file formats are supported for the map file:
 
12
 *   GIF: the contents of the GIF's global colormap are used.
 
13
 *   PPM (either text or raw flavor): the entire file is read and
 
14
 *      each unique pixel value is entered in the map.
 
15
 * Note that reading a large PPM file will be horrendously slow.
 
16
 * Typically, a PPM-format map file should contain just one pixel
 
17
 * of each desired color.  Such a file can be extracted from an
 
18
 * ordinary image PPM file with ppmtomap(1).
 
19
 *
 
20
 * Rescaling a PPM that has a maxval unequal to MAXJSAMPLE is not
 
21
 * currently implemented.
 
22
 */
 
23
 
 
24
#include "cdjpeg.h"             /* Common decls for cjpeg/djpeg applications */
 
25
 
 
26
#ifdef QUANT_2PASS_SUPPORTED    /* otherwise can't quantize to supplied map */
 
27
 
 
28
/* Portions of this code are based on the PBMPLUS library, which is:
 
29
**
 
30
** Copyright (C) 1988 by Jef Poskanzer.
 
31
**
 
32
** Permission to use, copy, modify, and distribute this software and its
 
33
** documentation for any purpose and without fee is hereby granted, provided
 
34
** that the above copyright notice appear in all copies and that both that
 
35
** copyright notice and this permission notice appear in supporting
 
36
** documentation.  This software is provided "as is" without express or
 
37
** implied warranty.
 
38
*/
 
39
 
 
40
 
 
41
/*
 
42
 * Add a (potentially) new color to the color map.
 
43
 */
 
44
 
 
45
LOCAL(void)
 
46
add_map_entry (j_decompress_ptr cinfo, int R, int G, int B)
 
47
{
 
48
  JSAMPROW colormap0 = cinfo->colormap[0];
 
49
  JSAMPROW colormap1 = cinfo->colormap[1];
 
50
  JSAMPROW colormap2 = cinfo->colormap[2];
 
51
  int ncolors = cinfo->actual_number_of_colors;
 
52
  int index;
 
53
 
 
54
  /* Check for duplicate color. */
 
55
  for (index = 0; index < ncolors; index++) {
 
56
    if (GETJSAMPLE(colormap0[index]) == R &&
 
57
        GETJSAMPLE(colormap1[index]) == G &&
 
58
        GETJSAMPLE(colormap2[index]) == B)
 
59
      return;                   /* color is already in map */
 
60
  }
 
61
 
 
62
  /* Check for map overflow. */
 
63
  if (ncolors >= (MAXJSAMPLE+1))
 
64
    ERREXIT1(cinfo, JERR_QUANT_MANY_COLORS, (MAXJSAMPLE+1));
 
65
 
 
66
  /* OK, add color to map. */
 
67
  colormap0[ncolors] = (JSAMPLE) R;
 
68
  colormap1[ncolors] = (JSAMPLE) G;
 
69
  colormap2[ncolors] = (JSAMPLE) B;
 
70
  cinfo->actual_number_of_colors++;
 
71
}
 
72
 
 
73
 
 
74
/*
 
75
 * Extract color map from a GIF file.
 
76
 */
 
77
 
 
78
LOCAL(void)
 
79
read_gif_map (j_decompress_ptr cinfo, FILE * infile)
 
80
{
 
81
  int header[13];
 
82
  int i, colormaplen;
 
83
  int R, G, B;
 
84
 
 
85
  /* Initial 'G' has already been read by read_color_map */
 
86
  /* Read the rest of the GIF header and logical screen descriptor */
 
87
  for (i = 1; i < 13; i++) {
 
88
    if ((header[i] = getc(infile)) == EOF)
 
89
      ERREXIT(cinfo, JERR_BAD_CMAP_FILE);
 
90
  }
 
91
 
 
92
  /* Verify GIF Header */
 
93
  if (header[1] != 'I' || header[2] != 'F')
 
94
    ERREXIT(cinfo, JERR_BAD_CMAP_FILE);
 
95
 
 
96
  /* There must be a global color map. */
 
97
  if ((header[10] & 0x80) == 0)
 
98
    ERREXIT(cinfo, JERR_BAD_CMAP_FILE);
 
99
 
 
100
  /* OK, fetch it. */
 
101
  colormaplen = 2 << (header[10] & 0x07);
 
102
 
 
103
  for (i = 0; i < colormaplen; i++) {
 
104
    R = getc(infile);
 
105
    G = getc(infile);
 
106
    B = getc(infile);
 
107
    if (R == EOF || G == EOF || B == EOF)
 
108
      ERREXIT(cinfo, JERR_BAD_CMAP_FILE);
 
109
    add_map_entry(cinfo,
 
110
                  R << (BITS_IN_JSAMPLE-8),
 
111
                  G << (BITS_IN_JSAMPLE-8),
 
112
                  B << (BITS_IN_JSAMPLE-8));
 
113
  }
 
114
}
 
115
 
 
116
 
 
117
/* Support routines for reading PPM */
 
118
 
 
119
 
 
120
LOCAL(int)
 
121
pbm_getc (FILE * infile)
 
122
/* Read next char, skipping over any comments */
 
123
/* A comment/newline sequence is returned as a newline */
 
124
{
 
125
  register int ch;
 
126
  
 
127
  ch = getc(infile);
 
128
  if (ch == '#') {
 
129
    do {
 
130
      ch = getc(infile);
 
131
    } while (ch != '\n' && ch != EOF);
 
132
  }
 
133
  return ch;
 
134
}
 
135
 
 
136
 
 
137
LOCAL(unsigned int)
 
138
read_pbm_integer (j_decompress_ptr cinfo, FILE * infile)
 
139
/* Read an unsigned decimal integer from the PPM file */
 
140
/* Swallows one trailing character after the integer */
 
141
/* Note that on a 16-bit-int machine, only values up to 64k can be read. */
 
142
/* This should not be a problem in practice. */
 
143
{
 
144
  register int ch;
 
145
  register unsigned int val;
 
146
  
 
147
  /* Skip any leading whitespace */
 
148
  do {
 
149
    ch = pbm_getc(infile);
 
150
    if (ch == EOF)
 
151
      ERREXIT(cinfo, JERR_BAD_CMAP_FILE);
 
152
  } while (ch == ' ' || ch == '\t' || ch == '\n' || ch == '\r');
 
153
  
 
154
  if (ch < '0' || ch > '9')
 
155
    ERREXIT(cinfo, JERR_BAD_CMAP_FILE);
 
156
  
 
157
  val = ch - '0';
 
158
  while ((ch = pbm_getc(infile)) >= '0' && ch <= '9') {
 
159
    val *= 10;
 
160
    val += ch - '0';
 
161
  }
 
162
  return val;
 
163
}
 
164
 
 
165
 
 
166
/*
 
167
 * Extract color map from a PPM file.
 
168
 */
 
169
 
 
170
LOCAL(void)
 
171
read_ppm_map (j_decompress_ptr cinfo, FILE * infile)
 
172
{
 
173
  int c;
 
174
  unsigned int w, h, maxval, row, col;
 
175
  int R, G, B;
 
176
 
 
177
  /* Initial 'P' has already been read by read_color_map */
 
178
  c = getc(infile);             /* save format discriminator for a sec */
 
179
 
 
180
  /* while we fetch the remaining header info */
 
181
  w = read_pbm_integer(cinfo, infile);
 
182
  h = read_pbm_integer(cinfo, infile);
 
183
  maxval = read_pbm_integer(cinfo, infile);
 
184
 
 
185
  if (w <= 0 || h <= 0 || maxval <= 0) /* error check */
 
186
    ERREXIT(cinfo, JERR_BAD_CMAP_FILE);
 
187
 
 
188
  /* For now, we don't support rescaling from an unusual maxval. */
 
189
  if (maxval != (unsigned int) MAXJSAMPLE)
 
190
    ERREXIT(cinfo, JERR_BAD_CMAP_FILE);
 
191
 
 
192
  switch (c) {
 
193
  case '3':                     /* it's a text-format PPM file */
 
194
    for (row = 0; row < h; row++) {
 
195
      for (col = 0; col < w; col++) {
 
196
        R = read_pbm_integer(cinfo, infile);
 
197
        G = read_pbm_integer(cinfo, infile);
 
198
        B = read_pbm_integer(cinfo, infile);
 
199
        add_map_entry(cinfo, R, G, B);
 
200
      }
 
201
    }
 
202
    break;
 
203
 
 
204
  case '6':                     /* it's a raw-format PPM file */
 
205
    for (row = 0; row < h; row++) {
 
206
      for (col = 0; col < w; col++) {
 
207
        R = getc(infile);
 
208
        G = getc(infile);
 
209
        B = getc(infile);
 
210
        if (R == EOF || G == EOF || B == EOF)
 
211
          ERREXIT(cinfo, JERR_BAD_CMAP_FILE);
 
212
        add_map_entry(cinfo, R, G, B);
 
213
      }
 
214
    }
 
215
    break;
 
216
 
 
217
  default:
 
218
    ERREXIT(cinfo, JERR_BAD_CMAP_FILE);
 
219
    break;
 
220
  }
 
221
}
 
222
 
 
223
 
 
224
/*
 
225
 * Main entry point from djpeg.c.
 
226
 *  Input: opened input file (from file name argument on command line).
 
227
 *  Output: colormap and actual_number_of_colors fields are set in cinfo.
 
228
 */
 
229
 
 
230
GLOBAL(void)
 
231
read_color_map (j_decompress_ptr cinfo, FILE * infile)
 
232
{
 
233
  /* Allocate space for a color map of maximum supported size. */
 
234
  cinfo->colormap = (*cinfo->mem->alloc_sarray)
 
235
    ((j_common_ptr) cinfo, JPOOL_IMAGE,
 
236
     (JDIMENSION) (MAXJSAMPLE+1), (JDIMENSION) 3);
 
237
  cinfo->actual_number_of_colors = 0; /* initialize map to empty */
 
238
 
 
239
  /* Read first byte to determine file format */
 
240
  switch (getc(infile)) {
 
241
  case 'G':
 
242
    read_gif_map(cinfo, infile);
 
243
    break;
 
244
  case 'P':
 
245
    read_ppm_map(cinfo, infile);
 
246
    break;
 
247
  default:
 
248
    ERREXIT(cinfo, JERR_BAD_CMAP_FILE);
 
249
    break;
 
250
  }
 
251
}
 
252
 
 
253
#endif /* QUANT_2PASS_SUPPORTED */