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 * Note: An initial buffer supplied by the caller is expected to be 230 * managed by the application. The library does not free such buffer 231 * when allocating a larger buffer. 232 */ 233 234 GLOBAL(void) 235 jpeg_mem_dest (j_compress_ptr cinfo, 236 unsigned char ** outbuffer, unsigned long * outsize) 237 { 238 my_mem_dest_ptr dest; 239 240 if (outbuffer == NULL || outsize == NULL) /* sanity check */ 241 ERREXIT(cinfo, JERR_BUFFER_SIZE); 242 243 /* The destination object is made permanent so that multiple JPEG images 244 * can be written to the same buffer without re-executing jpeg_mem_dest. 245 */ 246 if (cinfo->dest == NULL) { /* first time for this JPEG object? */ 247 cinfo->dest = (struct jpeg_destination_mgr *) 248 (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_PERMANENT, 249 SIZEOF(my_mem_destination_mgr)); 250 } 251 252 dest = (my_mem_dest_ptr) cinfo->dest; 253 dest->pub.init_destination = init_mem_destination; 254 dest->pub.empty_output_buffer = empty_mem_output_buffer; 255 dest->pub.term_destination = term_mem_destination; 256 dest->outbuffer = outbuffer; 257 dest->outsize = outsize; 258 dest->newbuffer = NULL; 259 260 if (*outbuffer == NULL || *outsize == 0) { 261 /* Allocate initial buffer */ 262 dest->newbuffer = *outbuffer = (unsigned char *) malloc(OUTPUT_BUF_SIZE); 263 if (dest->newbuffer == NULL) 264 ERREXIT1(cinfo, JERR_OUT_OF_MEMORY, 10); 265 *outsize = OUTPUT_BUF_SIZE; 266 } 267 268 dest->pub.next_output_byte = dest->buffer = *outbuffer; 269 dest->pub.free_in_buffer = dest->bufsize = *outsize; 270 } 271
