diff options
Diffstat (limited to 'libraries/irrlicht-1.8/source/Irrlicht/jpeglib/example.c')
-rw-r--r-- | libraries/irrlicht-1.8/source/Irrlicht/jpeglib/example.c | 866 |
1 files changed, 433 insertions, 433 deletions
diff --git a/libraries/irrlicht-1.8/source/Irrlicht/jpeglib/example.c b/libraries/irrlicht-1.8/source/Irrlicht/jpeglib/example.c index e21cf12..1d6f6cc 100644 --- a/libraries/irrlicht-1.8/source/Irrlicht/jpeglib/example.c +++ b/libraries/irrlicht-1.8/source/Irrlicht/jpeglib/example.c | |||
@@ -1,433 +1,433 @@ | |||
1 | /* | 1 | /* |
2 | * example.c | 2 | * example.c |
3 | * | 3 | * |
4 | * This file illustrates how to use the IJG code as a subroutine library | 4 | * This file illustrates how to use the IJG code as a subroutine library |
5 | * to read or write JPEG image files. You should look at this code in | 5 | * to read or write JPEG image files. You should look at this code in |
6 | * conjunction with the documentation file libjpeg.txt. | 6 | * conjunction with the documentation file libjpeg.txt. |
7 | * | 7 | * |
8 | * This code will not do anything useful as-is, but it may be helpful as a | 8 | * This code will not do anything useful as-is, but it may be helpful as a |
9 | * skeleton for constructing routines that call the JPEG library. | 9 | * skeleton for constructing routines that call the JPEG library. |
10 | * | 10 | * |
11 | * We present these routines in the same coding style used in the JPEG code | 11 | * We present these routines in the same coding style used in the JPEG code |
12 | * (ANSI function definitions, etc); but you are of course free to code your | 12 | * (ANSI function definitions, etc); but you are of course free to code your |
13 | * routines in a different style if you prefer. | 13 | * routines in a different style if you prefer. |
14 | */ | 14 | */ |
15 | 15 | ||
16 | #include <stdio.h> | 16 | #include <stdio.h> |
17 | 17 | ||
18 | /* | 18 | /* |
19 | * Include file for users of JPEG library. | 19 | * Include file for users of JPEG library. |
20 | * You will need to have included system headers that define at least | 20 | * You will need to have included system headers that define at least |
21 | * the typedefs FILE and size_t before you can include jpeglib.h. | 21 | * the typedefs FILE and size_t before you can include jpeglib.h. |
22 | * (stdio.h is sufficient on ANSI-conforming systems.) | 22 | * (stdio.h is sufficient on ANSI-conforming systems.) |
23 | * You may also wish to include "jerror.h". | 23 | * You may also wish to include "jerror.h". |
24 | */ | 24 | */ |
25 | 25 | ||
26 | #include "jpeglib.h" | 26 | #include "jpeglib.h" |
27 | 27 | ||
28 | /* | 28 | /* |
29 | * <setjmp.h> is used for the optional error recovery mechanism shown in | 29 | * <setjmp.h> is used for the optional error recovery mechanism shown in |
30 | * the second part of the example. | 30 | * the second part of the example. |
31 | */ | 31 | */ |
32 | 32 | ||
33 | #include <setjmp.h> | 33 | #include <setjmp.h> |
34 | 34 | ||
35 | 35 | ||
36 | 36 | ||
37 | /******************** JPEG COMPRESSION SAMPLE INTERFACE *******************/ | 37 | /******************** JPEG COMPRESSION SAMPLE INTERFACE *******************/ |
38 | 38 | ||
39 | /* This half of the example shows how to feed data into the JPEG compressor. | 39 | /* This half of the example shows how to feed data into the JPEG compressor. |
40 | * We present a minimal version that does not worry about refinements such | 40 | * We present a minimal version that does not worry about refinements such |
41 | * as error recovery (the JPEG code will just exit() if it gets an error). | 41 | * as error recovery (the JPEG code will just exit() if it gets an error). |
42 | */ | 42 | */ |
43 | 43 | ||
44 | 44 | ||
45 | /* | 45 | /* |
46 | * IMAGE DATA FORMATS: | 46 | * IMAGE DATA FORMATS: |
47 | * | 47 | * |
48 | * The standard input image format is a rectangular array of pixels, with | 48 | * The standard input image format is a rectangular array of pixels, with |
49 | * each pixel having the same number of "component" values (color channels). | 49 | * each pixel having the same number of "component" values (color channels). |
50 | * Each pixel row is an array of JSAMPLEs (which typically are unsigned chars). | 50 | * Each pixel row is an array of JSAMPLEs (which typically are unsigned chars). |
51 | * If you are working with color data, then the color values for each pixel | 51 | * If you are working with color data, then the color values for each pixel |
52 | * must be adjacent in the row; for example, R,G,B,R,G,B,R,G,B,... for 24-bit | 52 | * must be adjacent in the row; for example, R,G,B,R,G,B,R,G,B,... for 24-bit |
53 | * RGB color. | 53 | * RGB color. |
54 | * | 54 | * |
55 | * For this example, we'll assume that this data structure matches the way | 55 | * For this example, we'll assume that this data structure matches the way |
56 | * our application has stored the image in memory, so we can just pass a | 56 | * our application has stored the image in memory, so we can just pass a |
57 | * pointer to our image buffer. In particular, let's say that the image is | 57 | * pointer to our image buffer. In particular, let's say that the image is |
58 | * RGB color and is described by: | 58 | * RGB color and is described by: |
59 | */ | 59 | */ |
60 | 60 | ||
61 | extern JSAMPLE * image_buffer; /* Points to large array of R,G,B-order data */ | 61 | extern JSAMPLE * image_buffer; /* Points to large array of R,G,B-order data */ |
62 | extern int image_height; /* Number of rows in image */ | 62 | extern int image_height; /* Number of rows in image */ |
63 | extern int image_width; /* Number of columns in image */ | 63 | extern int image_width; /* Number of columns in image */ |
64 | 64 | ||
65 | 65 | ||
66 | /* | 66 | /* |
67 | * Sample routine for JPEG compression. We assume that the target file name | 67 | * Sample routine for JPEG compression. We assume that the target file name |
68 | * and a compression quality factor are passed in. | 68 | * and a compression quality factor are passed in. |
69 | */ | 69 | */ |
70 | 70 | ||
71 | GLOBAL(void) | 71 | GLOBAL(void) |
72 | write_JPEG_file (char * filename, int quality) | 72 | write_JPEG_file (char * filename, int quality) |
73 | { | 73 | { |
74 | /* This struct contains the JPEG compression parameters and pointers to | 74 | /* This struct contains the JPEG compression parameters and pointers to |
75 | * working space (which is allocated as needed by the JPEG library). | 75 | * working space (which is allocated as needed by the JPEG library). |
76 | * It is possible to have several such structures, representing multiple | 76 | * It is possible to have several such structures, representing multiple |
77 | * compression/decompression processes, in existence at once. We refer | 77 | * compression/decompression processes, in existence at once. We refer |
78 | * to any one struct (and its associated working data) as a "JPEG object". | 78 | * to any one struct (and its associated working data) as a "JPEG object". |
79 | */ | 79 | */ |
80 | struct jpeg_compress_struct cinfo; | 80 | struct jpeg_compress_struct cinfo; |
81 | /* This struct represents a JPEG error handler. It is declared separately | 81 | /* This struct represents a JPEG error handler. It is declared separately |
82 | * because applications often want to supply a specialized error handler | 82 | * because applications often want to supply a specialized error handler |
83 | * (see the second half of this file for an example). But here we just | 83 | * (see the second half of this file for an example). But here we just |
84 | * take the easy way out and use the standard error handler, which will | 84 | * take the easy way out and use the standard error handler, which will |
85 | * print a message on stderr and call exit() if compression fails. | 85 | * print a message on stderr and call exit() if compression fails. |
86 | * Note that this struct must live as long as the main JPEG parameter | 86 | * Note that this struct must live as long as the main JPEG parameter |
87 | * struct, to avoid dangling-pointer problems. | 87 | * struct, to avoid dangling-pointer problems. |
88 | */ | 88 | */ |
89 | struct jpeg_error_mgr jerr; | 89 | struct jpeg_error_mgr jerr; |
90 | /* More stuff */ | 90 | /* More stuff */ |
91 | FILE * outfile; /* target file */ | 91 | FILE * outfile; /* target file */ |
92 | JSAMPROW row_pointer[1]; /* pointer to JSAMPLE row[s] */ | 92 | JSAMPROW row_pointer[1]; /* pointer to JSAMPLE row[s] */ |
93 | int row_stride; /* physical row width in image buffer */ | 93 | int row_stride; /* physical row width in image buffer */ |
94 | 94 | ||
95 | /* Step 1: allocate and initialize JPEG compression object */ | 95 | /* Step 1: allocate and initialize JPEG compression object */ |
96 | 96 | ||
97 | /* We have to set up the error handler first, in case the initialization | 97 | /* We have to set up the error handler first, in case the initialization |
98 | * step fails. (Unlikely, but it could happen if you are out of memory.) | 98 | * step fails. (Unlikely, but it could happen if you are out of memory.) |
99 | * This routine fills in the contents of struct jerr, and returns jerr's | 99 | * This routine fills in the contents of struct jerr, and returns jerr's |
100 | * address which we place into the link field in cinfo. | 100 | * address which we place into the link field in cinfo. |
101 | */ | 101 | */ |
102 | cinfo.err = jpeg_std_error(&jerr); | 102 | cinfo.err = jpeg_std_error(&jerr); |
103 | /* Now we can initialize the JPEG compression object. */ | 103 | /* Now we can initialize the JPEG compression object. */ |
104 | jpeg_create_compress(&cinfo); | 104 | jpeg_create_compress(&cinfo); |
105 | 105 | ||
106 | /* Step 2: specify data destination (eg, a file) */ | 106 | /* Step 2: specify data destination (eg, a file) */ |
107 | /* Note: steps 2 and 3 can be done in either order. */ | 107 | /* Note: steps 2 and 3 can be done in either order. */ |
108 | 108 | ||
109 | /* Here we use the library-supplied code to send compressed data to a | 109 | /* Here we use the library-supplied code to send compressed data to a |
110 | * stdio stream. You can also write your own code to do something else. | 110 | * stdio stream. You can also write your own code to do something else. |
111 | * VERY IMPORTANT: use "b" option to fopen() if you are on a machine that | 111 | * VERY IMPORTANT: use "b" option to fopen() if you are on a machine that |
112 | * requires it in order to write binary files. | 112 | * requires it in order to write binary files. |
113 | */ | 113 | */ |
114 | if ((outfile = fopen(filename, "wb")) == NULL) { | 114 | if ((outfile = fopen(filename, "wb")) == NULL) { |
115 | fprintf(stderr, "can't open %s\n", filename); | 115 | fprintf(stderr, "can't open %s\n", filename); |
116 | exit(1); | 116 | exit(1); |
117 | } | 117 | } |
118 | jpeg_stdio_dest(&cinfo, outfile); | 118 | jpeg_stdio_dest(&cinfo, outfile); |
119 | 119 | ||
120 | /* Step 3: set parameters for compression */ | 120 | /* Step 3: set parameters for compression */ |
121 | 121 | ||
122 | /* First we supply a description of the input image. | 122 | /* First we supply a description of the input image. |
123 | * Four fields of the cinfo struct must be filled in: | 123 | * Four fields of the cinfo struct must be filled in: |
124 | */ | 124 | */ |
125 | cinfo.image_width = image_width; /* image width and height, in pixels */ | 125 | cinfo.image_width = image_width; /* image width and height, in pixels */ |
126 | cinfo.image_height = image_height; | 126 | cinfo.image_height = image_height; |
127 | cinfo.input_components = 3; /* # of color components per pixel */ | 127 | cinfo.input_components = 3; /* # of color components per pixel */ |
128 | cinfo.in_color_space = JCS_RGB; /* colorspace of input image */ | 128 | cinfo.in_color_space = JCS_RGB; /* colorspace of input image */ |
129 | /* Now use the library's routine to set default compression parameters. | 129 | /* Now use the library's routine to set default compression parameters. |
130 | * (You must set at least cinfo.in_color_space before calling this, | 130 | * (You must set at least cinfo.in_color_space before calling this, |
131 | * since the defaults depend on the source color space.) | 131 | * since the defaults depend on the source color space.) |
132 | */ | 132 | */ |
133 | jpeg_set_defaults(&cinfo); | 133 | jpeg_set_defaults(&cinfo); |
134 | /* Now you can set any non-default parameters you wish to. | 134 | /* Now you can set any non-default parameters you wish to. |
135 | * Here we just illustrate the use of quality (quantization table) scaling: | 135 | * Here we just illustrate the use of quality (quantization table) scaling: |
136 | */ | 136 | */ |
137 | jpeg_set_quality(&cinfo, quality, TRUE /* limit to baseline-JPEG values */); | 137 | jpeg_set_quality(&cinfo, quality, TRUE /* limit to baseline-JPEG values */); |
138 | 138 | ||
139 | /* Step 4: Start compressor */ | 139 | /* Step 4: Start compressor */ |
140 | 140 | ||
141 | /* TRUE ensures that we will write a complete interchange-JPEG file. | 141 | /* TRUE ensures that we will write a complete interchange-JPEG file. |
142 | * Pass TRUE unless you are very sure of what you're doing. | 142 | * Pass TRUE unless you are very sure of what you're doing. |
143 | */ | 143 | */ |
144 | jpeg_start_compress(&cinfo, TRUE); | 144 | jpeg_start_compress(&cinfo, TRUE); |
145 | 145 | ||
146 | /* Step 5: while (scan lines remain to be written) */ | 146 | /* Step 5: while (scan lines remain to be written) */ |
147 | /* jpeg_write_scanlines(...); */ | 147 | /* jpeg_write_scanlines(...); */ |
148 | 148 | ||
149 | /* Here we use the library's state variable cinfo.next_scanline as the | 149 | /* Here we use the library's state variable cinfo.next_scanline as the |
150 | * loop counter, so that we don't have to keep track ourselves. | 150 | * loop counter, so that we don't have to keep track ourselves. |
151 | * To keep things simple, we pass one scanline per call; you can pass | 151 | * To keep things simple, we pass one scanline per call; you can pass |
152 | * more if you wish, though. | 152 | * more if you wish, though. |
153 | */ | 153 | */ |
154 | row_stride = image_width * 3; /* JSAMPLEs per row in image_buffer */ | 154 | row_stride = image_width * 3; /* JSAMPLEs per row in image_buffer */ |
155 | 155 | ||
156 | while (cinfo.next_scanline < cinfo.image_height) { | 156 | while (cinfo.next_scanline < cinfo.image_height) { |
157 | /* jpeg_write_scanlines expects an array of pointers to scanlines. | 157 | /* jpeg_write_scanlines expects an array of pointers to scanlines. |
158 | * Here the array is only one element long, but you could pass | 158 | * Here the array is only one element long, but you could pass |
159 | * more than one scanline at a time if that's more convenient. | 159 | * more than one scanline at a time if that's more convenient. |
160 | */ | 160 | */ |
161 | row_pointer[0] = & image_buffer[cinfo.next_scanline * row_stride]; | 161 | row_pointer[0] = & image_buffer[cinfo.next_scanline * row_stride]; |
162 | (void) jpeg_write_scanlines(&cinfo, row_pointer, 1); | 162 | (void) jpeg_write_scanlines(&cinfo, row_pointer, 1); |
163 | } | 163 | } |
164 | 164 | ||
165 | /* Step 6: Finish compression */ | 165 | /* Step 6: Finish compression */ |
166 | 166 | ||
167 | jpeg_finish_compress(&cinfo); | 167 | jpeg_finish_compress(&cinfo); |
168 | /* After finish_compress, we can close the output file. */ | 168 | /* After finish_compress, we can close the output file. */ |
169 | fclose(outfile); | 169 | fclose(outfile); |
170 | 170 | ||
171 | /* Step 7: release JPEG compression object */ | 171 | /* Step 7: release JPEG compression object */ |
172 | 172 | ||
173 | /* This is an important step since it will release a good deal of memory. */ | 173 | /* This is an important step since it will release a good deal of memory. */ |
174 | jpeg_destroy_compress(&cinfo); | 174 | jpeg_destroy_compress(&cinfo); |
175 | 175 | ||
176 | /* And we're done! */ | 176 | /* And we're done! */ |
177 | } | 177 | } |
178 | 178 | ||
179 | 179 | ||
180 | /* | 180 | /* |
181 | * SOME FINE POINTS: | 181 | * SOME FINE POINTS: |
182 | * | 182 | * |
183 | * In the above loop, we ignored the return value of jpeg_write_scanlines, | 183 | * In the above loop, we ignored the return value of jpeg_write_scanlines, |
184 | * which is the number of scanlines actually written. We could get away | 184 | * which is the number of scanlines actually written. We could get away |
185 | * with this because we were only relying on the value of cinfo.next_scanline, | 185 | * with this because we were only relying on the value of cinfo.next_scanline, |
186 | * which will be incremented correctly. If you maintain additional loop | 186 | * which will be incremented correctly. If you maintain additional loop |
187 | * variables then you should be careful to increment them properly. | 187 | * variables then you should be careful to increment them properly. |
188 | * Actually, for output to a stdio stream you needn't worry, because | 188 | * Actually, for output to a stdio stream you needn't worry, because |
189 | * then jpeg_write_scanlines will write all the lines passed (or else exit | 189 | * then jpeg_write_scanlines will write all the lines passed (or else exit |
190 | * with a fatal error). Partial writes can only occur if you use a data | 190 | * with a fatal error). Partial writes can only occur if you use a data |
191 | * destination module that can demand suspension of the compressor. | 191 | * destination module that can demand suspension of the compressor. |
192 | * (If you don't know what that's for, you don't need it.) | 192 | * (If you don't know what that's for, you don't need it.) |
193 | * | 193 | * |
194 | * If the compressor requires full-image buffers (for entropy-coding | 194 | * If the compressor requires full-image buffers (for entropy-coding |
195 | * optimization or a multi-scan JPEG file), it will create temporary | 195 | * optimization or a multi-scan JPEG file), it will create temporary |
196 | * files for anything that doesn't fit within the maximum-memory setting. | 196 | * files for anything that doesn't fit within the maximum-memory setting. |
197 | * (Note that temp files are NOT needed if you use the default parameters.) | 197 | * (Note that temp files are NOT needed if you use the default parameters.) |
198 | * On some systems you may need to set up a signal handler to ensure that | 198 | * On some systems you may need to set up a signal handler to ensure that |
199 | * temporary files are deleted if the program is interrupted. See libjpeg.txt. | 199 | * temporary files are deleted if the program is interrupted. See libjpeg.txt. |
200 | * | 200 | * |
201 | * Scanlines MUST be supplied in top-to-bottom order if you want your JPEG | 201 | * Scanlines MUST be supplied in top-to-bottom order if you want your JPEG |
202 | * files to be compatible with everyone else's. If you cannot readily read | 202 | * files to be compatible with everyone else's. If you cannot readily read |
203 | * your data in that order, you'll need an intermediate array to hold the | 203 | * your data in that order, you'll need an intermediate array to hold the |
204 | * image. See rdtarga.c or rdbmp.c for examples of handling bottom-to-top | 204 | * image. See rdtarga.c or rdbmp.c for examples of handling bottom-to-top |
205 | * source data using the JPEG code's internal virtual-array mechanisms. | 205 | * source data using the JPEG code's internal virtual-array mechanisms. |
206 | */ | 206 | */ |
207 | 207 | ||
208 | 208 | ||
209 | 209 | ||
210 | /******************** JPEG DECOMPRESSION SAMPLE INTERFACE *******************/ | 210 | /******************** JPEG DECOMPRESSION SAMPLE INTERFACE *******************/ |
211 | 211 | ||
212 | /* This half of the example shows how to read data from the JPEG decompressor. | 212 | /* This half of the example shows how to read data from the JPEG decompressor. |
213 | * It's a bit more refined than the above, in that we show: | 213 | * It's a bit more refined than the above, in that we show: |
214 | * (a) how to modify the JPEG library's standard error-reporting behavior; | 214 | * (a) how to modify the JPEG library's standard error-reporting behavior; |
215 | * (b) how to allocate workspace using the library's memory manager. | 215 | * (b) how to allocate workspace using the library's memory manager. |
216 | * | 216 | * |
217 | * Just to make this example a little different from the first one, we'll | 217 | * Just to make this example a little different from the first one, we'll |
218 | * assume that we do not intend to put the whole image into an in-memory | 218 | * assume that we do not intend to put the whole image into an in-memory |
219 | * buffer, but to send it line-by-line someplace else. We need a one- | 219 | * buffer, but to send it line-by-line someplace else. We need a one- |
220 | * scanline-high JSAMPLE array as a work buffer, and we will let the JPEG | 220 | * scanline-high JSAMPLE array as a work buffer, and we will let the JPEG |
221 | * memory manager allocate it for us. This approach is actually quite useful | 221 | * memory manager allocate it for us. This approach is actually quite useful |
222 | * because we don't need to remember to deallocate the buffer separately: it | 222 | * because we don't need to remember to deallocate the buffer separately: it |
223 | * will go away automatically when the JPEG object is cleaned up. | 223 | * will go away automatically when the JPEG object is cleaned up. |
224 | */ | 224 | */ |
225 | 225 | ||
226 | 226 | ||
227 | /* | 227 | /* |
228 | * ERROR HANDLING: | 228 | * ERROR HANDLING: |
229 | * | 229 | * |
230 | * The JPEG library's standard error handler (jerror.c) is divided into | 230 | * The JPEG library's standard error handler (jerror.c) is divided into |
231 | * several "methods" which you can override individually. This lets you | 231 | * several "methods" which you can override individually. This lets you |
232 | * adjust the behavior without duplicating a lot of code, which you might | 232 | * adjust the behavior without duplicating a lot of code, which you might |
233 | * have to update with each future release. | 233 | * have to update with each future release. |
234 | * | 234 | * |
235 | * Our example here shows how to override the "error_exit" method so that | 235 | * Our example here shows how to override the "error_exit" method so that |
236 | * control is returned to the library's caller when a fatal error occurs, | 236 | * control is returned to the library's caller when a fatal error occurs, |
237 | * rather than calling exit() as the standard error_exit method does. | 237 | * rather than calling exit() as the standard error_exit method does. |
238 | * | 238 | * |
239 | * We use C's setjmp/longjmp facility to return control. This means that the | 239 | * We use C's setjmp/longjmp facility to return control. This means that the |
240 | * routine which calls the JPEG library must first execute a setjmp() call to | 240 | * routine which calls the JPEG library must first execute a setjmp() call to |
241 | * establish the return point. We want the replacement error_exit to do a | 241 | * establish the return point. We want the replacement error_exit to do a |
242 | * longjmp(). But we need to make the setjmp buffer accessible to the | 242 | * longjmp(). But we need to make the setjmp buffer accessible to the |
243 | * error_exit routine. To do this, we make a private extension of the | 243 | * error_exit routine. To do this, we make a private extension of the |
244 | * standard JPEG error handler object. (If we were using C++, we'd say we | 244 | * standard JPEG error handler object. (If we were using C++, we'd say we |
245 | * were making a subclass of the regular error handler.) | 245 | * were making a subclass of the regular error handler.) |
246 | * | 246 | * |
247 | * Here's the extended error handler struct: | 247 | * Here's the extended error handler struct: |
248 | */ | 248 | */ |
249 | 249 | ||
250 | struct my_error_mgr { | 250 | struct my_error_mgr { |
251 | struct jpeg_error_mgr pub; /* "public" fields */ | 251 | struct jpeg_error_mgr pub; /* "public" fields */ |
252 | 252 | ||
253 | jmp_buf setjmp_buffer; /* for return to caller */ | 253 | jmp_buf setjmp_buffer; /* for return to caller */ |
254 | }; | 254 | }; |
255 | 255 | ||
256 | typedef struct my_error_mgr * my_error_ptr; | 256 | typedef struct my_error_mgr * my_error_ptr; |
257 | 257 | ||
258 | /* | 258 | /* |
259 | * Here's the routine that will replace the standard error_exit method: | 259 | * Here's the routine that will replace the standard error_exit method: |
260 | */ | 260 | */ |
261 | 261 | ||
262 | METHODDEF(void) | 262 | METHODDEF(void) |
263 | my_error_exit (j_common_ptr cinfo) | 263 | my_error_exit (j_common_ptr cinfo) |
264 | { | 264 | { |
265 | /* cinfo->err really points to a my_error_mgr struct, so coerce pointer */ | 265 | /* cinfo->err really points to a my_error_mgr struct, so coerce pointer */ |
266 | my_error_ptr myerr = (my_error_ptr) cinfo->err; | 266 | my_error_ptr myerr = (my_error_ptr) cinfo->err; |
267 | 267 | ||
268 | /* Always display the message. */ | 268 | /* Always display the message. */ |
269 | /* We could postpone this until after returning, if we chose. */ | 269 | /* We could postpone this until after returning, if we chose. */ |
270 | (*cinfo->err->output_message) (cinfo); | 270 | (*cinfo->err->output_message) (cinfo); |
271 | 271 | ||
272 | /* Return control to the setjmp point */ | 272 | /* Return control to the setjmp point */ |
273 | longjmp(myerr->setjmp_buffer, 1); | 273 | longjmp(myerr->setjmp_buffer, 1); |
274 | } | 274 | } |
275 | 275 | ||
276 | 276 | ||
277 | /* | 277 | /* |
278 | * Sample routine for JPEG decompression. We assume that the source file name | 278 | * Sample routine for JPEG decompression. We assume that the source file name |
279 | * is passed in. We want to return 1 on success, 0 on error. | 279 | * is passed in. We want to return 1 on success, 0 on error. |
280 | */ | 280 | */ |
281 | 281 | ||
282 | 282 | ||
283 | GLOBAL(int) | 283 | GLOBAL(int) |
284 | read_JPEG_file (char * filename) | 284 | read_JPEG_file (char * filename) |
285 | { | 285 | { |
286 | /* This struct contains the JPEG decompression parameters and pointers to | 286 | /* This struct contains the JPEG decompression parameters and pointers to |
287 | * working space (which is allocated as needed by the JPEG library). | 287 | * working space (which is allocated as needed by the JPEG library). |
288 | */ | 288 | */ |
289 | struct jpeg_decompress_struct cinfo; | 289 | struct jpeg_decompress_struct cinfo; |
290 | /* We use our private extension JPEG error handler. | 290 | /* We use our private extension JPEG error handler. |
291 | * Note that this struct must live as long as the main JPEG parameter | 291 | * Note that this struct must live as long as the main JPEG parameter |
292 | * struct, to avoid dangling-pointer problems. | 292 | * struct, to avoid dangling-pointer problems. |
293 | */ | 293 | */ |
294 | struct my_error_mgr jerr; | 294 | struct my_error_mgr jerr; |
295 | /* More stuff */ | 295 | /* More stuff */ |
296 | FILE * infile; /* source file */ | 296 | FILE * infile; /* source file */ |
297 | JSAMPARRAY buffer; /* Output row buffer */ | 297 | JSAMPARRAY buffer; /* Output row buffer */ |
298 | int row_stride; /* physical row width in output buffer */ | 298 | int row_stride; /* physical row width in output buffer */ |
299 | 299 | ||
300 | /* In this example we want to open the input file before doing anything else, | 300 | /* In this example we want to open the input file before doing anything else, |
301 | * so that the setjmp() error recovery below can assume the file is open. | 301 | * so that the setjmp() error recovery below can assume the file is open. |
302 | * VERY IMPORTANT: use "b" option to fopen() if you are on a machine that | 302 | * VERY IMPORTANT: use "b" option to fopen() if you are on a machine that |
303 | * requires it in order to read binary files. | 303 | * requires it in order to read binary files. |
304 | */ | 304 | */ |
305 | 305 | ||
306 | if ((infile = fopen(filename, "rb")) == NULL) { | 306 | if ((infile = fopen(filename, "rb")) == NULL) { |
307 | fprintf(stderr, "can't open %s\n", filename); | 307 | fprintf(stderr, "can't open %s\n", filename); |
308 | return 0; | 308 | return 0; |
309 | } | 309 | } |
310 | 310 | ||
311 | /* Step 1: allocate and initialize JPEG decompression object */ | 311 | /* Step 1: allocate and initialize JPEG decompression object */ |
312 | 312 | ||
313 | /* We set up the normal JPEG error routines, then override error_exit. */ | 313 | /* We set up the normal JPEG error routines, then override error_exit. */ |
314 | cinfo.err = jpeg_std_error(&jerr.pub); | 314 | cinfo.err = jpeg_std_error(&jerr.pub); |
315 | jerr.pub.error_exit = my_error_exit; | 315 | jerr.pub.error_exit = my_error_exit; |
316 | /* Establish the setjmp return context for my_error_exit to use. */ | 316 | /* Establish the setjmp return context for my_error_exit to use. */ |
317 | if (setjmp(jerr.setjmp_buffer)) { | 317 | if (setjmp(jerr.setjmp_buffer)) { |
318 | /* If we get here, the JPEG code has signaled an error. | 318 | /* If we get here, the JPEG code has signaled an error. |
319 | * We need to clean up the JPEG object, close the input file, and return. | 319 | * We need to clean up the JPEG object, close the input file, and return. |
320 | */ | 320 | */ |
321 | jpeg_destroy_decompress(&cinfo); | 321 | jpeg_destroy_decompress(&cinfo); |
322 | fclose(infile); | 322 | fclose(infile); |
323 | return 0; | 323 | return 0; |
324 | } | 324 | } |
325 | /* Now we can initialize the JPEG decompression object. */ | 325 | /* Now we can initialize the JPEG decompression object. */ |
326 | jpeg_create_decompress(&cinfo); | 326 | jpeg_create_decompress(&cinfo); |
327 | 327 | ||
328 | /* Step 2: specify data source (eg, a file) */ | 328 | /* Step 2: specify data source (eg, a file) */ |
329 | 329 | ||
330 | jpeg_stdio_src(&cinfo, infile); | 330 | jpeg_stdio_src(&cinfo, infile); |
331 | 331 | ||
332 | /* Step 3: read file parameters with jpeg_read_header() */ | 332 | /* Step 3: read file parameters with jpeg_read_header() */ |
333 | 333 | ||
334 | (void) jpeg_read_header(&cinfo, TRUE); | 334 | (void) jpeg_read_header(&cinfo, TRUE); |
335 | /* We can ignore the return value from jpeg_read_header since | 335 | /* We can ignore the return value from jpeg_read_header since |
336 | * (a) suspension is not possible with the stdio data source, and | 336 | * (a) suspension is not possible with the stdio data source, and |
337 | * (b) we passed TRUE to reject a tables-only JPEG file as an error. | 337 | * (b) we passed TRUE to reject a tables-only JPEG file as an error. |
338 | * See libjpeg.txt for more info. | 338 | * See libjpeg.txt for more info. |
339 | */ | 339 | */ |
340 | 340 | ||
341 | /* Step 4: set parameters for decompression */ | 341 | /* Step 4: set parameters for decompression */ |
342 | 342 | ||
343 | /* In this example, we don't need to change any of the defaults set by | 343 | /* In this example, we don't need to change any of the defaults set by |
344 | * jpeg_read_header(), so we do nothing here. | 344 | * jpeg_read_header(), so we do nothing here. |
345 | */ | 345 | */ |
346 | 346 | ||
347 | /* Step 5: Start decompressor */ | 347 | /* Step 5: Start decompressor */ |
348 | 348 | ||
349 | (void) jpeg_start_decompress(&cinfo); | 349 | (void) jpeg_start_decompress(&cinfo); |
350 | /* We can ignore the return value since suspension is not possible | 350 | /* We can ignore the return value since suspension is not possible |
351 | * with the stdio data source. | 351 | * with the stdio data source. |
352 | */ | 352 | */ |
353 | 353 | ||
354 | /* We may need to do some setup of our own at this point before reading | 354 | /* We may need to do some setup of our own at this point before reading |
355 | * the data. After jpeg_start_decompress() we have the correct scaled | 355 | * the data. After jpeg_start_decompress() we have the correct scaled |
356 | * output image dimensions available, as well as the output colormap | 356 | * output image dimensions available, as well as the output colormap |
357 | * if we asked for color quantization. | 357 | * if we asked for color quantization. |
358 | * In this example, we need to make an output work buffer of the right size. | 358 | * In this example, we need to make an output work buffer of the right size. |
359 | */ | 359 | */ |
360 | /* JSAMPLEs per row in output buffer */ | 360 | /* JSAMPLEs per row in output buffer */ |
361 | row_stride = cinfo.output_width * cinfo.output_components; | 361 | row_stride = cinfo.output_width * cinfo.output_components; |
362 | /* Make a one-row-high sample array that will go away when done with image */ | 362 | /* Make a one-row-high sample array that will go away when done with image */ |
363 | buffer = (*cinfo.mem->alloc_sarray) | 363 | buffer = (*cinfo.mem->alloc_sarray) |
364 | ((j_common_ptr) &cinfo, JPOOL_IMAGE, row_stride, 1); | 364 | ((j_common_ptr) &cinfo, JPOOL_IMAGE, row_stride, 1); |
365 | 365 | ||
366 | /* Step 6: while (scan lines remain to be read) */ | 366 | /* Step 6: while (scan lines remain to be read) */ |
367 | /* jpeg_read_scanlines(...); */ | 367 | /* jpeg_read_scanlines(...); */ |
368 | 368 | ||
369 | /* Here we use the library's state variable cinfo.output_scanline as the | 369 | /* Here we use the library's state variable cinfo.output_scanline as the |
370 | * loop counter, so that we don't have to keep track ourselves. | 370 | * loop counter, so that we don't have to keep track ourselves. |
371 | */ | 371 | */ |
372 | while (cinfo.output_scanline < cinfo.output_height) { | 372 | while (cinfo.output_scanline < cinfo.output_height) { |
373 | /* jpeg_read_scanlines expects an array of pointers to scanlines. | 373 | /* jpeg_read_scanlines expects an array of pointers to scanlines. |
374 | * Here the array is only one element long, but you could ask for | 374 | * Here the array is only one element long, but you could ask for |
375 | * more than one scanline at a time if that's more convenient. | 375 | * more than one scanline at a time if that's more convenient. |
376 | */ | 376 | */ |
377 | (void) jpeg_read_scanlines(&cinfo, buffer, 1); | 377 | (void) jpeg_read_scanlines(&cinfo, buffer, 1); |
378 | /* Assume put_scanline_someplace wants a pointer and sample count. */ | 378 | /* Assume put_scanline_someplace wants a pointer and sample count. */ |
379 | put_scanline_someplace(buffer[0], row_stride); | 379 | put_scanline_someplace(buffer[0], row_stride); |
380 | } | 380 | } |
381 | 381 | ||
382 | /* Step 7: Finish decompression */ | 382 | /* Step 7: Finish decompression */ |
383 | 383 | ||
384 | (void) jpeg_finish_decompress(&cinfo); | 384 | (void) jpeg_finish_decompress(&cinfo); |
385 | /* We can ignore the return value since suspension is not possible | 385 | /* We can ignore the return value since suspension is not possible |
386 | * with the stdio data source. | 386 | * with the stdio data source. |
387 | */ | 387 | */ |
388 | 388 | ||
389 | /* Step 8: Release JPEG decompression object */ | 389 | /* Step 8: Release JPEG decompression object */ |
390 | 390 | ||
391 | /* This is an important step since it will release a good deal of memory. */ | 391 | /* This is an important step since it will release a good deal of memory. */ |
392 | jpeg_destroy_decompress(&cinfo); | 392 | jpeg_destroy_decompress(&cinfo); |
393 | 393 | ||
394 | /* After finish_decompress, we can close the input file. | 394 | /* After finish_decompress, we can close the input file. |
395 | * Here we postpone it until after no more JPEG errors are possible, | 395 | * Here we postpone it until after no more JPEG errors are possible, |
396 | * so as to simplify the setjmp error logic above. (Actually, I don't | 396 | * so as to simplify the setjmp error logic above. (Actually, I don't |
397 | * think that jpeg_destroy can do an error exit, but why assume anything...) | 397 | * think that jpeg_destroy can do an error exit, but why assume anything...) |
398 | */ | 398 | */ |
399 | fclose(infile); | 399 | fclose(infile); |
400 | 400 | ||
401 | /* At this point you may want to check to see whether any corrupt-data | 401 | /* At this point you may want to check to see whether any corrupt-data |
402 | * warnings occurred (test whether jerr.pub.num_warnings is nonzero). | 402 | * warnings occurred (test whether jerr.pub.num_warnings is nonzero). |
403 | */ | 403 | */ |
404 | 404 | ||
405 | /* And we're done! */ | 405 | /* And we're done! */ |
406 | return 1; | 406 | return 1; |
407 | } | 407 | } |
408 | 408 | ||
409 | 409 | ||
410 | /* | 410 | /* |
411 | * SOME FINE POINTS: | 411 | * SOME FINE POINTS: |
412 | * | 412 | * |
413 | * In the above code, we ignored the return value of jpeg_read_scanlines, | 413 | * In the above code, we ignored the return value of jpeg_read_scanlines, |
414 | * which is the number of scanlines actually read. We could get away with | 414 | * which is the number of scanlines actually read. We could get away with |
415 | * this because we asked for only one line at a time and we weren't using | 415 | * this because we asked for only one line at a time and we weren't using |
416 | * a suspending data source. See libjpeg.txt for more info. | 416 | * a suspending data source. See libjpeg.txt for more info. |
417 | * | 417 | * |
418 | * We cheated a bit by calling alloc_sarray() after jpeg_start_decompress(); | 418 | * We cheated a bit by calling alloc_sarray() after jpeg_start_decompress(); |
419 | * we should have done it beforehand to ensure that the space would be | 419 | * we should have done it beforehand to ensure that the space would be |
420 | * counted against the JPEG max_memory setting. In some systems the above | 420 | * counted against the JPEG max_memory setting. In some systems the above |
421 | * code would risk an out-of-memory error. However, in general we don't | 421 | * code would risk an out-of-memory error. However, in general we don't |
422 | * know the output image dimensions before jpeg_start_decompress(), unless we | 422 | * know the output image dimensions before jpeg_start_decompress(), unless we |
423 | * call jpeg_calc_output_dimensions(). See libjpeg.txt for more about this. | 423 | * call jpeg_calc_output_dimensions(). See libjpeg.txt for more about this. |
424 | * | 424 | * |
425 | * Scanlines are returned in the same order as they appear in the JPEG file, | 425 | * Scanlines are returned in the same order as they appear in the JPEG file, |
426 | * which is standardly top-to-bottom. If you must emit data bottom-to-top, | 426 | * which is standardly top-to-bottom. If you must emit data bottom-to-top, |
427 | * you can use one of the virtual arrays provided by the JPEG memory manager | 427 | * you can use one of the virtual arrays provided by the JPEG memory manager |
428 | * to invert the data. See wrbmp.c for an example. | 428 | * to invert the data. See wrbmp.c for an example. |
429 | * | 429 | * |
430 | * As with compression, some operating modes may require temporary files. | 430 | * As with compression, some operating modes may require temporary files. |
431 | * On some systems you may need to set up a signal handler to ensure that | 431 | * On some systems you may need to set up a signal handler to ensure that |
432 | * temporary files are deleted if the program is interrupted. See libjpeg.txt. | 432 | * temporary files are deleted if the program is interrupted. See libjpeg.txt. |
433 | */ | 433 | */ |