]>
Commit | Line | Data |
---|---|---|
cfb0ab24 | 1 | /* |
71fe22b7 | 2 | * "$Id: raster.c,v 1.8 2000/01/04 13:45:36 mike Exp $" |
cfb0ab24 | 3 | * |
4 | * Raster file routines for the Common UNIX Printing System (CUPS). | |
5 | * | |
71fe22b7 | 6 | * Copyright 1997-2000 by Easy Software Products. |
cfb0ab24 | 7 | * |
8 | * These coded instructions, statements, and computer programs are the | |
9 | * property of Easy Software Products and are protected by Federal | |
10 | * copyright law. Distribution and use rights for the CUPS Raster source | |
11 | * files are outlined in the GNU Library General Public License, located | |
12 | * in the "pstoraster" directory. If this file is missing or damaged | |
13 | * please contact Easy Software Products at: | |
14 | * | |
15 | * Attn: CUPS Licensing Information | |
16 | * Easy Software Products | |
8cb60b06 | 17 | * 44141 Airport View Drive, Suite 204 |
cfb0ab24 | 18 | * Hollywood, Maryland 20636-3111 USA |
19 | * | |
20 | * Voice: (301) 373-9603 | |
21 | * EMail: cups-info@cups.org | |
22 | * WWW: http://www.cups.org | |
23 | * | |
b87e43e9 | 24 | * This code and any derivative of it may be used and distributed |
25 | * freely under the terms of the GNU General Public License when | |
26 | * used with GNU Ghostscript or its derivatives. Use of the code | |
27 | * (or any derivative of it) with software other than GNU | |
28 | * GhostScript (or its derivatives) is governed by the CUPS license | |
29 | * agreement. | |
30 | * | |
cfb0ab24 | 31 | * Contents: |
32 | * | |
58ec2a95 | 33 | * cupsRasterClose() - Close a raster stream. |
34 | * cupsRasterOpen() - Open a raster stream. | |
35 | * cupsRasterReadHeader() - Read a raster page header. | |
36 | * cupsRasterReadPixels() - Read raster pixels. | |
37 | * cupsRasterWriteHeader() - Write a raster page header. | |
38 | * cupsRasterWritePixels() - Write raster pixels. | |
cfb0ab24 | 39 | */ |
40 | ||
41 | /* | |
42 | * Include necessary headers... | |
43 | */ | |
44 | ||
58ec2a95 | 45 | #include "raster.h" |
46 | #include <stdio.h> | |
47 | #include <stdlib.h> | |
1ff56f81 | 48 | #include <errno.h> |
58ec2a95 | 49 | |
50 | #if defined(WIN32) || defined(__EMX__) | |
51 | # include <io.h> | |
52 | #else | |
53 | # include <unistd.h> | |
54 | #endif /* WIN32 || __EMX__ */ | |
55 | ||
56 | ||
57 | /* | |
58 | * 'cupsRasterClose()' - Close a raster stream. | |
59 | */ | |
60 | ||
61 | void | |
62 | cupsRasterClose(cups_raster_t *r) /* I - Stream to close */ | |
63 | { | |
64 | if (r != NULL) | |
65 | free(r); | |
66 | } | |
67 | ||
68 | ||
69 | /* | |
70 | * 'cupsRasterOpen()' - Open a raster stream. | |
71 | */ | |
72 | ||
73 | cups_raster_t * /* O - New stream */ | |
74 | cupsRasterOpen(int fd, /* I - File descriptor */ | |
75 | cups_mode_t mode) /* I - Mode */ | |
76 | { | |
77 | cups_raster_t *r; /* New stream */ | |
78 | ||
79 | ||
80 | if ((r = calloc(sizeof(cups_raster_t), 1)) == NULL) | |
81 | return (NULL); | |
82 | ||
83 | r->fd = fd; | |
84 | r->mode = mode; | |
85 | ||
86 | if (mode == CUPS_RASTER_READ) | |
87 | { | |
88 | /* | |
89 | * Open for read - get sync word... | |
90 | */ | |
91 | ||
92 | if (read(fd, &(r->sync), sizeof(r->sync)) < sizeof(r->sync)) | |
93 | { | |
94 | free(r); | |
95 | return (NULL); | |
96 | } | |
97 | ||
98 | if (r->sync != CUPS_RASTER_SYNC && | |
99 | r->sync != CUPS_RASTER_REVSYNC) | |
100 | { | |
101 | free(r); | |
102 | return (NULL); | |
103 | } | |
104 | } | |
105 | else | |
106 | { | |
107 | /* | |
108 | * Open for write - put sync word... | |
109 | */ | |
110 | ||
111 | r->sync = CUPS_RASTER_SYNC; | |
112 | if (write(fd, &(r->sync), sizeof(r->sync)) < sizeof(r->sync)) | |
113 | { | |
114 | free(r); | |
115 | return (NULL); | |
116 | } | |
117 | } | |
118 | ||
119 | return (r); | |
120 | } | |
121 | ||
122 | ||
123 | /* | |
124 | * 'cupsRasterReadHeader()' - Read a raster page header. | |
125 | */ | |
126 | ||
127 | unsigned /* O - 1 on success, 0 on fail */ | |
128 | cupsRasterReadHeader(cups_raster_t *r, /* I - Raster stream */ | |
129 | cups_page_header_t *h) /* I - Pointer to header data */ | |
130 | { | |
131 | int len; /* Number of words to swap */ | |
132 | union swap_s /* Swapping structure */ | |
133 | { | |
134 | unsigned char b[4]; | |
135 | unsigned v; | |
136 | } *s; | |
137 | ||
138 | ||
139 | if (r == NULL || r->mode != CUPS_RASTER_READ) | |
140 | return (0); | |
141 | ||
53161b68 | 142 | if (cupsRasterReadPixels(r, (unsigned char *)h, sizeof(cups_page_header_t)) < |
143 | sizeof(cups_page_header_t)) | |
58ec2a95 | 144 | return (0); |
145 | ||
146 | if (r->sync == CUPS_RASTER_REVSYNC) | |
147 | for (len = (sizeof(cups_page_header_t) - 256) / 4, | |
148 | s = (union swap_s *)&(h->AdvanceDistance); | |
149 | len > 0; | |
150 | len --, s ++) | |
151 | s->v = (((((s->b[3] << 8) | s->b[2]) << 8) | s->b[1]) << 8) | s->b[0]; | |
152 | ||
153 | return (1); | |
154 | } | |
155 | ||
156 | ||
157 | /* | |
158 | * 'cupsRasterReadPixels()' - Read raster pixels. | |
159 | */ | |
160 | ||
161 | unsigned /* O - Number of bytes read */ | |
162 | cupsRasterReadPixels(cups_raster_t *r, /* I - Raster stream */ | |
163 | unsigned char *p, /* I - Pointer to pixel buffer */ | |
164 | unsigned len) /* I - Number of bytes to read */ | |
165 | { | |
53161b68 | 166 | int bytes; /* Bytes read */ |
167 | unsigned remaining; /* Bytes remaining */ | |
168 | ||
169 | ||
58ec2a95 | 170 | if (r == NULL || r->mode != CUPS_RASTER_READ) |
171 | return (0); | |
53161b68 | 172 | |
173 | remaining = len; | |
174 | ||
175 | while (remaining > 0) | |
176 | { | |
177 | bytes = read(r->fd, p, remaining); | |
1ff56f81 | 178 | |
cf909df0 | 179 | if (bytes <= 0) |
1ff56f81 | 180 | { |
181 | if (errno != EAGAIN && errno != EINTR) | |
182 | return (0); | |
183 | else | |
184 | continue; | |
185 | } | |
53161b68 | 186 | |
187 | remaining -= bytes; | |
188 | p += bytes; | |
189 | } | |
190 | ||
191 | return (len); | |
58ec2a95 | 192 | } |
193 | ||
194 | ||
195 | /* | |
196 | * 'cupsRasterWriteHeader()' - Write a raster page header. | |
197 | */ | |
198 | ||
199 | unsigned | |
200 | cupsRasterWriteHeader(cups_raster_t *r, | |
201 | cups_page_header_t *h) | |
202 | { | |
203 | if (r == NULL || r->mode != CUPS_RASTER_WRITE) | |
204 | return (0); | |
53161b68 | 205 | |
206 | return (cupsRasterWritePixels(r, (unsigned char *)h, | |
207 | sizeof(cups_page_header_t)) == | |
58ec2a95 | 208 | sizeof(cups_page_header_t)); |
209 | } | |
210 | ||
211 | ||
212 | /* | |
213 | * 'cupsRasterWritePixels()' - Write raster pixels. | |
214 | */ | |
215 | ||
53161b68 | 216 | unsigned /* O - Number of bytes written */ |
217 | cupsRasterWritePixels(cups_raster_t *r, /* I - Raster stream */ | |
218 | unsigned char *p, /* I - Bytes to write */ | |
219 | unsigned len)/* I - Number of bytes to write */ | |
58ec2a95 | 220 | { |
53161b68 | 221 | int bytes; /* Bytes read */ |
222 | unsigned remaining; /* Bytes remaining */ | |
223 | ||
224 | ||
58ec2a95 | 225 | if (r == NULL || r->mode != CUPS_RASTER_WRITE) |
226 | return (0); | |
53161b68 | 227 | |
228 | remaining = len; | |
229 | ||
230 | while (remaining > 0) | |
231 | { | |
232 | bytes = write(r->fd, p, remaining); | |
1ff56f81 | 233 | |
cf909df0 | 234 | if (bytes <= 0) |
1ff56f81 | 235 | { |
236 | if (errno != EAGAIN && errno != EINTR) | |
237 | return (0); | |
238 | else | |
239 | continue; | |
240 | } | |
53161b68 | 241 | |
242 | remaining -= bytes; | |
243 | p += bytes; | |
244 | } | |
245 | ||
246 | return (len); | |
58ec2a95 | 247 | } |
cfb0ab24 | 248 | |
249 | ||
250 | /* | |
71fe22b7 | 251 | * End of "$Id: raster.c,v 1.8 2000/01/04 13:45:36 mike Exp $". |
cfb0ab24 | 252 | */ |