diff options
Diffstat (limited to 'libraries/irrlicht-1.8/source/Irrlicht/jpeglib/jdatasrc.c')
-rw-r--r-- | libraries/irrlicht-1.8/source/Irrlicht/jpeglib/jdatasrc.c | 550 |
1 files changed, 275 insertions, 275 deletions
diff --git a/libraries/irrlicht-1.8/source/Irrlicht/jpeglib/jdatasrc.c b/libraries/irrlicht-1.8/source/Irrlicht/jpeglib/jdatasrc.c index e8bca76..7be59a8 100644 --- a/libraries/irrlicht-1.8/source/Irrlicht/jpeglib/jdatasrc.c +++ b/libraries/irrlicht-1.8/source/Irrlicht/jpeglib/jdatasrc.c | |||
@@ -1,275 +1,275 @@ | |||
1 | /* | 1 | /* |
2 | * jdatasrc.c | 2 | * jdatasrc.c |
3 | * | 3 | * |
4 | * Copyright (C) 1994-1996, Thomas G. Lane. | 4 | * Copyright (C) 1994-1996, Thomas G. Lane. |
5 | * Modified 2009-2011 by Guido Vollbeding. | 5 | * Modified 2009-2011 by Guido Vollbeding. |
6 | * This file is part of the Independent JPEG Group's software. | 6 | * This file is part of the Independent JPEG Group's software. |
7 | * For conditions of distribution and use, see the accompanying README file. | 7 | * For conditions of distribution and use, see the accompanying README file. |
8 | * | 8 | * |
9 | * This file contains decompression data source routines for the case of | 9 | * This file contains decompression data source routines for the case of |
10 | * reading JPEG data from memory or from a file (or any stdio stream). | 10 | * reading JPEG data from memory or from a file (or any stdio stream). |
11 | * While these routines are sufficient for most applications, | 11 | * While these routines are sufficient for most applications, |
12 | * some will want to use a different source manager. | 12 | * some will want to use a different source manager. |
13 | * IMPORTANT: we assume that fread() will correctly transcribe an array of | 13 | * IMPORTANT: we assume that fread() will correctly transcribe an array of |
14 | * JOCTETs from 8-bit-wide elements on external storage. If char is wider | 14 | * JOCTETs from 8-bit-wide elements on external storage. If char is wider |
15 | * than 8 bits on your machine, you may need to do some tweaking. | 15 | * than 8 bits on your machine, you may need to do some tweaking. |
16 | */ | 16 | */ |
17 | 17 | ||
18 | /* this is not a core library module, so it doesn't define JPEG_INTERNALS */ | 18 | /* this is not a core library module, so it doesn't define JPEG_INTERNALS */ |
19 | #include "jinclude.h" | 19 | #include "jinclude.h" |
20 | #include "jpeglib.h" | 20 | #include "jpeglib.h" |
21 | #include "jerror.h" | 21 | #include "jerror.h" |
22 | 22 | ||
23 | 23 | ||
24 | /* Expanded data source object for stdio input */ | 24 | /* Expanded data source object for stdio input */ |
25 | 25 | ||
26 | typedef struct { | 26 | typedef struct { |
27 | struct jpeg_source_mgr pub; /* public fields */ | 27 | struct jpeg_source_mgr pub; /* public fields */ |
28 | 28 | ||
29 | FILE * infile; /* source stream */ | 29 | FILE * infile; /* source stream */ |
30 | JOCTET * buffer; /* start of buffer */ | 30 | JOCTET * buffer; /* start of buffer */ |
31 | boolean start_of_file; /* have we gotten any data yet? */ | 31 | boolean start_of_file; /* have we gotten any data yet? */ |
32 | } my_source_mgr; | 32 | } my_source_mgr; |
33 | 33 | ||
34 | typedef my_source_mgr * my_src_ptr; | 34 | typedef my_source_mgr * my_src_ptr; |
35 | 35 | ||
36 | #define INPUT_BUF_SIZE 4096 /* choose an efficiently fread'able size */ | 36 | #define INPUT_BUF_SIZE 4096 /* choose an efficiently fread'able size */ |
37 | 37 | ||
38 | 38 | ||
39 | /* | 39 | /* |
40 | * Initialize source --- called by jpeg_read_header | 40 | * Initialize source --- called by jpeg_read_header |
41 | * before any data is actually read. | 41 | * before any data is actually read. |
42 | */ | 42 | */ |
43 | 43 | ||
44 | METHODDEF(void) | 44 | METHODDEF(void) |
45 | init_source (j_decompress_ptr cinfo) | 45 | init_source (j_decompress_ptr cinfo) |
46 | { | 46 | { |
47 | my_src_ptr src = (my_src_ptr) cinfo->src; | 47 | my_src_ptr src = (my_src_ptr) cinfo->src; |
48 | 48 | ||
49 | /* We reset the empty-input-file flag for each image, | 49 | /* We reset the empty-input-file flag for each image, |
50 | * but we don't clear the input buffer. | 50 | * but we don't clear the input buffer. |
51 | * This is correct behavior for reading a series of images from one source. | 51 | * This is correct behavior for reading a series of images from one source. |
52 | */ | 52 | */ |
53 | src->start_of_file = TRUE; | 53 | src->start_of_file = TRUE; |
54 | } | 54 | } |
55 | 55 | ||
56 | METHODDEF(void) | 56 | METHODDEF(void) |
57 | init_mem_source (j_decompress_ptr cinfo) | 57 | init_mem_source (j_decompress_ptr cinfo) |
58 | { | 58 | { |
59 | /* no work necessary here */ | 59 | /* no work necessary here */ |
60 | } | 60 | } |
61 | 61 | ||
62 | 62 | ||
63 | /* | 63 | /* |
64 | * Fill the input buffer --- called whenever buffer is emptied. | 64 | * Fill the input buffer --- called whenever buffer is emptied. |
65 | * | 65 | * |
66 | * In typical applications, this should read fresh data into the buffer | 66 | * In typical applications, this should read fresh data into the buffer |
67 | * (ignoring the current state of next_input_byte & bytes_in_buffer), | 67 | * (ignoring the current state of next_input_byte & bytes_in_buffer), |
68 | * reset the pointer & count to the start of the buffer, and return TRUE | 68 | * reset the pointer & count to the start of the buffer, and return TRUE |
69 | * indicating that the buffer has been reloaded. It is not necessary to | 69 | * indicating that the buffer has been reloaded. It is not necessary to |
70 | * fill the buffer entirely, only to obtain at least one more byte. | 70 | * fill the buffer entirely, only to obtain at least one more byte. |
71 | * | 71 | * |
72 | * There is no such thing as an EOF return. If the end of the file has been | 72 | * There is no such thing as an EOF return. If the end of the file has been |
73 | * reached, the routine has a choice of ERREXIT() or inserting fake data into | 73 | * reached, the routine has a choice of ERREXIT() or inserting fake data into |
74 | * the buffer. In most cases, generating a warning message and inserting a | 74 | * the buffer. In most cases, generating a warning message and inserting a |
75 | * fake EOI marker is the best course of action --- this will allow the | 75 | * fake EOI marker is the best course of action --- this will allow the |
76 | * decompressor to output however much of the image is there. However, | 76 | * decompressor to output however much of the image is there. However, |
77 | * the resulting error message is misleading if the real problem is an empty | 77 | * the resulting error message is misleading if the real problem is an empty |
78 | * input file, so we handle that case specially. | 78 | * input file, so we handle that case specially. |
79 | * | 79 | * |
80 | * In applications that need to be able to suspend compression due to input | 80 | * In applications that need to be able to suspend compression due to input |
81 | * not being available yet, a FALSE return indicates that no more data can be | 81 | * not being available yet, a FALSE return indicates that no more data can be |
82 | * obtained right now, but more may be forthcoming later. In this situation, | 82 | * obtained right now, but more may be forthcoming later. In this situation, |
83 | * the decompressor will return to its caller (with an indication of the | 83 | * the decompressor will return to its caller (with an indication of the |
84 | * number of scanlines it has read, if any). The application should resume | 84 | * number of scanlines it has read, if any). The application should resume |
85 | * decompression after it has loaded more data into the input buffer. Note | 85 | * decompression after it has loaded more data into the input buffer. Note |
86 | * that there are substantial restrictions on the use of suspension --- see | 86 | * that there are substantial restrictions on the use of suspension --- see |
87 | * the documentation. | 87 | * the documentation. |
88 | * | 88 | * |
89 | * When suspending, the decompressor will back up to a convenient restart point | 89 | * When suspending, the decompressor will back up to a convenient restart point |
90 | * (typically the start of the current MCU). next_input_byte & bytes_in_buffer | 90 | * (typically the start of the current MCU). next_input_byte & bytes_in_buffer |
91 | * indicate where the restart point will be if the current call returns FALSE. | 91 | * indicate where the restart point will be if the current call returns FALSE. |
92 | * Data beyond this point must be rescanned after resumption, so move it to | 92 | * Data beyond this point must be rescanned after resumption, so move it to |
93 | * the front of the buffer rather than discarding it. | 93 | * the front of the buffer rather than discarding it. |
94 | */ | 94 | */ |
95 | 95 | ||
96 | METHODDEF(boolean) | 96 | METHODDEF(boolean) |
97 | fill_input_buffer (j_decompress_ptr cinfo) | 97 | fill_input_buffer (j_decompress_ptr cinfo) |
98 | { | 98 | { |
99 | my_src_ptr src = (my_src_ptr) cinfo->src; | 99 | my_src_ptr src = (my_src_ptr) cinfo->src; |
100 | size_t nbytes; | 100 | size_t nbytes; |
101 | 101 | ||
102 | nbytes = JFREAD(src->infile, src->buffer, INPUT_BUF_SIZE); | 102 | nbytes = JFREAD(src->infile, src->buffer, INPUT_BUF_SIZE); |
103 | 103 | ||
104 | if (nbytes <= 0) { | 104 | if (nbytes <= 0) { |
105 | if (src->start_of_file) /* Treat empty input file as fatal error */ | 105 | if (src->start_of_file) /* Treat empty input file as fatal error */ |
106 | ERREXIT(cinfo, JERR_INPUT_EMPTY); | 106 | ERREXIT(cinfo, JERR_INPUT_EMPTY); |
107 | WARNMS(cinfo, JWRN_JPEG_EOF); | 107 | WARNMS(cinfo, JWRN_JPEG_EOF); |
108 | /* Insert a fake EOI marker */ | 108 | /* Insert a fake EOI marker */ |
109 | src->buffer[0] = (JOCTET) 0xFF; | 109 | src->buffer[0] = (JOCTET) 0xFF; |
110 | src->buffer[1] = (JOCTET) JPEG_EOI; | 110 | src->buffer[1] = (JOCTET) JPEG_EOI; |
111 | nbytes = 2; | 111 | nbytes = 2; |
112 | } | 112 | } |
113 | 113 | ||
114 | src->pub.next_input_byte = src->buffer; | 114 | src->pub.next_input_byte = src->buffer; |
115 | src->pub.bytes_in_buffer = nbytes; | 115 | src->pub.bytes_in_buffer = nbytes; |
116 | src->start_of_file = FALSE; | 116 | src->start_of_file = FALSE; |
117 | 117 | ||
118 | return TRUE; | 118 | return TRUE; |
119 | } | 119 | } |
120 | 120 | ||
121 | METHODDEF(boolean) | 121 | METHODDEF(boolean) |
122 | fill_mem_input_buffer (j_decompress_ptr cinfo) | 122 | fill_mem_input_buffer (j_decompress_ptr cinfo) |
123 | { | 123 | { |
124 | static const JOCTET mybuffer[4] = { | 124 | static const JOCTET mybuffer[4] = { |
125 | (JOCTET) 0xFF, (JOCTET) JPEG_EOI, 0, 0 | 125 | (JOCTET) 0xFF, (JOCTET) JPEG_EOI, 0, 0 |
126 | }; | 126 | }; |
127 | 127 | ||
128 | /* The whole JPEG data is expected to reside in the supplied memory | 128 | /* The whole JPEG data is expected to reside in the supplied memory |
129 | * buffer, so any request for more data beyond the given buffer size | 129 | * buffer, so any request for more data beyond the given buffer size |
130 | * is treated as an error. | 130 | * is treated as an error. |
131 | */ | 131 | */ |
132 | WARNMS(cinfo, JWRN_JPEG_EOF); | 132 | WARNMS(cinfo, JWRN_JPEG_EOF); |
133 | 133 | ||
134 | /* Insert a fake EOI marker */ | 134 | /* Insert a fake EOI marker */ |
135 | 135 | ||
136 | cinfo->src->next_input_byte = mybuffer; | 136 | cinfo->src->next_input_byte = mybuffer; |
137 | cinfo->src->bytes_in_buffer = 2; | 137 | cinfo->src->bytes_in_buffer = 2; |
138 | 138 | ||
139 | return TRUE; | 139 | return TRUE; |
140 | } | 140 | } |
141 | 141 | ||
142 | 142 | ||
143 | /* | 143 | /* |
144 | * Skip data --- used to skip over a potentially large amount of | 144 | * Skip data --- used to skip over a potentially large amount of |
145 | * uninteresting data (such as an APPn marker). | 145 | * uninteresting data (such as an APPn marker). |
146 | * | 146 | * |
147 | * Writers of suspendable-input applications must note that skip_input_data | 147 | * Writers of suspendable-input applications must note that skip_input_data |
148 | * is not granted the right to give a suspension return. If the skip extends | 148 | * is not granted the right to give a suspension return. If the skip extends |
149 | * beyond the data currently in the buffer, the buffer can be marked empty so | 149 | * beyond the data currently in the buffer, the buffer can be marked empty so |
150 | * that the next read will cause a fill_input_buffer call that can suspend. | 150 | * that the next read will cause a fill_input_buffer call that can suspend. |
151 | * Arranging for additional bytes to be discarded before reloading the input | 151 | * Arranging for additional bytes to be discarded before reloading the input |
152 | * buffer is the application writer's problem. | 152 | * buffer is the application writer's problem. |
153 | */ | 153 | */ |
154 | 154 | ||
155 | METHODDEF(void) | 155 | METHODDEF(void) |
156 | skip_input_data (j_decompress_ptr cinfo, long num_bytes) | 156 | skip_input_data (j_decompress_ptr cinfo, long num_bytes) |
157 | { | 157 | { |
158 | struct jpeg_source_mgr * src = cinfo->src; | 158 | struct jpeg_source_mgr * src = cinfo->src; |
159 | 159 | ||
160 | /* Just a dumb implementation for now. Could use fseek() except | 160 | /* Just a dumb implementation for now. Could use fseek() except |
161 | * it doesn't work on pipes. Not clear that being smart is worth | 161 | * it doesn't work on pipes. Not clear that being smart is worth |
162 | * any trouble anyway --- large skips are infrequent. | 162 | * any trouble anyway --- large skips are infrequent. |
163 | */ | 163 | */ |
164 | if (num_bytes > 0) { | 164 | if (num_bytes > 0) { |
165 | while (num_bytes > (long) src->bytes_in_buffer) { | 165 | while (num_bytes > (long) src->bytes_in_buffer) { |
166 | num_bytes -= (long) src->bytes_in_buffer; | 166 | num_bytes -= (long) src->bytes_in_buffer; |
167 | (void) (*src->fill_input_buffer) (cinfo); | 167 | (void) (*src->fill_input_buffer) (cinfo); |
168 | /* note we assume that fill_input_buffer will never return FALSE, | 168 | /* note we assume that fill_input_buffer will never return FALSE, |
169 | * so suspension need not be handled. | 169 | * so suspension need not be handled. |
170 | */ | 170 | */ |
171 | } | 171 | } |
172 | src->next_input_byte += (size_t) num_bytes; | 172 | src->next_input_byte += (size_t) num_bytes; |
173 | src->bytes_in_buffer -= (size_t) num_bytes; | 173 | src->bytes_in_buffer -= (size_t) num_bytes; |
174 | } | 174 | } |
175 | } | 175 | } |
176 | 176 | ||
177 | 177 | ||
178 | /* | 178 | /* |
179 | * An additional method that can be provided by data source modules is the | 179 | * An additional method that can be provided by data source modules is the |
180 | * resync_to_restart method for error recovery in the presence of RST markers. | 180 | * resync_to_restart method for error recovery in the presence of RST markers. |
181 | * For the moment, this source module just uses the default resync method | 181 | * For the moment, this source module just uses the default resync method |
182 | * provided by the JPEG library. That method assumes that no backtracking | 182 | * provided by the JPEG library. That method assumes that no backtracking |
183 | * is possible. | 183 | * is possible. |
184 | */ | 184 | */ |
185 | 185 | ||
186 | 186 | ||
187 | /* | 187 | /* |
188 | * Terminate source --- called by jpeg_finish_decompress | 188 | * Terminate source --- called by jpeg_finish_decompress |
189 | * after all data has been read. Often a no-op. | 189 | * after all data has been read. Often a no-op. |
190 | * | 190 | * |
191 | * NB: *not* called by jpeg_abort or jpeg_destroy; surrounding | 191 | * NB: *not* called by jpeg_abort or jpeg_destroy; surrounding |
192 | * application must deal with any cleanup that should happen even | 192 | * application must deal with any cleanup that should happen even |
193 | * for error exit. | 193 | * for error exit. |
194 | */ | 194 | */ |
195 | 195 | ||
196 | METHODDEF(void) | 196 | METHODDEF(void) |
197 | term_source (j_decompress_ptr cinfo) | 197 | term_source (j_decompress_ptr cinfo) |
198 | { | 198 | { |
199 | /* no work necessary here */ | 199 | /* no work necessary here */ |
200 | } | 200 | } |
201 | 201 | ||
202 | 202 | ||
203 | /* | 203 | /* |
204 | * Prepare for input from a stdio stream. | 204 | * Prepare for input from a stdio stream. |
205 | * The caller must have already opened the stream, and is responsible | 205 | * The caller must have already opened the stream, and is responsible |
206 | * for closing it after finishing decompression. | 206 | * for closing it after finishing decompression. |
207 | */ | 207 | */ |
208 | 208 | ||
209 | GLOBAL(void) | 209 | GLOBAL(void) |
210 | jpeg_stdio_src (j_decompress_ptr cinfo, FILE * infile) | 210 | jpeg_stdio_src (j_decompress_ptr cinfo, FILE * infile) |
211 | { | 211 | { |
212 | my_src_ptr src; | 212 | my_src_ptr src; |
213 | 213 | ||
214 | /* The source object and input buffer are made permanent so that a series | 214 | /* The source object and input buffer are made permanent so that a series |
215 | * of JPEG images can be read from the same file by calling jpeg_stdio_src | 215 | * of JPEG images can be read from the same file by calling jpeg_stdio_src |
216 | * only before the first one. (If we discarded the buffer at the end of | 216 | * only before the first one. (If we discarded the buffer at the end of |
217 | * one image, we'd likely lose the start of the next one.) | 217 | * one image, we'd likely lose the start of the next one.) |
218 | * This makes it unsafe to use this manager and a different source | 218 | * This makes it unsafe to use this manager and a different source |
219 | * manager serially with the same JPEG object. Caveat programmer. | 219 | * manager serially with the same JPEG object. Caveat programmer. |
220 | */ | 220 | */ |
221 | if (cinfo->src == NULL) { /* first time for this JPEG object? */ | 221 | if (cinfo->src == NULL) { /* first time for this JPEG object? */ |
222 | cinfo->src = (struct jpeg_source_mgr *) | 222 | cinfo->src = (struct jpeg_source_mgr *) |
223 | (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_PERMANENT, | 223 | (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_PERMANENT, |
224 | SIZEOF(my_source_mgr)); | 224 | SIZEOF(my_source_mgr)); |
225 | src = (my_src_ptr) cinfo->src; | 225 | src = (my_src_ptr) cinfo->src; |
226 | src->buffer = (JOCTET *) | 226 | src->buffer = (JOCTET *) |
227 | (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_PERMANENT, | 227 | (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_PERMANENT, |
228 | INPUT_BUF_SIZE * SIZEOF(JOCTET)); | 228 | INPUT_BUF_SIZE * SIZEOF(JOCTET)); |
229 | } | 229 | } |
230 | 230 | ||
231 | src = (my_src_ptr) cinfo->src; | 231 | src = (my_src_ptr) cinfo->src; |
232 | src->pub.init_source = init_source; | 232 | src->pub.init_source = init_source; |
233 | src->pub.fill_input_buffer = fill_input_buffer; | 233 | src->pub.fill_input_buffer = fill_input_buffer; |
234 | src->pub.skip_input_data = skip_input_data; | 234 | src->pub.skip_input_data = skip_input_data; |
235 | src->pub.resync_to_restart = jpeg_resync_to_restart; /* use default method */ | 235 | src->pub.resync_to_restart = jpeg_resync_to_restart; /* use default method */ |
236 | src->pub.term_source = term_source; | 236 | src->pub.term_source = term_source; |
237 | src->infile = infile; | 237 | src->infile = infile; |
238 | src->pub.bytes_in_buffer = 0; /* forces fill_input_buffer on first read */ | 238 | src->pub.bytes_in_buffer = 0; /* forces fill_input_buffer on first read */ |
239 | src->pub.next_input_byte = NULL; /* until buffer loaded */ | 239 | src->pub.next_input_byte = NULL; /* until buffer loaded */ |
240 | } | 240 | } |
241 | 241 | ||
242 | 242 | ||
243 | /* | 243 | /* |
244 | * Prepare for input from a supplied memory buffer. | 244 | * Prepare for input from a supplied memory buffer. |
245 | * The buffer must contain the whole JPEG data. | 245 | * The buffer must contain the whole JPEG data. |
246 | */ | 246 | */ |
247 | 247 | ||
248 | GLOBAL(void) | 248 | GLOBAL(void) |
249 | jpeg_mem_src (j_decompress_ptr cinfo, | 249 | jpeg_mem_src (j_decompress_ptr cinfo, |
250 | unsigned char * inbuffer, unsigned long insize) | 250 | unsigned char * inbuffer, unsigned long insize) |
251 | { | 251 | { |
252 | struct jpeg_source_mgr * src; | 252 | struct jpeg_source_mgr * src; |
253 | 253 | ||
254 | if (inbuffer == NULL || insize == 0) /* Treat empty input as fatal error */ | 254 | if (inbuffer == NULL || insize == 0) /* Treat empty input as fatal error */ |
255 | ERREXIT(cinfo, JERR_INPUT_EMPTY); | 255 | ERREXIT(cinfo, JERR_INPUT_EMPTY); |
256 | 256 | ||
257 | /* The source object is made permanent so that a series of JPEG images | 257 | /* The source object is made permanent so that a series of JPEG images |
258 | * can be read from the same buffer by calling jpeg_mem_src only before | 258 | * can be read from the same buffer by calling jpeg_mem_src only before |
259 | * the first one. | 259 | * the first one. |
260 | */ | 260 | */ |
261 | if (cinfo->src == NULL) { /* first time for this JPEG object? */ | 261 | if (cinfo->src == NULL) { /* first time for this JPEG object? */ |
262 | cinfo->src = (struct jpeg_source_mgr *) | 262 | cinfo->src = (struct jpeg_source_mgr *) |
263 | (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_PERMANENT, | 263 | (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_PERMANENT, |
264 | SIZEOF(struct jpeg_source_mgr)); | 264 | SIZEOF(struct jpeg_source_mgr)); |
265 | } | 265 | } |
266 | 266 | ||
267 | src = cinfo->src; | 267 | src = cinfo->src; |
268 | src->init_source = init_mem_source; | 268 | src->init_source = init_mem_source; |
269 | src->fill_input_buffer = fill_mem_input_buffer; | 269 | src->fill_input_buffer = fill_mem_input_buffer; |
270 | src->skip_input_data = skip_input_data; | 270 | src->skip_input_data = skip_input_data; |
271 | src->resync_to_restart = jpeg_resync_to_restart; /* use default method */ | 271 | src->resync_to_restart = jpeg_resync_to_restart; /* use default method */ |
272 | src->term_source = term_source; | 272 | src->term_source = term_source; |
273 | src->bytes_in_buffer = (size_t) insize; | 273 | src->bytes_in_buffer = (size_t) insize; |
274 | src->next_input_byte = (JOCTET *) inbuffer; | 274 | src->next_input_byte = (JOCTET *) inbuffer; |
275 | } | 275 | } |