diff options
author | David Walter Seikel | 2013-01-13 17:24:39 +1000 |
---|---|---|
committer | David Walter Seikel | 2013-01-13 17:24:39 +1000 |
commit | 393b5cd1dc438872af89d334ef6e5fcc59f27d47 (patch) | |
tree | 6a14521219942a08a1b95cb2f5a923a9edd60f63 /libraries/irrlicht-1.8/source/Irrlicht/jpeglib/jdatasrc.c | |
parent | Add a note about rasters suggested start up code. (diff) | |
download | SledjHamr-393b5cd1dc438872af89d334ef6e5fcc59f27d47.zip SledjHamr-393b5cd1dc438872af89d334ef6e5fcc59f27d47.tar.gz SledjHamr-393b5cd1dc438872af89d334ef6e5fcc59f27d47.tar.bz2 SledjHamr-393b5cd1dc438872af89d334ef6e5fcc59f27d47.tar.xz |
Added Irrlicht 1.8, but without all the Windows binaries.
Diffstat (limited to '')
-rw-r--r-- | libraries/irrlicht-1.8/source/Irrlicht/jpeglib/jdatasrc.c | 275 |
1 files changed, 275 insertions, 0 deletions
diff --git a/libraries/irrlicht-1.8/source/Irrlicht/jpeglib/jdatasrc.c b/libraries/irrlicht-1.8/source/Irrlicht/jpeglib/jdatasrc.c new file mode 100644 index 0000000..e8bca76 --- /dev/null +++ b/libraries/irrlicht-1.8/source/Irrlicht/jpeglib/jdatasrc.c | |||
@@ -0,0 +1,275 @@ | |||
1 | /* | ||
2 | * jdatasrc.c | ||
3 | * | ||
4 | * Copyright (C) 1994-1996, Thomas G. Lane. | ||
5 | * Modified 2009-2011 by Guido Vollbeding. | ||
6 | * This file is part of the Independent JPEG Group's software. | ||
7 | * For conditions of distribution and use, see the accompanying README file. | ||
8 | * | ||
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). | ||
11 | * While these routines are sufficient for most applications, | ||
12 | * some will want to use a different source manager. | ||
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 | ||
15 | * than 8 bits on your machine, you may need to do some tweaking. | ||
16 | */ | ||
17 | |||
18 | /* this is not a core library module, so it doesn't define JPEG_INTERNALS */ | ||
19 | #include "jinclude.h" | ||
20 | #include "jpeglib.h" | ||
21 | #include "jerror.h" | ||
22 | |||
23 | |||
24 | /* Expanded data source object for stdio input */ | ||
25 | |||
26 | typedef struct { | ||
27 | struct jpeg_source_mgr pub; /* public fields */ | ||
28 | |||
29 | FILE * infile; /* source stream */ | ||
30 | JOCTET * buffer; /* start of buffer */ | ||
31 | boolean start_of_file; /* have we gotten any data yet? */ | ||
32 | } my_source_mgr; | ||
33 | |||
34 | typedef my_source_mgr * my_src_ptr; | ||
35 | |||
36 | #define INPUT_BUF_SIZE 4096 /* choose an efficiently fread'able size */ | ||
37 | |||
38 | |||
39 | /* | ||
40 | * Initialize source --- called by jpeg_read_header | ||
41 | * before any data is actually read. | ||
42 | */ | ||
43 | |||
44 | METHODDEF(void) | ||
45 | init_source (j_decompress_ptr cinfo) | ||
46 | { | ||
47 | my_src_ptr src = (my_src_ptr) cinfo->src; | ||
48 | |||
49 | /* We reset the empty-input-file flag for each image, | ||
50 | * but we don't clear the input buffer. | ||
51 | * This is correct behavior for reading a series of images from one source. | ||
52 | */ | ||
53 | src->start_of_file = TRUE; | ||
54 | } | ||
55 | |||
56 | METHODDEF(void) | ||
57 | init_mem_source (j_decompress_ptr cinfo) | ||
58 | { | ||
59 | /* no work necessary here */ | ||
60 | } | ||
61 | |||
62 | |||
63 | /* | ||
64 | * Fill the input buffer --- called whenever buffer is emptied. | ||
65 | * | ||
66 | * In typical applications, this should read fresh data into the 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 | ||
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. | ||
71 | * | ||
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 | ||
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 | ||
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 | ||
78 | * input file, so we handle that case specially. | ||
79 | * | ||
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 | ||
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 | ||
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 | ||
86 | * that there are substantial restrictions on the use of suspension --- see | ||
87 | * the documentation. | ||
88 | * | ||
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 | ||
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 | ||
93 | * the front of the buffer rather than discarding it. | ||
94 | */ | ||
95 | |||
96 | METHODDEF(boolean) | ||
97 | fill_input_buffer (j_decompress_ptr cinfo) | ||
98 | { | ||
99 | my_src_ptr src = (my_src_ptr) cinfo->src; | ||
100 | size_t nbytes; | ||
101 | |||
102 | nbytes = JFREAD(src->infile, src->buffer, INPUT_BUF_SIZE); | ||
103 | |||
104 | if (nbytes <= 0) { | ||
105 | if (src->start_of_file) /* Treat empty input file as fatal error */ | ||
106 | ERREXIT(cinfo, JERR_INPUT_EMPTY); | ||
107 | WARNMS(cinfo, JWRN_JPEG_EOF); | ||
108 | /* Insert a fake EOI marker */ | ||
109 | src->buffer[0] = (JOCTET) 0xFF; | ||
110 | src->buffer[1] = (JOCTET) JPEG_EOI; | ||
111 | nbytes = 2; | ||
112 | } | ||
113 | |||
114 | src->pub.next_input_byte = src->buffer; | ||
115 | src->pub.bytes_in_buffer = nbytes; | ||
116 | src->start_of_file = FALSE; | ||
117 | |||
118 | return TRUE; | ||
119 | } | ||
120 | |||
121 | METHODDEF(boolean) | ||
122 | fill_mem_input_buffer (j_decompress_ptr cinfo) | ||
123 | { | ||
124 | static const JOCTET mybuffer[4] = { | ||
125 | (JOCTET) 0xFF, (JOCTET) JPEG_EOI, 0, 0 | ||
126 | }; | ||
127 | |||
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 | ||
130 | * is treated as an error. | ||
131 | */ | ||
132 | WARNMS(cinfo, JWRN_JPEG_EOF); | ||
133 | |||
134 | /* Insert a fake EOI marker */ | ||
135 | |||
136 | cinfo->src->next_input_byte = mybuffer; | ||
137 | cinfo->src->bytes_in_buffer = 2; | ||
138 | |||
139 | return TRUE; | ||
140 | } | ||
141 | |||
142 | |||
143 | /* | ||
144 | * Skip data --- used to skip over a potentially large amount of | ||
145 | * uninteresting data (such as an APPn marker). | ||
146 | * | ||
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 | ||
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. | ||
151 | * Arranging for additional bytes to be discarded before reloading the input | ||
152 | * buffer is the application writer's problem. | ||
153 | */ | ||
154 | |||
155 | METHODDEF(void) | ||
156 | skip_input_data (j_decompress_ptr cinfo, long num_bytes) | ||
157 | { | ||
158 | struct jpeg_source_mgr * src = cinfo->src; | ||
159 | |||
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 | ||
162 | * any trouble anyway --- large skips are infrequent. | ||
163 | */ | ||
164 | if (num_bytes > 0) { | ||
165 | while (num_bytes > (long) src->bytes_in_buffer) { | ||
166 | num_bytes -= (long) src->bytes_in_buffer; | ||
167 | (void) (*src->fill_input_buffer) (cinfo); | ||
168 | /* note we assume that fill_input_buffer will never return FALSE, | ||
169 | * so suspension need not be handled. | ||
170 | */ | ||
171 | } | ||
172 | src->next_input_byte += (size_t) num_bytes; | ||
173 | src->bytes_in_buffer -= (size_t) num_bytes; | ||
174 | } | ||
175 | } | ||
176 | |||
177 | |||
178 | /* | ||
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. | ||
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 | ||
183 | * is possible. | ||
184 | */ | ||
185 | |||
186 | |||
187 | /* | ||
188 | * Terminate source --- called by jpeg_finish_decompress | ||
189 | * after all data has been read. Often a no-op. | ||
190 | * | ||
191 | * NB: *not* called by jpeg_abort or jpeg_destroy; surrounding | ||
192 | * application must deal with any cleanup that should happen even | ||
193 | * for error exit. | ||
194 | */ | ||
195 | |||
196 | METHODDEF(void) | ||
197 | term_source (j_decompress_ptr cinfo) | ||
198 | { | ||
199 | /* no work necessary here */ | ||
200 | } | ||
201 | |||
202 | |||
203 | /* | ||
204 | * Prepare for input from a stdio stream. | ||
205 | * The caller must have already opened the stream, and is responsible | ||
206 | * for closing it after finishing decompression. | ||
207 | */ | ||
208 | |||
209 | GLOBAL(void) | ||
210 | jpeg_stdio_src (j_decompress_ptr cinfo, FILE * infile) | ||
211 | { | ||
212 | my_src_ptr src; | ||
213 | |||
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 | ||
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.) | ||
218 | * This makes it unsafe to use this manager and a different source | ||
219 | * manager serially with the same JPEG object. Caveat programmer. | ||
220 | */ | ||
221 | if (cinfo->src == NULL) { /* first time for this JPEG object? */ | ||
222 | cinfo->src = (struct jpeg_source_mgr *) | ||
223 | (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_PERMANENT, | ||
224 | SIZEOF(my_source_mgr)); | ||
225 | src = (my_src_ptr) cinfo->src; | ||
226 | src->buffer = (JOCTET *) | ||
227 | (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_PERMANENT, | ||
228 | INPUT_BUF_SIZE * SIZEOF(JOCTET)); | ||
229 | } | ||
230 | |||
231 | src = (my_src_ptr) cinfo->src; | ||
232 | src->pub.init_source = init_source; | ||
233 | src->pub.fill_input_buffer = fill_input_buffer; | ||
234 | src->pub.skip_input_data = skip_input_data; | ||
235 | src->pub.resync_to_restart = jpeg_resync_to_restart; /* use default method */ | ||
236 | src->pub.term_source = term_source; | ||
237 | src->infile = infile; | ||
238 | src->pub.bytes_in_buffer = 0; /* forces fill_input_buffer on first read */ | ||
239 | src->pub.next_input_byte = NULL; /* until buffer loaded */ | ||
240 | } | ||
241 | |||
242 | |||
243 | /* | ||
244 | * Prepare for input from a supplied memory buffer. | ||
245 | * The buffer must contain the whole JPEG data. | ||
246 | */ | ||
247 | |||
248 | GLOBAL(void) | ||
249 | jpeg_mem_src (j_decompress_ptr cinfo, | ||
250 | unsigned char * inbuffer, unsigned long insize) | ||
251 | { | ||
252 | struct jpeg_source_mgr * src; | ||
253 | |||
254 | if (inbuffer == NULL || insize == 0) /* Treat empty input as fatal error */ | ||
255 | ERREXIT(cinfo, JERR_INPUT_EMPTY); | ||
256 | |||
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 | ||
259 | * the first one. | ||
260 | */ | ||
261 | if (cinfo->src == NULL) { /* first time for this JPEG object? */ | ||
262 | cinfo->src = (struct jpeg_source_mgr *) | ||
263 | (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_PERMANENT, | ||
264 | SIZEOF(struct jpeg_source_mgr)); | ||
265 | } | ||
266 | |||
267 | src = cinfo->src; | ||
268 | src->init_source = init_mem_source; | ||
269 | src->fill_input_buffer = fill_mem_input_buffer; | ||
270 | src->skip_input_data = skip_input_data; | ||
271 | src->resync_to_restart = jpeg_resync_to_restart; /* use default method */ | ||
272 | src->term_source = term_source; | ||
273 | src->bytes_in_buffer = (size_t) insize; | ||
274 | src->next_input_byte = (JOCTET *) inbuffer; | ||
275 | } | ||