← Back to branch summary

~ubuntu-branches/ubuntu/jaunty/texlive-bin/jaunty

« back to all changes in this revision

Viewing changes to build/TeX/libs/jpeg/wrtarga.c

  • Committer: Bazaar Package Importer
  • Author(s): Norbert Preining
  • Date: 2008-06-26 23:14:59 UTC
  • mfrom: (2.1.30 intrepid)
  • Revision ID: james.westby@ubuntu.com-20080626231459-y02rjsrgtafu83yr
Tags: 2007.dfsg.2-3
http://bugs.debian.org/482915
add missing source roadmap.fig of roadmap.eps in fontinst documentation
(Closes: #482915) (urgency medium due to RC bug)
(new patch add-missing-fontinst-source)

Show diffs side-by-side

added added

removed removed

Lines of Context:
build/TeX/libs/jpeg/wrtarga.c
1
 
/*
2
 
 * wrtarga.c
3
 
 *
4
 
 * Copyright (C) 1991-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 contains routines to write output images in Targa format.
9
 
 *
10
 
 * These routines may need modification for non-Unix environments or
11
 
 * specialized applications.  As they stand, they assume output to
12
 
 * an ordinary stdio stream.
13
 
 *
14
 
 * Based on code contributed by Lee Daniel Crocker.
15
 
 */
16
 
 
17
 
#include "cdjpeg.h"             /* Common decls for cjpeg/djpeg applications */
18
 
 
19
 
#ifdef TARGA_SUPPORTED
20
 
 
21
 
 
22
 
/*
23
 
 * To support 12-bit JPEG data, we'd have to scale output down to 8 bits.
24
 
 * This is not yet implemented.
25
 
 */
26
 
 
27
 
#if BITS_IN_JSAMPLE != 8
28
 
  Sorry, this code only copes with 8-bit JSAMPLEs. /* deliberate syntax err */
29
 
#endif
30
 
 
31
 
/*
32
 
 * The output buffer needs to be writable by fwrite().  On PCs, we must
33
 
 * allocate the buffer in near data space, because we are assuming small-data
34
 
 * memory model, wherein fwrite() can't reach far memory.  If you need to
35
 
 * process very wide images on a PC, you might have to compile in large-memory
36
 
 * model, or else replace fwrite() with a putc() loop --- which will be much
37
 
 * slower.
38
 
 */
39
 
 
40
 
 
41
 
/* Private version of data destination object */
42
 
 
43
 
typedef struct {
44
 
  struct djpeg_dest_struct pub; /* public fields */
45
 
 
46
 
  char *iobuffer;               /* physical I/O buffer */
47
 
  JDIMENSION buffer_width;      /* width of one row */
48
 
} tga_dest_struct;
49
 
 
50
 
typedef tga_dest_struct * tga_dest_ptr;
51
 
 
52
 
 
53
 
LOCAL(void)
54
 
write_header (j_decompress_ptr cinfo, djpeg_dest_ptr dinfo, int num_colors)
55
 
/* Create and write a Targa header */
56
 
{
57
 
  char targaheader[18];
58
 
 
59
 
  /* Set unused fields of header to 0 */
60
 
  MEMZERO(targaheader, SIZEOF(targaheader));
61
 
 
62
 
  if (num_colors > 0) {
63
 
    targaheader[1] = 1;         /* color map type 1 */
64
 
    targaheader[5] = (char) (num_colors & 0xFF);
65
 
    targaheader[6] = (char) (num_colors >> 8);
66
 
    targaheader[7] = 24;        /* 24 bits per cmap entry */
67
 
  }
68
 
 
69
 
  targaheader[12] = (char) (cinfo->output_width & 0xFF);
70
 
  targaheader[13] = (char) (cinfo->output_width >> 8);
71
 
  targaheader[14] = (char) (cinfo->output_height & 0xFF);
72
 
  targaheader[15] = (char) (cinfo->output_height >> 8);
73
 
  targaheader[17] = 0x20;       /* Top-down, non-interlaced */
74
 
 
75
 
  if (cinfo->out_color_space == JCS_GRAYSCALE) {
76
 
    targaheader[2] = 3;         /* image type = uncompressed gray-scale */
77
 
    targaheader[16] = 8;        /* bits per pixel */
78
 
  } else {                      /* must be RGB */
79
 
    if (num_colors > 0) {
80
 
      targaheader[2] = 1;       /* image type = colormapped RGB */
81
 
      targaheader[16] = 8;
82
 
    } else {
83
 
      targaheader[2] = 2;       /* image type = uncompressed RGB */
84
 
      targaheader[16] = 24;
85
 
    }
86
 
  }
87
 
 
88
 
  if (JFWRITE(dinfo->output_file, targaheader, 18) != (size_t) 18)
89
 
    ERREXIT(cinfo, JERR_FILE_WRITE);
90
 
}
91
 
 
92
 
 
93
 
/*
94
 
 * Write some pixel data.
95
 
 * In this module rows_supplied will always be 1.
96
 
 */
97
 
 
98
 
METHODDEF(void)
99
 
put_pixel_rows (j_decompress_ptr cinfo, djpeg_dest_ptr dinfo,
100
 
                JDIMENSION rows_supplied)
101
 
/* used for unquantized full-color output */
102
 
{
103
 
  tga_dest_ptr dest = (tga_dest_ptr) dinfo;
104
 
  register JSAMPROW inptr;
105
 
  register char * outptr;
106
 
  register JDIMENSION col;
107
 
 
108
 
  inptr = dest->pub.buffer[0];
109
 
  outptr = dest->iobuffer;
110
 
  for (col = cinfo->output_width; col > 0; col--) {
111
 
    outptr[0] = (char) GETJSAMPLE(inptr[2]); /* RGB to BGR order */
112
 
    outptr[1] = (char) GETJSAMPLE(inptr[1]);
113
 
    outptr[2] = (char) GETJSAMPLE(inptr[0]);
114
 
    inptr += 3, outptr += 3;
115
 
  }
116
 
  (void) JFWRITE(dest->pub.output_file, dest->iobuffer, dest->buffer_width);
117
 
}
118
 
 
119
 
METHODDEF(void)
120
 
put_gray_rows (j_decompress_ptr cinfo, djpeg_dest_ptr dinfo,
121
 
               JDIMENSION rows_supplied)
122
 
/* used for grayscale OR quantized color output */
123
 
{
124
 
  tga_dest_ptr dest = (tga_dest_ptr) dinfo;
125
 
  register JSAMPROW inptr;
126
 
  register char * outptr;
127
 
  register JDIMENSION col;
128
 
 
129
 
  inptr = dest->pub.buffer[0];
130
 
  outptr = dest->iobuffer;
131
 
  for (col = cinfo->output_width; col > 0; col--) {
132
 
    *outptr++ = (char) GETJSAMPLE(*inptr++);
133
 
  }
134
 
  (void) JFWRITE(dest->pub.output_file, dest->iobuffer, dest->buffer_width);
135
 
}
136
 
 
137
 
 
138
 
/*
139
 
 * Write some demapped pixel data when color quantization is in effect.
140
 
 * For Targa, this is only applied to grayscale data.
141
 
 */
142
 
 
143
 
METHODDEF(void)
144
 
put_demapped_gray (j_decompress_ptr cinfo, djpeg_dest_ptr dinfo,
145
 
                   JDIMENSION rows_supplied)
146
 
{
147
 
  tga_dest_ptr dest = (tga_dest_ptr) dinfo;
148
 
  register JSAMPROW inptr;
149
 
  register char * outptr;
150
 
  register JSAMPROW color_map0 = cinfo->colormap[0];
151
 
  register JDIMENSION col;
152
 
 
153
 
  inptr = dest->pub.buffer[0];
154
 
  outptr = dest->iobuffer;
155
 
  for (col = cinfo->output_width; col > 0; col--) {
156
 
    *outptr++ = (char) GETJSAMPLE(color_map0[GETJSAMPLE(*inptr++)]);
157
 
  }
158
 
  (void) JFWRITE(dest->pub.output_file, dest->iobuffer, dest->buffer_width);
159
 
}
160
 
 
161
 
 
162
 
/*
163
 
 * Startup: write the file header.
164
 
 */
165
 
 
166
 
METHODDEF(void)
167
 
start_output_tga (j_decompress_ptr cinfo, djpeg_dest_ptr dinfo)
168
 
{
169
 
  tga_dest_ptr dest = (tga_dest_ptr) dinfo;
170
 
  int num_colors, i;
171
 
  FILE *outfile;
172
 
 
173
 
  if (cinfo->out_color_space == JCS_GRAYSCALE) {
174
 
    /* Targa doesn't have a mapped grayscale format, so we will */
175
 
    /* demap quantized gray output.  Never emit a colormap. */
176
 
    write_header(cinfo, dinfo, 0);
177
 
    if (cinfo->quantize_colors)
178
 
      dest->pub.put_pixel_rows = put_demapped_gray;
179
 
    else
180
 
      dest->pub.put_pixel_rows = put_gray_rows;
181
 
  } else if (cinfo->out_color_space == JCS_RGB) {
182
 
    if (cinfo->quantize_colors) {
183
 
      /* We only support 8-bit colormap indexes, so only 256 colors */
184
 
      num_colors = cinfo->actual_number_of_colors;
185
 
      if (num_colors > 256)
186
 
        ERREXIT1(cinfo, JERR_TOO_MANY_COLORS, num_colors);
187
 
      write_header(cinfo, dinfo, num_colors);
188
 
      /* Write the colormap.  Note Targa uses BGR byte order */
189
 
      outfile = dest->pub.output_file;
190
 
      for (i = 0; i < num_colors; i++) {
191
 
        putc(GETJSAMPLE(cinfo->colormap[2][i]), outfile);
192
 
        putc(GETJSAMPLE(cinfo->colormap[1][i]), outfile);
193
 
        putc(GETJSAMPLE(cinfo->colormap[0][i]), outfile);
194
 
      }
195
 
      dest->pub.put_pixel_rows = put_gray_rows;
196
 
    } else {
197
 
      write_header(cinfo, dinfo, 0);
198
 
      dest->pub.put_pixel_rows = put_pixel_rows;
199
 
    }
200
 
  } else {
201
 
    ERREXIT(cinfo, JERR_TGA_COLORSPACE);
202
 
  }
203
 
}
204
 
 
205
 
 
206
 
/*
207
 
 * Finish up at the end of the file.
208
 
 */
209
 
 
210
 
METHODDEF(void)
211
 
finish_output_tga (j_decompress_ptr cinfo, djpeg_dest_ptr dinfo)
212
 
{
213
 
  /* Make sure we wrote the output file OK */
214
 
  fflush(dinfo->output_file);
215
 
  if (ferror(dinfo->output_file))
216
 
    ERREXIT(cinfo, JERR_FILE_WRITE);
217
 
}
218
 
 
219
 
 
220
 
/*
221
 
 * The module selection routine for Targa format output.
222
 
 */
223
 
 
224
 
GLOBAL(djpeg_dest_ptr)
225
 
jinit_write_targa (j_decompress_ptr cinfo)
226
 
{
227
 
  tga_dest_ptr dest;
228
 
 
229
 
  /* Create module interface object, fill in method pointers */
230
 
  dest = (tga_dest_ptr)
231
 
      (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
232
 
                                  SIZEOF(tga_dest_struct));
233
 
  dest->pub.start_output = start_output_tga;
234
 
  dest->pub.finish_output = finish_output_tga;
235
 
 
236
 
  /* Calculate output image dimensions so we can allocate space */
237
 
  jpeg_calc_output_dimensions(cinfo);
238
 
 
239
 
  /* Create I/O buffer.  Note we make this near on a PC. */
240
 
  dest->buffer_width = cinfo->output_width * cinfo->output_components;
241
 
  dest->iobuffer = (char *)
242
 
    (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
243
 
                                (size_t) (dest->buffer_width * SIZEOF(char)));
244
 
 
245
 
  /* Create decompressor output buffer. */
246
 
  dest->pub.buffer = (*cinfo->mem->alloc_sarray)
247
 
    ((j_common_ptr) cinfo, JPOOL_IMAGE, dest->buffer_width, (JDIMENSION) 1);
248
 
  dest->pub.buffer_height = 1;
249
 
 
250
 
  return (djpeg_dest_ptr) dest;
251
 
}
252
 
 
253
 
#endif /* TARGA_SUPPORTED */