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 | } |
---|