diff options
Diffstat (limited to '')
-rw-r--r-- | libraries/irrlicht-1.8/source/Irrlicht/jpeglib/jdatadst.c | 267 |
1 files changed, 267 insertions, 0 deletions
diff --git a/libraries/irrlicht-1.8/source/Irrlicht/jpeglib/jdatadst.c b/libraries/irrlicht-1.8/source/Irrlicht/jpeglib/jdatadst.c new file mode 100644 index 0000000..d22feb0 --- /dev/null +++ b/libraries/irrlicht-1.8/source/Irrlicht/jpeglib/jdatadst.c | |||
@@ -0,0 +1,267 @@ | |||
1 | /* | ||
2 | * jdatadst.c | ||
3 | * | ||
4 | * Copyright (C) 1994-1996, Thomas G. Lane. | ||
5 | * Modified 2009-2012 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 compression data destination routines for the case of | ||
10 | * emitting JPEG data to memory or to a file (or any stdio stream). | ||
11 | * While these routines are sufficient for most applications, | ||
12 | * some will want to use a different destination manager. | ||
13 | * IMPORTANT: we assume that fwrite() will correctly transcribe an array of | ||
14 | * JOCTETs into 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 | #ifndef HAVE_STDLIB_H /* <stdlib.h> should declare malloc(),free() */ | ||
24 | extern void * malloc JPP((size_t size)); | ||
25 | extern void free JPP((void *ptr)); | ||
26 | #endif | ||
27 | |||
28 | |||
29 | /* Expanded data destination object for stdio output */ | ||
30 | |||
31 | typedef struct { | ||
32 | struct jpeg_destination_mgr pub; /* public fields */ | ||
33 | |||
34 | FILE * outfile; /* target stream */ | ||
35 | JOCTET * buffer; /* start of buffer */ | ||
36 | } my_destination_mgr; | ||
37 | |||
38 | typedef my_destination_mgr * my_dest_ptr; | ||
39 | |||
40 | #define OUTPUT_BUF_SIZE 4096 /* choose an efficiently fwrite'able size */ | ||
41 | |||
42 | |||
43 | /* Expanded data destination object for memory output */ | ||
44 | |||
45 | typedef struct { | ||
46 | struct jpeg_destination_mgr pub; /* public fields */ | ||
47 | |||
48 | unsigned char ** outbuffer; /* target buffer */ | ||
49 | unsigned long * outsize; | ||
50 | unsigned char * newbuffer; /* newly allocated buffer */ | ||
51 | JOCTET * buffer; /* start of buffer */ | ||
52 | size_t bufsize; | ||
53 | } my_mem_destination_mgr; | ||
54 | |||
55 | typedef my_mem_destination_mgr * my_mem_dest_ptr; | ||
56 | |||
57 | |||
58 | /* | ||
59 | * Initialize destination --- called by jpeg_start_compress | ||
60 | * before any data is actually written. | ||
61 | */ | ||
62 | |||
63 | METHODDEF(void) | ||
64 | init_destination (j_compress_ptr cinfo) | ||
65 | { | ||
66 | my_dest_ptr dest = (my_dest_ptr) cinfo->dest; | ||
67 | |||
68 | /* Allocate the output buffer --- it will be released when done with image */ | ||
69 | dest->buffer = (JOCTET *) | ||
70 | (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE, | ||
71 | OUTPUT_BUF_SIZE * SIZEOF(JOCTET)); | ||
72 | |||
73 | dest->pub.next_output_byte = dest->buffer; | ||
74 | dest->pub.free_in_buffer = OUTPUT_BUF_SIZE; | ||
75 | } | ||
76 | |||
77 | METHODDEF(void) | ||
78 | init_mem_destination (j_compress_ptr cinfo) | ||
79 | { | ||
80 | /* no work necessary here */ | ||
81 | } | ||
82 | |||
83 | |||
84 | /* | ||
85 | * Empty the output buffer --- called whenever buffer fills up. | ||
86 | * | ||
87 | * In typical applications, this should write the entire output buffer | ||
88 | * (ignoring the current state of next_output_byte & free_in_buffer), | ||
89 | * reset the pointer & count to the start of the buffer, and return TRUE | ||
90 | * indicating that the buffer has been dumped. | ||
91 | * | ||
92 | * In applications that need to be able to suspend compression due to output | ||
93 | * overrun, a FALSE return indicates that the buffer cannot be emptied now. | ||
94 | * In this situation, the compressor will return to its caller (possibly with | ||
95 | * an indication that it has not accepted all the supplied scanlines). The | ||
96 | * application should resume compression after it has made more room in the | ||
97 | * output buffer. Note that there are substantial restrictions on the use of | ||
98 | * suspension --- see the documentation. | ||
99 | * | ||
100 | * When suspending, the compressor will back up to a convenient restart point | ||
101 | * (typically the start of the current MCU). next_output_byte & free_in_buffer | ||
102 | * indicate where the restart point will be if the current call returns FALSE. | ||
103 | * Data beyond this point will be regenerated after resumption, so do not | ||
104 | * write it out when emptying the buffer externally. | ||
105 | */ | ||
106 | |||
107 | METHODDEF(boolean) | ||
108 | empty_output_buffer (j_compress_ptr cinfo) | ||
109 | { | ||
110 | my_dest_ptr dest = (my_dest_ptr) cinfo->dest; | ||
111 | |||
112 | if (JFWRITE(dest->outfile, dest->buffer, OUTPUT_BUF_SIZE) != | ||
113 | (size_t) OUTPUT_BUF_SIZE) | ||
114 | ERREXIT(cinfo, JERR_FILE_WRITE); | ||
115 | |||
116 | dest->pub.next_output_byte = dest->buffer; | ||
117 | dest->pub.free_in_buffer = OUTPUT_BUF_SIZE; | ||
118 | |||
119 | return TRUE; | ||
120 | } | ||
121 | |||
122 | METHODDEF(boolean) | ||
123 | empty_mem_output_buffer (j_compress_ptr cinfo) | ||
124 | { | ||
125 | size_t nextsize; | ||
126 | JOCTET * nextbuffer; | ||
127 | my_mem_dest_ptr dest = (my_mem_dest_ptr) cinfo->dest; | ||
128 | |||
129 | /* Try to allocate new buffer with double size */ | ||
130 | nextsize = dest->bufsize * 2; | ||
131 | nextbuffer = (JOCTET *) malloc(nextsize); | ||
132 | |||
133 | if (nextbuffer == NULL) | ||
134 | ERREXIT1(cinfo, JERR_OUT_OF_MEMORY, 10); | ||
135 | |||
136 | MEMCOPY(nextbuffer, dest->buffer, dest->bufsize); | ||
137 | |||
138 | if (dest->newbuffer != NULL) | ||
139 | free(dest->newbuffer); | ||
140 | |||
141 | dest->newbuffer = nextbuffer; | ||
142 | |||
143 | dest->pub.next_output_byte = nextbuffer + dest->bufsize; | ||
144 | dest->pub.free_in_buffer = dest->bufsize; | ||
145 | |||
146 | dest->buffer = nextbuffer; | ||
147 | dest->bufsize = nextsize; | ||
148 | |||
149 | return TRUE; | ||
150 | } | ||
151 | |||
152 | |||
153 | /* | ||
154 | * Terminate destination --- called by jpeg_finish_compress | ||
155 | * after all data has been written. Usually needs to flush buffer. | ||
156 | * | ||
157 | * NB: *not* called by jpeg_abort or jpeg_destroy; surrounding | ||
158 | * application must deal with any cleanup that should happen even | ||
159 | * for error exit. | ||
160 | */ | ||
161 | |||
162 | METHODDEF(void) | ||
163 | term_destination (j_compress_ptr cinfo) | ||
164 | { | ||
165 | my_dest_ptr dest = (my_dest_ptr) cinfo->dest; | ||
166 | size_t datacount = OUTPUT_BUF_SIZE - dest->pub.free_in_buffer; | ||
167 | |||
168 | /* Write any data remaining in the buffer */ | ||
169 | if (datacount > 0) { | ||
170 | if (JFWRITE(dest->outfile, dest->buffer, datacount) != datacount) | ||
171 | ERREXIT(cinfo, JERR_FILE_WRITE); | ||
172 | } | ||
173 | fflush(dest->outfile); | ||
174 | /* Make sure we wrote the output file OK */ | ||
175 | if (ferror(dest->outfile)) | ||
176 | ERREXIT(cinfo, JERR_FILE_WRITE); | ||
177 | } | ||
178 | |||
179 | METHODDEF(void) | ||
180 | term_mem_destination (j_compress_ptr cinfo) | ||
181 | { | ||
182 | my_mem_dest_ptr dest = (my_mem_dest_ptr) cinfo->dest; | ||
183 | |||
184 | *dest->outbuffer = dest->buffer; | ||
185 | *dest->outsize = dest->bufsize - dest->pub.free_in_buffer; | ||
186 | } | ||
187 | |||
188 | |||
189 | /* | ||
190 | * Prepare for output to a stdio stream. | ||
191 | * The caller must have already opened the stream, and is responsible | ||
192 | * for closing it after finishing compression. | ||
193 | */ | ||
194 | |||
195 | GLOBAL(void) | ||
196 | jpeg_stdio_dest (j_compress_ptr cinfo, FILE * outfile) | ||
197 | { | ||
198 | my_dest_ptr dest; | ||
199 | |||
200 | /* The destination object is made permanent so that multiple JPEG images | ||
201 | * can be written to the same file without re-executing jpeg_stdio_dest. | ||
202 | * This makes it dangerous to use this manager and a different destination | ||
203 | * manager serially with the same JPEG object, because their private object | ||
204 | * sizes may be different. Caveat programmer. | ||
205 | */ | ||
206 | if (cinfo->dest == NULL) { /* first time for this JPEG object? */ | ||
207 | cinfo->dest = (struct jpeg_destination_mgr *) | ||
208 | (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_PERMANENT, | ||
209 | SIZEOF(my_destination_mgr)); | ||
210 | } | ||
211 | |||
212 | dest = (my_dest_ptr) cinfo->dest; | ||
213 | dest->pub.init_destination = init_destination; | ||
214 | dest->pub.empty_output_buffer = empty_output_buffer; | ||
215 | dest->pub.term_destination = term_destination; | ||
216 | dest->outfile = outfile; | ||
217 | } | ||
218 | |||
219 | |||
220 | /* | ||
221 | * Prepare for output to a memory buffer. | ||
222 | * The caller may supply an own initial buffer with appropriate size. | ||
223 | * Otherwise, or when the actual data output exceeds the given size, | ||
224 | * the library adapts the buffer size as necessary. | ||
225 | * The standard library functions malloc/free are used for allocating | ||
226 | * larger memory, so the buffer is available to the application after | ||
227 | * finishing compression, and then the application is responsible for | ||
228 | * freeing the requested memory. | ||
229 | */ | ||
230 | |||
231 | GLOBAL(void) | ||
232 | jpeg_mem_dest (j_compress_ptr cinfo, | ||
233 | unsigned char ** outbuffer, unsigned long * outsize) | ||
234 | { | ||
235 | my_mem_dest_ptr dest; | ||
236 | |||
237 | if (outbuffer == NULL || outsize == NULL) /* sanity check */ | ||
238 | ERREXIT(cinfo, JERR_BUFFER_SIZE); | ||
239 | |||
240 | /* The destination object is made permanent so that multiple JPEG images | ||
241 | * can be written to the same buffer without re-executing jpeg_mem_dest. | ||
242 | */ | ||
243 | if (cinfo->dest == NULL) { /* first time for this JPEG object? */ | ||
244 | cinfo->dest = (struct jpeg_destination_mgr *) | ||
245 | (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_PERMANENT, | ||
246 | SIZEOF(my_mem_destination_mgr)); | ||
247 | } | ||
248 | |||
249 | dest = (my_mem_dest_ptr) cinfo->dest; | ||
250 | dest->pub.init_destination = init_mem_destination; | ||
251 | dest->pub.empty_output_buffer = empty_mem_output_buffer; | ||
252 | dest->pub.term_destination = term_mem_destination; | ||
253 | dest->outbuffer = outbuffer; | ||
254 | dest->outsize = outsize; | ||
255 | dest->newbuffer = NULL; | ||
256 | |||
257 | if (*outbuffer == NULL || *outsize == 0) { | ||
258 | /* Allocate initial buffer */ | ||
259 | dest->newbuffer = *outbuffer = (unsigned char *) malloc(OUTPUT_BUF_SIZE); | ||
260 | if (dest->newbuffer == NULL) | ||
261 | ERREXIT1(cinfo, JERR_OUT_OF_MEMORY, 10); | ||
262 | *outsize = OUTPUT_BUF_SIZE; | ||
263 | } | ||
264 | |||
265 | dest->pub.next_output_byte = dest->buffer = *outbuffer; | ||
266 | dest->pub.free_in_buffer = dest->bufsize = *outsize; | ||
267 | } | ||