1 | /* |
2 | * jdatadst.c |
3 | * |
4 | * This file was part of the Independent JPEG Group's software: |
5 | * Copyright (C) 1994-1996, Thomas G. Lane. |
6 | * Modified 2009-2012 by Guido Vollbeding. |
7 | * libjpeg-turbo Modifications: |
8 | * Copyright (C) 2013, 2016, D. R. Commander. |
9 | * For conditions of distribution and use, see the accompanying README.ijg |
10 | * file. |
11 | * |
12 | * This file contains compression data destination routines for the case of |
13 | * emitting JPEG data to memory or to a file (or any stdio stream). |
14 | * While these routines are sufficient for most applications, |
15 | * some will want to use a different destination manager. |
16 | * IMPORTANT: we assume that fwrite() will correctly transcribe an array of |
17 | * JOCTETs into 8-bit-wide elements on external storage. If char is wider |
18 | * than 8 bits on your machine, you may need to do some tweaking. |
19 | */ |
20 | |
21 | /* this is not a core library module, so it doesn't define JPEG_INTERNALS */ |
22 | #include "jinclude.h" |
23 | #include "jpeglib.h" |
24 | #include "jerror.h" |
25 | |
26 | #ifndef HAVE_STDLIB_H /* <stdlib.h> should declare malloc(),free() */ |
27 | extern void *malloc(size_t size); |
28 | extern void free(void *ptr); |
29 | #endif |
30 | |
31 | |
32 | /* Expanded data destination object for stdio output */ |
33 | |
34 | typedef struct { |
35 | struct jpeg_destination_mgr pub; /* public fields */ |
36 | |
37 | FILE *outfile; /* target stream */ |
38 | JOCTET *buffer; /* start of buffer */ |
39 | } my_destination_mgr; |
40 | |
41 | typedef my_destination_mgr *my_dest_ptr; |
42 | |
43 | #define OUTPUT_BUF_SIZE 4096 /* choose an efficiently fwrite'able size */ |
44 | |
45 | |
46 | #if JPEG_LIB_VERSION >= 80 || defined(MEM_SRCDST_SUPPORTED) |
47 | /* Expanded data destination object for memory output */ |
48 | |
49 | typedef struct { |
50 | struct jpeg_destination_mgr pub; /* public fields */ |
51 | |
52 | unsigned char **outbuffer; /* target buffer */ |
53 | unsigned long *outsize; |
54 | unsigned char *newbuffer; /* newly allocated buffer */ |
55 | JOCTET *buffer; /* start of buffer */ |
56 | size_t bufsize; |
57 | } my_mem_destination_mgr; |
58 | |
59 | typedef my_mem_destination_mgr *my_mem_dest_ptr; |
60 | #endif |
61 | |
62 | |
63 | /* |
64 | * Initialize destination --- called by jpeg_start_compress |
65 | * before any data is actually written. |
66 | */ |
67 | |
68 | METHODDEF(void) |
69 | init_destination(j_compress_ptr cinfo) |
70 | { |
71 | my_dest_ptr dest = (my_dest_ptr)cinfo->dest; |
72 | |
73 | /* Allocate the output buffer --- it will be released when done with image */ |
74 | dest->buffer = (JOCTET *) |
75 | (*cinfo->mem->alloc_small) ((j_common_ptr)cinfo, JPOOL_IMAGE, |
76 | OUTPUT_BUF_SIZE * sizeof(JOCTET)); |
77 | |
78 | dest->pub.next_output_byte = dest->buffer; |
79 | dest->pub.free_in_buffer = OUTPUT_BUF_SIZE; |
80 | } |
81 | |
82 | #if JPEG_LIB_VERSION >= 80 || defined(MEM_SRCDST_SUPPORTED) |
83 | METHODDEF(void) |
84 | init_mem_destination(j_compress_ptr cinfo) |
85 | { |
86 | /* no work necessary here */ |
87 | } |
88 | #endif |
89 | |
90 | |
91 | /* |
92 | * Empty the output buffer --- called whenever buffer fills up. |
93 | * |
94 | * In typical applications, this should write the entire output buffer |
95 | * (ignoring the current state of next_output_byte & free_in_buffer), |
96 | * reset the pointer & count to the start of the buffer, and return TRUE |
97 | * indicating that the buffer has been dumped. |
98 | * |
99 | * In applications that need to be able to suspend compression due to output |
100 | * overrun, a FALSE return indicates that the buffer cannot be emptied now. |
101 | * In this situation, the compressor will return to its caller (possibly with |
102 | * an indication that it has not accepted all the supplied scanlines). The |
103 | * application should resume compression after it has made more room in the |
104 | * output buffer. Note that there are substantial restrictions on the use of |
105 | * suspension --- see the documentation. |
106 | * |
107 | * When suspending, the compressor will back up to a convenient restart point |
108 | * (typically the start of the current MCU). next_output_byte & free_in_buffer |
109 | * indicate where the restart point will be if the current call returns FALSE. |
110 | * Data beyond this point will be regenerated after resumption, so do not |
111 | * write it out when emptying the buffer externally. |
112 | */ |
113 | |
114 | METHODDEF(boolean) |
115 | empty_output_buffer(j_compress_ptr cinfo) |
116 | { |
117 | my_dest_ptr dest = (my_dest_ptr)cinfo->dest; |
118 | |
119 | if (JFWRITE(dest->outfile, dest->buffer, OUTPUT_BUF_SIZE) != |
120 | (size_t)OUTPUT_BUF_SIZE) |
121 | ERREXIT(cinfo, JERR_FILE_WRITE); |
122 | |
123 | dest->pub.next_output_byte = dest->buffer; |
124 | dest->pub.free_in_buffer = OUTPUT_BUF_SIZE; |
125 | |
126 | return TRUE; |
127 | } |
128 | |
129 | #if JPEG_LIB_VERSION >= 80 || defined(MEM_SRCDST_SUPPORTED) |
130 | METHODDEF(boolean) |
131 | empty_mem_output_buffer(j_compress_ptr cinfo) |
132 | { |
133 | size_t nextsize; |
134 | JOCTET *nextbuffer; |
135 | my_mem_dest_ptr dest = (my_mem_dest_ptr)cinfo->dest; |
136 | |
137 | /* Try to allocate new buffer with double size */ |
138 | nextsize = dest->bufsize * 2; |
139 | nextbuffer = (JOCTET *)malloc(nextsize); |
140 | |
141 | if (nextbuffer == NULL) |
142 | ERREXIT1(cinfo, JERR_OUT_OF_MEMORY, 10); |
143 | |
144 | MEMCOPY(nextbuffer, dest->buffer, dest->bufsize); |
145 | |
146 | free(dest->newbuffer); |
147 | |
148 | dest->newbuffer = nextbuffer; |
149 | |
150 | dest->pub.next_output_byte = nextbuffer + dest->bufsize; |
151 | dest->pub.free_in_buffer = dest->bufsize; |
152 | |
153 | dest->buffer = nextbuffer; |
154 | dest->bufsize = nextsize; |
155 | |
156 | return TRUE; |
157 | } |
158 | #endif |
159 | |
160 | |
161 | /* |
162 | * Terminate destination --- called by jpeg_finish_compress |
163 | * after all data has been written. Usually needs to flush buffer. |
164 | * |
165 | * NB: *not* called by jpeg_abort or jpeg_destroy; surrounding |
166 | * application must deal with any cleanup that should happen even |
167 | * for error exit. |
168 | */ |
169 | |
170 | METHODDEF(void) |
171 | term_destination(j_compress_ptr cinfo) |
172 | { |
173 | my_dest_ptr dest = (my_dest_ptr)cinfo->dest; |
174 | size_t datacount = OUTPUT_BUF_SIZE - dest->pub.free_in_buffer; |
175 | |
176 | /* Write any data remaining in the buffer */ |
177 | if (datacount > 0) { |
178 | if (JFWRITE(dest->outfile, dest->buffer, datacount) != datacount) |
179 | ERREXIT(cinfo, JERR_FILE_WRITE); |
180 | } |
181 | fflush(dest->outfile); |
182 | /* Make sure we wrote the output file OK */ |
183 | if (ferror(dest->outfile)) |
184 | ERREXIT(cinfo, JERR_FILE_WRITE); |
185 | } |
186 | |
187 | #if JPEG_LIB_VERSION >= 80 || defined(MEM_SRCDST_SUPPORTED) |
188 | METHODDEF(void) |
189 | term_mem_destination(j_compress_ptr cinfo) |
190 | { |
191 | my_mem_dest_ptr dest = (my_mem_dest_ptr)cinfo->dest; |
192 | |
193 | *dest->outbuffer = dest->buffer; |
194 | *dest->outsize = (unsigned long)(dest->bufsize - dest->pub.free_in_buffer); |
195 | } |
196 | #endif |
197 | |
198 | |
199 | /* |
200 | * Prepare for output to a stdio stream. |
201 | * The caller must have already opened the stream, and is responsible |
202 | * for closing it after finishing compression. |
203 | */ |
204 | |
205 | GLOBAL(void) |
206 | jpeg_stdio_dest(j_compress_ptr cinfo, FILE *outfile) |
207 | { |
208 | my_dest_ptr dest; |
209 | |
210 | /* The destination object is made permanent so that multiple JPEG images |
211 | * can be written to the same file without re-executing jpeg_stdio_dest. |
212 | */ |
213 | if (cinfo->dest == NULL) { /* first time for this JPEG object? */ |
214 | cinfo->dest = (struct jpeg_destination_mgr *) |
215 | (*cinfo->mem->alloc_small) ((j_common_ptr)cinfo, JPOOL_PERMANENT, |
216 | sizeof(my_destination_mgr)); |
217 | } else if (cinfo->dest->init_destination != init_destination) { |
218 | /* It is unsafe to reuse the existing destination manager unless it was |
219 | * created by this function. Otherwise, there is no guarantee that the |
220 | * opaque structure is the right size. Note that we could just create a |
221 | * new structure, but the old structure would not be freed until |
222 | * jpeg_destroy_compress() was called. |
223 | */ |
224 | ERREXIT(cinfo, JERR_BUFFER_SIZE); |
225 | } |
226 | |
227 | dest = (my_dest_ptr)cinfo->dest; |
228 | dest->pub.init_destination = init_destination; |
229 | dest->pub.empty_output_buffer = empty_output_buffer; |
230 | dest->pub.term_destination = term_destination; |
231 | dest->outfile = outfile; |
232 | } |
233 | |
234 | |
235 | #if JPEG_LIB_VERSION >= 80 || defined(MEM_SRCDST_SUPPORTED) |
236 | /* |
237 | * Prepare for output to a memory buffer. |
238 | * The caller may supply an own initial buffer with appropriate size. |
239 | * Otherwise, or when the actual data output exceeds the given size, |
240 | * the library adapts the buffer size as necessary. |
241 | * The standard library functions malloc/free are used for allocating |
242 | * larger memory, so the buffer is available to the application after |
243 | * finishing compression, and then the application is responsible for |
244 | * freeing the requested memory. |
245 | * Note: An initial buffer supplied by the caller is expected to be |
246 | * managed by the application. The library does not free such buffer |
247 | * when allocating a larger buffer. |
248 | */ |
249 | |
250 | GLOBAL(void) |
251 | jpeg_mem_dest(j_compress_ptr cinfo, unsigned char **outbuffer, |
252 | unsigned long *outsize) |
253 | { |
254 | my_mem_dest_ptr dest; |
255 | |
256 | if (outbuffer == NULL || outsize == NULL) /* sanity check */ |
257 | ERREXIT(cinfo, JERR_BUFFER_SIZE); |
258 | |
259 | /* The destination object is made permanent so that multiple JPEG images |
260 | * can be written to the same buffer without re-executing jpeg_mem_dest. |
261 | */ |
262 | if (cinfo->dest == NULL) { /* first time for this JPEG object? */ |
263 | cinfo->dest = (struct jpeg_destination_mgr *) |
264 | (*cinfo->mem->alloc_small) ((j_common_ptr)cinfo, JPOOL_PERMANENT, |
265 | sizeof(my_mem_destination_mgr)); |
266 | } else if (cinfo->dest->init_destination != init_mem_destination) { |
267 | /* It is unsafe to reuse the existing destination manager unless it was |
268 | * created by this function. |
269 | */ |
270 | ERREXIT(cinfo, JERR_BUFFER_SIZE); |
271 | } |
272 | |
273 | dest = (my_mem_dest_ptr)cinfo->dest; |
274 | dest->pub.init_destination = init_mem_destination; |
275 | dest->pub.empty_output_buffer = empty_mem_output_buffer; |
276 | dest->pub.term_destination = term_mem_destination; |
277 | dest->outbuffer = outbuffer; |
278 | dest->outsize = outsize; |
279 | dest->newbuffer = NULL; |
280 | |
281 | if (*outbuffer == NULL || *outsize == 0) { |
282 | /* Allocate initial buffer */ |
283 | dest->newbuffer = *outbuffer = (unsigned char *)malloc(OUTPUT_BUF_SIZE); |
284 | if (dest->newbuffer == NULL) |
285 | ERREXIT1(cinfo, JERR_OUT_OF_MEMORY, 10); |
286 | *outsize = OUTPUT_BUF_SIZE; |
287 | } |
288 | |
289 | dest->pub.next_output_byte = dest->buffer = *outbuffer; |
290 | dest->pub.free_in_buffer = dest->bufsize = *outsize; |
291 | } |
292 | #endif |
293 | |